diff --git a/dll/win32/oleaut32/CMakeLists.txt b/dll/win32/oleaut32/CMakeLists.txt
index 775630302fc..be73464536f 100644
--- a/dll/win32/oleaut32/CMakeLists.txt
+++ b/dll/win32/oleaut32/CMakeLists.txt
@@ -3,14 +3,11 @@ remove_definitions(-D_WIN32_WINNT=0x502)
 add_definitions(-D_WIN32_WINNT=0x600)
 
 add_definitions(
-    -D__ROS_LONG64__
-    -DCOM_NO_WINDOWS_H
     -D_OLEAUT32_
     -DPROXY_DELEGATION
     -DWINE_REGISTER_DLL
     -DENTRY_PREFIX=OLEAUTPS_
-    -DPROXY_CLSID=CLSID_PSFactoryBuffer
-    -D_CRT_NON_CONFORMING_SWPRINTFS)
+    -DPROXY_CLSID=CLSID_PSFactoryBuffer)
 
 spec2def(oleaut32.dll oleaut32.spec ADD_IMPORTLIB)
 add_rpcproxy_files(oleaut32_oaidl.idl oleaut32_ocidl.idl)
@@ -25,6 +22,7 @@ list(APPEND SOURCE
     olepropframe.c
     recinfo.c
     safearray.c
+    thunks.c
     typelib.c
     usrmarshal.c
     varformat.c
@@ -60,8 +58,9 @@ endif()
 
 add_idl_headers(oleaut32_idlheader oleaut32_oaidl.idl)
 add_dependencies(oleaut32 oleaut32_idlheader)
+add_idl_reg_scripts(oleaut32 registry oleaut32_oaidl.idl oleaut32_ocidl.idl)
 set_module_type(oleaut32 win32dll)
-target_link_libraries(oleaut32 wine wineldr uuid ${PSEH_LIB} oldnames)
+target_link_libraries(oleaut32 wine wineldr uuid ${PSEH_LIB} oldnames wine_dll_canunload)
 add_delay_importlibs(oleaut32 comctl32 urlmon windowscodecs)
 add_importlibs(oleaut32 ole32 rpcrt4 user32 gdi32 advapi32 kernel32_vista msvcrt kernel32 ntdll)
 add_pch(oleaut32 precomp.h "${PCH_SKIP_SOURCE}")
diff --git a/dll/win32/oleaut32/connpt.c b/dll/win32/oleaut32/connpt.c
index 0405d3857c8..9275b7306d6 100644
--- a/dll/win32/oleaut32/connpt.c
+++ b/dll/win32/oleaut32/connpt.c
@@ -101,9 +101,6 @@ static inline EnumConnectionsImpl *impl_from_IEnumConnections(IEnumConnections *
   return CONTAINING_RECORD(iface, EnumConnectionsImpl, IEnumConnections_iface);
 }
 
-/************************************************************************
- * ConnectionPointImpl_Destroy
- */
 static void ConnectionPointImpl_Destroy(ConnectionPointImpl *Obj)
 {
   DWORD i;
@@ -113,16 +110,11 @@ static void ConnectionPointImpl_Destroy(ConnectionPointImpl *Obj)
       Obj->sinks[i] = NULL;
     }
   }
-  HeapFree(GetProcessHeap(), 0, Obj->sinks);
-  HeapFree(GetProcessHeap(), 0, Obj);
+  free(Obj->sinks);
+  free(Obj);
   return;
 }
 
-/************************************************************************
- * ConnectionPointImpl_QueryInterface (IUnknown)
- *
- * See Windows documentation for more details on IUnknown methods.
- */
 static HRESULT WINAPI ConnectionPointImpl_QueryInterface(
   IConnectionPoint*  iface,
   REFIID  riid,
@@ -160,47 +152,29 @@ static HRESULT WINAPI ConnectionPointImpl_QueryInterface(
   return S_OK;
 }
 
-
-/************************************************************************
- * ConnectionPointImpl_AddRef (IUnknown)
- *
- * See Windows documentation for more details on IUnknown methods.
- */
 static ULONG WINAPI ConnectionPointImpl_AddRef(IConnectionPoint* iface)
 {
   ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
   ULONG refCount = InterlockedIncrement(&This->ref);
 
-  TRACE("(%p)->(ref before=%d)\n", This, refCount - 1);
+  TRACE("%p, refcount %lu.\n", iface, refCount);
 
   return refCount;
 }
 
-/************************************************************************
- * ConnectionPointImpl_Release (IUnknown)
- *
- * See Windows documentation for more details on IUnknown methods.
- */
 static ULONG WINAPI ConnectionPointImpl_Release(
       IConnectionPoint* iface)
 {
   ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
   ULONG refCount = InterlockedDecrement(&This->ref);
 
-  TRACE("(%p)->(ref before=%d)\n", This, refCount + 1);
+  TRACE("%p, refcount %lu.\n", iface, refCount);
 
-  /*
-   * If the reference count goes down to 0, perform suicide.
-   */
   if (!refCount) ConnectionPointImpl_Destroy(This);
 
   return refCount;
 }
 
-/************************************************************************
- * ConnectionPointImpl_GetConnectionInterface (IConnectionPoint)
- *
- */
 static HRESULT WINAPI ConnectionPointImpl_GetConnectionInterface(
 					       IConnectionPoint *iface,
 					       IID              *piid)
@@ -211,10 +185,6 @@ static HRESULT WINAPI ConnectionPointImpl_GetConnectionInterface(
   return S_OK;
 }
 
-/************************************************************************
- * ConnectionPointImpl_GetConnectionPointContainer (IConnectionPoint)
- *
- */
 static HRESULT WINAPI ConnectionPointImpl_GetConnectionPointContainer(
 				      IConnectionPoint           *iface,
 				      IConnectionPointContainer  **ppCPC)
@@ -225,10 +195,6 @@ static HRESULT WINAPI ConnectionPointImpl_GetConnectionPointContainer(
   return IUnknown_QueryInterface(This->Obj, &IID_IConnectionPointContainer, (void**)ppCPC);
 }
 
-/************************************************************************
- * ConnectionPointImpl_Advise (IConnectionPoint)
- *
- */
 static HRESULT WINAPI ConnectionPointImpl_Advise(IConnectionPoint *iface,
 						 IUnknown *lpUnk,
 						 DWORD *pdwCookie)
@@ -247,9 +213,9 @@ static HRESULT WINAPI ConnectionPointImpl_Advise(IConnectionPoint *iface,
       break;
   }
   if(i == This->maxSinks) {
+    This->sinks = realloc(This->sinks, (This->maxSinks + MAXSINKS) * sizeof(IUnknown*));
+    memset(This->sinks + This->maxSinks, 0, MAXSINKS * sizeof(IUnknown*));
     This->maxSinks += MAXSINKS;
-    This->sinks = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->sinks,
-			      This->maxSinks * sizeof(IUnknown *));
   }
   This->sinks[i] = lpSink;
   This->nSinks++;
@@ -258,15 +224,11 @@ static HRESULT WINAPI ConnectionPointImpl_Advise(IConnectionPoint *iface,
 }
 
 
-/************************************************************************
- * ConnectionPointImpl_Unadvise (IConnectionPoint)
- *
- */
-static HRESULT WINAPI ConnectionPointImpl_Unadvise(IConnectionPoint *iface,
-						   DWORD dwCookie)
+static HRESULT WINAPI ConnectionPointImpl_Unadvise(IConnectionPoint *iface, DWORD dwCookie)
 {
   ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
-  TRACE("(%p)->(%d)\n", This, dwCookie);
+
+  TRACE("%p, %#lx.\n", iface, dwCookie);
 
   if(dwCookie == 0 || dwCookie > This->maxSinks) return E_INVALIDARG;
 
@@ -278,13 +240,7 @@ static HRESULT WINAPI ConnectionPointImpl_Unadvise(IConnectionPoint *iface,
   return S_OK;
 }
 
-/************************************************************************
- * ConnectionPointImpl_EnumConnections (IConnectionPoint)
- *
- */
-static HRESULT WINAPI ConnectionPointImpl_EnumConnections(
-						    IConnectionPoint *iface,
-						    LPENUMCONNECTIONS *ppEnum)
+static HRESULT WINAPI ConnectionPointImpl_EnumConnections(IConnectionPoint *iface, IEnumConnections **ppEnum)
 {
   ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
   CONNECTDATA *pCD;
@@ -298,7 +254,7 @@ static HRESULT WINAPI ConnectionPointImpl_EnumConnections(
 
   if(This->nSinks == 0) return OLE_E_NOCONNECTION;
 
-  pCD = HeapAlloc(GetProcessHeap(), 0, sizeof(CONNECTDATA) * This->nSinks);
+  pCD = malloc(sizeof(CONNECTDATA) * This->nSinks);
 
   for(i = 0, nextslot = 0; i < This->maxSinks; i++) {
     if(This->sinks[i] != NULL) {
@@ -318,7 +274,7 @@ static HRESULT WINAPI ConnectionPointImpl_EnumConnections(
                                        &IID_IEnumConnections, (void**)ppEnum);
   IEnumConnections_Release(&EnumObj->IEnumConnections_iface);
 
-  HeapFree(GetProcessHeap(), 0, pCD);
+  free(pCD);
   return hr;
 }
 
@@ -337,20 +293,17 @@ static const IConnectionPointVtbl ConnectionPointImpl_VTable =
 
 static const IEnumConnectionsVtbl EnumConnectionsImpl_VTable;
 
-/************************************************************************
- * EnumConnectionsImpl_Construct
- */
 static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
 							  DWORD nSinks,
 							  CONNECTDATA *pCD)
 {
-  EnumConnectionsImpl *Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj));
+  EnumConnectionsImpl *Obj = malloc(sizeof(*Obj));
   DWORD i;
 
   Obj->IEnumConnections_iface.lpVtbl = &EnumConnectionsImpl_VTable;
   Obj->ref = 1;
   Obj->pUnk = pUnk;
-  Obj->pCD = HeapAlloc(GetProcessHeap(), 0, nSinks * sizeof(CONNECTDATA));
+  Obj->pCD = malloc(nSinks * sizeof(CONNECTDATA));
   Obj->nConns = nSinks;
   Obj->nCur = 0;
 
@@ -361,9 +314,6 @@ static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
   return Obj;
 }
 
-/************************************************************************
- * EnumConnectionsImpl_Destroy
- */
 static void EnumConnectionsImpl_Destroy(EnumConnectionsImpl *Obj)
 {
   DWORD i;
@@ -371,16 +321,11 @@ static void EnumConnectionsImpl_Destroy(EnumConnectionsImpl *Obj)
   for(i = 0; i < Obj->nConns; i++)
     IUnknown_Release(Obj->pCD[i].pUnk);
 
-  HeapFree(GetProcessHeap(), 0, Obj->pCD);
-  HeapFree(GetProcessHeap(), 0, Obj);
+  free(Obj->pCD);
+  free(Obj);
   return;
 }
 
-/************************************************************************
- * EnumConnectionsImpl_QueryInterface (IUnknown)
- *
- * See Windows documentation for more details on IUnknown methods.
- */
 static HRESULT WINAPI EnumConnectionsImpl_QueryInterface(
   IEnumConnections*  iface,
   REFIID  riid,
@@ -417,56 +362,37 @@ static HRESULT WINAPI EnumConnectionsImpl_QueryInterface(
   return S_OK;
 }
 
-
-/************************************************************************
- * EnumConnectionsImpl_AddRef (IUnknown)
- *
- * See Windows documentation for more details on IUnknown methods.
- */
 static ULONG WINAPI EnumConnectionsImpl_AddRef(IEnumConnections* iface)
 {
   EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
   ULONG refCount = InterlockedIncrement(&This->ref);
 
-  TRACE("(%p)->(ref before=%d)\n", This, refCount - 1);
+  TRACE("%p, refcount %lu.\n", iface, refCount);
 
   IUnknown_AddRef(This->pUnk);
   return refCount;
 }
 
-/************************************************************************
- * EnumConnectionsImpl_Release (IUnknown)
- *
- * See Windows documentation for more details on IUnknown methods.
- */
 static ULONG WINAPI EnumConnectionsImpl_Release(IEnumConnections* iface)
 {
   EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
   ULONG refCount = InterlockedDecrement(&This->ref);
 
-  TRACE("(%p)->(ref before=%d)\n", This, refCount + 1);
+  TRACE("%p, refcount %lu.\n", iface, refCount);
 
   IUnknown_Release(This->pUnk);
 
-  /*
-   * If the reference count goes down to 0, perform suicide.
-   */
   if (!refCount) EnumConnectionsImpl_Destroy(This);
 
   return refCount;
 }
 
-/************************************************************************
- * EnumConnectionsImpl_Next (IEnumConnections)
- *
- */
-static HRESULT WINAPI EnumConnectionsImpl_Next(IEnumConnections* iface,
-					       ULONG cConn, LPCONNECTDATA pCD,
-					       ULONG *pEnum)
+static HRESULT WINAPI EnumConnectionsImpl_Next(IEnumConnections* iface, ULONG cConn, LPCONNECTDATA pCD, ULONG *pEnum)
 {
   EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
   DWORD nRet = 0;
-  TRACE("(%p)->(%d, %p, %p)\n", This, cConn, pCD, pEnum);
+
+  TRACE("%p, %lu, %p, %p.\n", iface, cConn, pCD, pEnum);
 
   if(pEnum == NULL) {
     if(cConn != 1)
@@ -491,16 +417,11 @@ static HRESULT WINAPI EnumConnectionsImpl_Next(IEnumConnections* iface,
   return S_OK;
 }
 
-
-/************************************************************************
- * EnumConnectionsImpl_Skip (IEnumConnections)
- *
- */
-static HRESULT WINAPI EnumConnectionsImpl_Skip(IEnumConnections* iface,
-					       ULONG cSkip)
+static HRESULT WINAPI EnumConnectionsImpl_Skip(IEnumConnections* iface, ULONG cSkip)
 {
   EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
-  TRACE("(%p)->(%d)\n", This, cSkip);
+
+  TRACE("%p, %lu.\n", iface, cSkip);
 
   if(This->nCur + cSkip >= This->nConns)
     return S_FALSE;
@@ -510,11 +431,6 @@ static HRESULT WINAPI EnumConnectionsImpl_Skip(IEnumConnections* iface,
   return S_OK;
 }
 
-
-/************************************************************************
- * EnumConnectionsImpl_Reset (IEnumConnections)
- *
- */
 static HRESULT WINAPI EnumConnectionsImpl_Reset(IEnumConnections* iface)
 {
   EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
@@ -525,13 +441,7 @@ static HRESULT WINAPI EnumConnectionsImpl_Reset(IEnumConnections* iface)
   return S_OK;
 }
 
-
-/************************************************************************
- * EnumConnectionsImpl_Clone (IEnumConnections)
- *
- */
-static HRESULT WINAPI EnumConnectionsImpl_Clone(IEnumConnections* iface,
-						LPENUMCONNECTIONS *ppEnum)
+static HRESULT WINAPI EnumConnectionsImpl_Clone(IEnumConnections* iface, IEnumConnections **ppEnum)
 {
   EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
   EnumConnectionsImpl *newObj;
@@ -577,7 +487,7 @@ HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid,
   TRACE("(%p %s %p)\n", pUnk, debugstr_guid(riid), pCP);
 
   *pCP = NULL;
-  Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj));
+  Obj = malloc(sizeof(*Obj));
   if (!Obj)
     return E_OUTOFMEMORY;
 
@@ -586,7 +496,7 @@ HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid,
   Obj->ref = 1;
   Obj->iid = *riid;
   Obj->maxSinks = MAXSINKS;
-  Obj->sinks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IUnknown*) * MAXSINKS);
+  Obj->sinks = calloc(MAXSINKS, sizeof(IUnknown*));
   Obj->nSinks = 0;
 
   *pCP = &Obj->IConnectionPoint_iface;
diff --git a/dll/win32/oleaut32/connpt.h b/dll/win32/oleaut32/connpt.h
index e0bdd8b59b4..cac3ae62fa8 100644
--- a/dll/win32/oleaut32/connpt.h
+++ b/dll/win32/oleaut32/connpt.h
@@ -19,6 +19,6 @@
 #ifndef _CONNPT_H
 #define _CONNPT_H
 
-HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid, IConnectionPoint **pCP) DECLSPEC_HIDDEN;
+HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid, IConnectionPoint **pCP);
 
 #endif /* _CONNPT_H */
diff --git a/dll/win32/oleaut32/dispatch.c b/dll/win32/oleaut32/dispatch.c
index 7e6398a1621..7fa96e5af83 100644
--- a/dll/win32/oleaut32/dispatch.c
+++ b/dll/win32/oleaut32/dispatch.c
@@ -176,7 +176,7 @@ done:
  *  (linked at run-time), as opposed to early-bound (linked at compile time).
  *
  *  The interface is used by objects that wish to called by scripting
- *  languages such as VBA, in order to minimise the amount of COM and C/C++
+ *  languages such as VBA, in order to minimize the amount of COM and C/C++
  *  knowledge required, or by objects that wish to live out of process from code
  *  that will call their methods.
  *
@@ -248,7 +248,7 @@ static ULONG WINAPI StdDispatch_AddRef(LPDISPATCH iface)
     StdDispatch *This = impl_from_IDispatch(iface);
     ULONG refCount = InterlockedIncrement(&This->ref);
 
-    TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
+    TRACE("%p, refcount %lu.\n", iface, refCount);
 
     return refCount;
 }
@@ -263,7 +263,7 @@ static ULONG WINAPI StdDispatch_Release(LPDISPATCH iface)
     StdDispatch *This = impl_from_IDispatch(iface);
     ULONG refCount = InterlockedDecrement(&This->ref);
 
-    TRACE("(%p)->(ref before=%u)\n", This, refCount + 1);
+    TRACE("%p, refcount %lu.\n", iface, refCount);
 
     if (!refCount)
     {
@@ -319,7 +319,8 @@ static HRESULT WINAPI StdDispatch_GetTypeInfoCount(LPDISPATCH iface, UINT * pcti
 static HRESULT WINAPI StdDispatch_GetTypeInfo(LPDISPATCH iface, UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
 {
     StdDispatch *This = impl_from_IDispatch(iface);
-    TRACE("(%d, %x, %p)\n", iTInfo, lcid, ppTInfo);
+
+    TRACE("%d, %#lx, %p.\n", iTInfo, lcid, ppTInfo);
 
     *ppTInfo = NULL;
     if (iTInfo != 0)
@@ -360,7 +361,8 @@ static HRESULT WINAPI StdDispatch_GetTypeInfo(LPDISPATCH iface, UINT iTInfo, LCI
 static HRESULT WINAPI StdDispatch_GetIDsOfNames(LPDISPATCH iface, REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId)
 {
     StdDispatch *This = impl_from_IDispatch(iface);
-    TRACE("(%s, %p, %d, 0x%x, %p)\n", debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
+
+    TRACE("%s, %p, %d, %#lx, %p.\n", debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 
     if (!IsEqualGUID(riid, &IID_NULL))
     {
@@ -398,7 +400,8 @@ static HRESULT WINAPI StdDispatch_Invoke(LPDISPATCH iface, DISPID dispIdMember,
                                          EXCEPINFO * pExcepInfo, UINT * puArgErr)
 {
     StdDispatch *This = impl_from_IDispatch(iface);
-    TRACE("(%d, %s, 0x%x, 0x%x, %p, %p, %p, %p)\n", dispIdMember, debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
+
+    TRACE("%ld, %s, %#lx, 0x%x, %p, %p, %p, %p.\n", dispIdMember, debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 
     if (!IsEqualGUID(riid, &IID_NULL))
     {
diff --git a/dll/win32/oleaut32/hash.c b/dll/win32/oleaut32/hash.c
index 43043980adb..e3aababb241 100644
--- a/dll/win32/oleaut32/hash.c
+++ b/dll/win32/oleaut32/hash.c
@@ -509,7 +509,7 @@ ULONG WINAPI LHashValOfNameSysA( SYSKIND skind, LCID lcid, LPCSTR lpStr)
   ULONG nHiWord, nLoWord = 0x0deadbee;
   const unsigned char *str = (const unsigned char *)lpStr, *pnLookup = NULL;
 
-  TRACE("(%d, 0x%x, %s) %s\n", skind, lcid, debugstr_a(lpStr),
+  TRACE("%d, %#lx, %s, %s.\n", skind, lcid, debugstr_a(lpStr),
     (skind == SYS_WIN16) ? "SYS_WIN16" : (skind == SYS_WIN32) ? "SYS_WIN32" : "");
 
   if (!str)
@@ -520,34 +520,6 @@ ULONG WINAPI LHashValOfNameSysA( SYSKIND skind, LCID lcid, LPCSTR lpStr)
   switch (PRIMARYLANGID(LANGIDFROMLCID(lcid)))
   {
   default:
-    ERR("Unknown lcid %x, treating as latin-based, please report\n", lcid);
-    /* .. Fall Through .. */
-  case LANG_AFRIKAANS:  case LANG_ALBANIAN:   case LANG_ARMENIAN:
-  case LANG_ASSAMESE:   case LANG_AZERI:      case LANG_BASQUE:
-  case LANG_BELARUSIAN: case LANG_BENGALI:    case LANG_BULGARIAN:
-  case LANG_CATALAN:    case LANG_DANISH:     case LANG_DIVEHI:
-  case LANG_DUTCH:      case LANG_ENGLISH:    case LANG_ESTONIAN:
-  case LANG_FAEROESE:   case LANG_FINNISH:    case LANG_FRENCH:
-  case LANG_GALICIAN:   case LANG_GEORGIAN:   case LANG_GERMAN:
-  case LANG_GUJARATI:   case LANG_HINDI:      case LANG_INDONESIAN:
-  case LANG_ITALIAN:    case LANG_KANNADA:    case LANG_KASHMIRI:
-  case LANG_KAZAK:      case LANG_KONKANI:    case LANG_KYRGYZ:
-  case LANG_LATVIAN:    case LANG_LITHUANIAN: case LANG_MACEDONIAN:
-  case LANG_MALAY:      case LANG_MALAYALAM:  case LANG_MANIPURI:
-  case LANG_MARATHI:    case LANG_MONGOLIAN:  case LANG_NEPALI:
-  case LANG_ORIYA:      case LANG_PORTUGUESE: case LANG_PUNJABI:
-  case LANG_ROMANIAN:   case LANG_SANSKRIT:   case LANG_SERBIAN:
-  case LANG_SINDHI:     case LANG_SLOVENIAN:  case LANG_SWAHILI:
-  case LANG_SWEDISH:    case LANG_SYRIAC:     case LANG_TAMIL:
-  case LANG_TATAR:      case LANG_TELUGU:     case LANG_THAI:
-  case LANG_UKRAINIAN:  case LANG_URDU:       case LANG_UZBEK:
-  case LANG_VIETNAMESE: case LANG_SCOTTISH_GAELIC: case LANG_MALTESE:
-  case LANG_MAORI:      case LANG_ROMANSH:    case LANG_IRISH:
-  case LANG_SAMI:       case LANG_UPPER_SORBIAN: case LANG_SUTU:
-  case LANG_TSONGA:     case LANG_TSWANA:     case LANG_VENDA:
-  case LANG_XHOSA:      case LANG_ZULU:       case LANG_ESPERANTO:
-  case LANG_WALON:      case LANG_CORNISH:    case LANG_WELSH:
-  case LANG_BRETON:     case LANG_MANX_GAELIC:
     nOffset = 16;
     pnLookup = Lookup_16;
     break;
@@ -633,9 +605,9 @@ ULONG WINAPI LHashValOfNameSys(SYSKIND skind, LCID lcid, LPCOLESTR str)
 
     if (!str) return 0;
     len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
-    strA = HeapAlloc( GetProcessHeap(), 0, len );
+    strA = malloc(len);
     WideCharToMultiByte( CP_ACP, 0, str, -1, strA, len, NULL, NULL );
     res = LHashValOfNameSysA(skind, lcid, strA);
-    HeapFree(GetProcessHeap(), 0, strA);
+    free(strA);
     return res;
 }
diff --git a/dll/win32/oleaut32/oleaut.c b/dll/win32/oleaut32/oleaut.c
index c38bb09a893..2a7d7b8df69 100644
--- a/dll/win32/oleaut32/oleaut.c
+++ b/dll/win32/oleaut32/oleaut.c
@@ -18,6 +18,7 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
+#include <assert.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
@@ -34,6 +35,7 @@
 #include "ole2.h"
 #include "olectl.h"
 #include "oleauto.h"
+#include "rpcproxy.h"
 #include "initguid.h"
 #include "typelib.h"
 #include "oleaut32_oaidl.h"
@@ -115,7 +117,7 @@ static inline size_t bstr_alloc_size(size_t size)
 
 static inline bstr_t *bstr_from_str(BSTR str)
 {
-    return CONTAINING_RECORD((void *)str, bstr_t, u.str);
+    return CONTAINING_RECORD(str, bstr_t, u.str);
 }
 
 static inline bstr_cache_entry_t *get_cache_entry_from_idx(unsigned cache_idx)
@@ -505,9 +507,6 @@ void WINAPI SetOaNoCache(void)
     bstr_cache_enabled = FALSE;
 }
 
-static const WCHAR	_delimiter[] = {'!',0}; /* default delimiter apparently */
-static const WCHAR	*pdelimiter = &_delimiter[0];
-
 /***********************************************************************
  *		RegisterActiveObject (OLEAUT32.33)
  *
@@ -533,7 +532,7 @@ HRESULT WINAPI DECLSPEC_HOTPATCH RegisterActiveObject(
         DWORD                   rot_flags = ROTFLAGS_REGISTRATIONKEEPSALIVE; /* default registration is strong */
 
 	StringFromGUID2(rcid,guidbuf,39);
-	ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
+	ret = CreateItemMoniker(L"!", guidbuf, &moniker);
 	if (FAILED(ret))
 		return ret;
 	ret = GetRunningObjectTable(0,&runobtable);
@@ -597,7 +596,7 @@ HRESULT WINAPI DECLSPEC_HOTPATCH GetActiveObject(REFCLSID rcid,LPVOID preserved,
 	LPMONIKER		moniker;
 
 	StringFromGUID2(rcid,guidbuf,39);
-	ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
+	ret = CreateItemMoniker(L"!", guidbuf, &moniker);
 	if (FAILED(ret))
 		return ret;
 	ret = GetRunningObjectTable(0,&runobtable);
@@ -660,15 +659,14 @@ ULONG WINAPI OaBuildVersion(void)
     case 0x00000005:  /* W2K */
 		return MAKELONG(0xffff, 40);
     case 0x00000105:  /* WinXP */
-#ifdef __REACTOS__
-    case 0x00000205:  /* Win2K3 */
-#endif /* __REACTOS__ */
     case 0x00000006:  /* Vista */
     case 0x00000106:  /* Win7 */
+    case 0x00000205:  /* W2K3 */
+    case 0x00000206:  /* Win8, Win10, Win11 */
 		return MAKELONG(0xffff, 50);
     default:
 		FIXME("Version value not known yet. Please investigate it !\n");
-		return MAKELONG(0xffff, 40);  /* for now return the same value as for w2k */
+		return MAKELONG(0xffff, 50);  /* for now return the same value as for Win10 */
     }
 }
 
@@ -697,7 +695,7 @@ HRESULT WINAPI OleTranslateColor(
   COLORREF colorref;
   BYTE b = HIBYTE(HIWORD(clr));
 
-  TRACE("(%08x, %p, %p)\n", clr, hpal, pColorRef);
+  TRACE("%#lx, %p, %p.\n", clr, hpal, pColorRef);
 
   /*
    * In case pColorRef is NULL, provide our own to simplify the code.
@@ -762,10 +760,10 @@ HRESULT WINAPI OleTranslateColor(
   return S_OK;
 }
 
-extern HRESULT WINAPI OLEAUTPS_DllGetClassObject(REFCLSID, REFIID, LPVOID *) DECLSPEC_HIDDEN;
-extern BOOL WINAPI OLEAUTPS_DllMain(HINSTANCE, DWORD, LPVOID) DECLSPEC_HIDDEN;
-extern HRESULT WINAPI OLEAUTPS_DllRegisterServer(void) DECLSPEC_HIDDEN;
-extern HRESULT WINAPI OLEAUTPS_DllUnregisterServer(void) DECLSPEC_HIDDEN;
+extern HRESULT WINAPI OLEAUTPS_DllGetClassObject(REFCLSID, REFIID, LPVOID *);
+extern BOOL WINAPI OLEAUTPS_DllMain(HINSTANCE, DWORD, LPVOID);
+extern HRESULT WINAPI OLEAUTPS_DllRegisterServer(void);
+extern HRESULT WINAPI OLEAUTPS_DllUnregisterServer(void);
 
 extern HRESULT WINAPI CreateProxyFromTypeInfo(ITypeInfo *typeinfo,
         IUnknown *outer, REFIID iid, IRpcProxyBuffer **proxy, void **obj);
@@ -820,7 +818,7 @@ static BOOL actctx_get_typelib_module(REFIID iid, WCHAR *module, DWORD len)
 
     if (tlib->name_len/sizeof(WCHAR) >= len)
     {
-        ERR("need larger module buffer, %u\n", tlib->name_len);
+        ERR("need larger module buffer, %lu.\n", tlib->name_len);
         return FALSE;
     }
 
@@ -832,13 +830,13 @@ static BOOL actctx_get_typelib_module(REFIID iid, WCHAR *module, DWORD len)
 static HRESULT reg_get_typelib_module(REFIID iid, WCHAR *module, DWORD len)
 {
     REGSAM opposite = (sizeof(void*) == 8) ? KEY_WOW64_32KEY : KEY_WOW64_64KEY;
-    char tlguid[200], typelibkey[300], interfacekey[300], ver[100], tlfn[260];
+    char tlguid[200], typelibkey[316], interfacekey[300], ver[100], tlfn[260];
     DWORD tlguidlen, verlen, type;
     LONG tlfnlen, err;
     BOOL is_wow64;
     HKEY ikey;
 
-    sprintf( interfacekey, "Interface\\{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\Typelib",
+    sprintf( interfacekey, "Interface\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\Typelib",
         iid->Data1, iid->Data2, iid->Data3,
         iid->Data4[0], iid->Data4[1], iid->Data4[2], iid->Data4[3],
         iid->Data4[4], iid->Data4[5], iid->Data4[6], iid->Data4[7]
@@ -989,7 +987,7 @@ static HRESULT WINAPI dispatch_typelib_ps_CreateProxy(IPSFactoryBuffer *iface,
         hr = dispatch_create_proxy(outer, proxy, out);
 
     if (FAILED(hr))
-        ERR("Failed to create proxy, hr %#x.\n", hr);
+        ERR("Failed to create proxy, hr %#lx.\n", hr);
 
     ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
     ITypeInfo_Release(typeinfo);
@@ -1009,6 +1007,114 @@ static HRESULT dispatch_create_stub(IUnknown *server, IRpcStubBuffer **stub)
     return hr;
 }
 
+struct dispinterface_stub
+{
+    CInterfaceStubVtbl stub_vtbl;
+    CStdStubBuffer stub_buffer;
+};
+
+static struct dispinterface_stub *impl_from_IRpcStubBuffer(IRpcStubBuffer *iface)
+{
+    return CONTAINING_RECORD(&iface->lpVtbl, struct dispinterface_stub, stub_buffer.lpVtbl);
+}
+
+static ULONG WINAPI dispinterface_stub_Release(IRpcStubBuffer *iface)
+{
+    struct dispinterface_stub *stub = impl_from_IRpcStubBuffer(iface);
+    unsigned int refcount = InterlockedDecrement(&stub->stub_buffer.RefCount);
+
+    TRACE("%p decreasing refcount to %u.\n", stub, refcount);
+
+    if (!refcount)
+    {
+        /* Copied from NdrCStdStubBuffer_Release(), but supposedly incorrect
+         * according to the comment there. */
+        IRpcStubBuffer_Disconnect(iface);
+
+        free(stub);
+    }
+    return refcount;
+}
+
+extern const ExtendedProxyFileInfo oleaut32_oaidl_ProxyFileInfo;
+
+static const CInterfaceStubVtbl *find_idispatch_stub_vtbl(void)
+{
+    CInterfaceStubVtbl *const *vtbl;
+
+    for (vtbl = oleaut32_oaidl_ProxyFileInfo.pStubVtblList; *vtbl; ++vtbl)
+    {
+        if (IsEqualGUID((*vtbl)->header.piid, &IID_IDispatch))
+            return *vtbl;
+    }
+
+    assert(0);
+    return NULL;
+}
+
+/* Normal dispinterfaces have an IID specified by the IDL compiler as DIID_*,
+ * but are otherwise identical to IDispatch. Unfortunately, such interfaces may
+ * not actually support IDispatch in QueryInterface.
+ *
+ * This becomes a problem, since CreateStub() was designed such that, for some
+ * reason, the caller need not actually pass the interface matching "iid". As
+ * such the standard rpcrt4 implementation will query the server for the
+ * relevant IID.
+ *
+ * This means that we cannot just pass IID_IDispatch with the object, even
+ * though it is in theory an IDispatch. However, while the standard stub
+ * constructor is not exported from rpcrt4, all of the vtbl methods are, and
+ * the type is public, so we *can* manually create it ourselves, bypassing the
+ * QueryInterface check.
+ *
+ * This relies on some rpcrt4 implementation details.
+ */
+static HRESULT dispinterface_create_stub(IUnknown *server, const GUID *iid, IRpcStubBuffer **stub)
+{
+    const CInterfaceStubVtbl *stub_vtbl = find_idispatch_stub_vtbl();
+    struct dispinterface_stub *object;
+    void *dispatch;
+    HRESULT hr;
+
+    if (!(object = calloc(1, sizeof(*object))))
+        return E_OUTOFMEMORY;
+
+    /* It's possible we can just assume that "server" is already the
+     * dispinterface type—we don't have tests for this—but since rpcrt4 queries
+     * (which we do have tests for) it makes sense for us to match that
+     * behaviour. */
+    if (FAILED(hr = IUnknown_QueryInterface(server, iid, &dispatch)))
+    {
+        ERR("Object does not support interface %s.\n", debugstr_guid(iid));
+        free(object);
+        return hr;
+    }
+
+    object->stub_vtbl.header = stub_vtbl->header;
+    object->stub_vtbl.Vtbl.QueryInterface             = CStdStubBuffer_QueryInterface;
+    object->stub_vtbl.Vtbl.AddRef                     = CStdStubBuffer_AddRef;
+    object->stub_vtbl.Vtbl.Release                    = dispinterface_stub_Release;
+    object->stub_vtbl.Vtbl.Connect                    = CStdStubBuffer_Connect;
+    object->stub_vtbl.Vtbl.Disconnect                 = CStdStubBuffer_Disconnect;
+    object->stub_vtbl.Vtbl.Invoke                     = CStdStubBuffer_Invoke;
+    object->stub_vtbl.Vtbl.IsIIDSupported             = CStdStubBuffer_IsIIDSupported;
+    object->stub_vtbl.Vtbl.CountRefs                  = CStdStubBuffer_CountRefs;
+    object->stub_vtbl.Vtbl.DebugServerQueryInterface  = CStdStubBuffer_DebugServerQueryInterface;
+    object->stub_vtbl.Vtbl.DebugServerRelease         = CStdStubBuffer_DebugServerRelease;
+    object->stub_buffer.lpVtbl = &object->stub_vtbl.Vtbl;
+    object->stub_buffer.RefCount = 1;
+    object->stub_buffer.pvServerObject = dispatch;
+    /* rpcrt4 will also fill pPSFactory, but it never uses it except in the
+     * Release method (which we reimplement). It's only to keep a reference to
+     * the module to implement NdrDllCanUnloadNow(). We use the default
+     * DllCanUnloadNow() from winecrt0, which always returns S_FALSE, so don't
+     * bother filling pPSFactory. */
+
+    TRACE("Created stub %p.\n", object);
+    *stub = (IRpcStubBuffer *)&object->stub_buffer.lpVtbl;
+    return S_OK;
+}
+
 static HRESULT WINAPI dispatch_typelib_ps_CreateStub(IPSFactoryBuffer *iface,
     REFIID iid, IUnknown *server, IRpcStubBuffer **stub)
 {
@@ -1032,10 +1138,10 @@ static HRESULT WINAPI dispatch_typelib_ps_CreateStub(IPSFactoryBuffer *iface,
     if (attr->typekind == TKIND_INTERFACE || (attr->wTypeFlags & TYPEFLAG_FDUAL))
         hr = CreateStubFromTypeInfo(typeinfo, iid, server, stub);
     else
-        hr = dispatch_create_stub(server, stub);
+        hr = dispinterface_create_stub(server, iid, stub);
 
     if (FAILED(hr))
-        ERR("Failed to create proxy, hr %#x.\n", hr);
+        ERR("Failed to create stub, hr %#lx.\n", hr);
 
     ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
     ITypeInfo_Release(typeinfo);
@@ -1090,31 +1196,13 @@ HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
     return OLEAUTPS_DllGetClassObject(rclsid, iid, ppv);
 }
 
-/***********************************************************************
- *		DllCanUnloadNow (OLEAUT32.@)
- *
- * Determine if this dll can be unloaded from the callers address space.
- *
- * PARAMS
- *  None.
- *
- * RETURNS
- *  Always returns S_FALSE. This dll cannot be unloaded.
- */
-HRESULT WINAPI DllCanUnloadNow(void)
-{
-    return S_FALSE;
-}
-
 /*****************************************************************************
  *              DllMain         [OLEAUT32.@]
  */
 BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
 {
-    static const WCHAR oanocacheW[] = {'o','a','n','o','c','a','c','h','e',0};
-
     if(fdwReason == DLL_PROCESS_ATTACH)
-        bstr_cache_enabled = !GetEnvironmentVariableW(oanocacheW, NULL, 0);
+        bstr_cache_enabled = !GetEnvironmentVariableW(L"oanocache", NULL, 0);
 
     return OLEAUTPS_DllMain( hInstDll, fdwReason, lpvReserved );
 }
@@ -1150,97 +1238,58 @@ HCURSOR WINAPI OleIconToCursor( HINSTANCE hinstExe, HICON hIcon)
  */
 HRESULT WINAPI GetAltMonthNames(LCID lcid, LPOLESTR **str)
 {
-    static const WCHAR ar_month1W[] = {0x645,0x62d,0x631,0x645,0};
-    static const WCHAR ar_month2W[] = {0x635,0x641,0x631,0};
-    static const WCHAR ar_month3W[] = {0x631,0x628,0x64a,0x639,' ',0x627,0x644,0x627,0x648,0x644,0};
-    static const WCHAR ar_month4W[] = {0x631,0x628,0x64a,0x639,' ',0x627,0x644,0x62b,0x627,0x646,0x64a,0};
-    static const WCHAR ar_month5W[] = {0x62c,0x645,0x627,0x62f,0x649,' ',0x627,0x644,0x627,0x648,0x644,0x649,0};
-    static const WCHAR ar_month6W[] = {0x62c,0x645,0x627,0x62f,0x649,' ',0x627,0x644,0x62b,0x627,0x646,0x64a,0x629,0};
-    static const WCHAR ar_month7W[] = {0x631,0x62c,0x628,0};
-    static const WCHAR ar_month8W[] = {0x634,0x639,0x628,0x627,0x646,0};
-    static const WCHAR ar_month9W[] = {0x631,0x645,0x636,0x627,0x646,0};
-    static const WCHAR ar_month10W[] = {0x634,0x648,0x627,0x643,0};
-    static const WCHAR ar_month11W[] = {0x630,0x648,' ',0x627,0x644,0x642,0x639,0x62f,0x629,0};
-    static const WCHAR ar_month12W[] = {0x630,0x648,' ',0x627,0x644,0x62d,0x62c,0x629,0};
-
     static const WCHAR *arabic_hijri[] =
     {
-        ar_month1W,
-        ar_month2W,
-        ar_month3W,
-        ar_month4W,
-        ar_month5W,
-        ar_month6W,
-        ar_month7W,
-        ar_month8W,
-        ar_month9W,
-        ar_month10W,
-        ar_month11W,
-        ar_month12W,
+        L"\x0645\x062d\x0631\x0645",
+        L"\x0635\x0641\x0631",
+        L"\x0631\x0628\x064a\x0639 \x0627\x0644\x0627\x0648\x0644",
+        L"\x0631\x0628\x064a\x0639 \x0627\x0644\x062b\x0627\x0646\x064a",
+        L"\x062c\x0645\x0627\x062f\x0649 \x0627\x0644\x0627\x0648\x0644\x0649",
+        L"\x062c\x0645\x0627\x062f\x0649 \x0627\x0644\x062b\x0627\x0646\x064a\x0629",
+        L"\x0631\x062c\x0628",
+        L"\x0634\x0639\x0628\x0627\x0646",
+        L"\x0631\x0645\x0636\x0627\x0646",
+        L"\x0634\x0648\x0627\x0643",
+        L"\x0630\x0648 \x0627\x0644\x0642\x0639\x062f\x0629",
+        L"\x0630\x0648 \x0627\x0644\x062d\x062c\x0629",
         NULL
     };
 
-    static const WCHAR pl_month1W[] = {'s','t','y','c','z','n','i','a',0};
-    static const WCHAR pl_month2W[] = {'l','u','t','e','g','o',0};
-    static const WCHAR pl_month3W[] = {'m','a','r','c','a',0};
-    static const WCHAR pl_month4W[] = {'k','w','i','e','t','n','i','a',0};
-    static const WCHAR pl_month5W[] = {'m','a','j','a',0};
-    static const WCHAR pl_month6W[] = {'c','z','e','r','w','c','a',0};
-    static const WCHAR pl_month7W[] = {'l','i','p','c','a',0};
-    static const WCHAR pl_month8W[] = {'s','i','e','r','p','n','i','a',0};
-    static const WCHAR pl_month9W[] = {'w','r','z','e',0x15b,'n','i','a',0};
-    static const WCHAR pl_month10W[] = {'p','a',0x17a,'d','z','i','e','r','n','i','k','a',0};
-    static const WCHAR pl_month11W[] = {'l','i','s','t','o','p','a','d','a',0};
-    static const WCHAR pl_month12W[] = {'g','r','u','d','n','i','a',0};
-
     static const WCHAR *polish_genitive_names[] =
     {
-        pl_month1W,
-        pl_month2W,
-        pl_month3W,
-        pl_month4W,
-        pl_month5W,
-        pl_month6W,
-        pl_month7W,
-        pl_month8W,
-        pl_month9W,
-        pl_month10W,
-        pl_month11W,
-        pl_month12W,
+        L"stycznia",
+        L"lutego",
+        L"marca",
+        L"kwietnia",
+        L"maja",
+        L"czerwca",
+        L"lipca",
+        L"sierpnia",
+        L"wrze\x015bnia",
+        L"pa\x017a" "dziernika",
+        L"listopada",
+        L"grudnia",
         NULL
     };
 
-    static const WCHAR ru_month1W[] = {0x44f,0x43d,0x432,0x430,0x440,0x44f,0};
-    static const WCHAR ru_month2W[] = {0x444,0x435,0x432,0x440,0x430,0x43b,0x44f,0};
-    static const WCHAR ru_month3W[] = {0x43c,0x430,0x440,0x442,0x430,0};
-    static const WCHAR ru_month4W[] = {0x430,0x43f,0x440,0x435,0x43b,0x44f,0};
-    static const WCHAR ru_month5W[] = {0x43c,0x430,0x44f,0};
-    static const WCHAR ru_month6W[] = {0x438,0x44e,0x43d,0x44f,0};
-    static const WCHAR ru_month7W[] = {0x438,0x44e,0x43b,0x44f,0};
-    static const WCHAR ru_month8W[] = {0x430,0x432,0x433,0x443,0x441,0x442,0x430,0};
-    static const WCHAR ru_month9W[] = {0x441,0x435,0x43d,0x442,0x44f,0x431,0x440,0x44f,0};
-    static const WCHAR ru_month10W[] = {0x43e,0x43a,0x442,0x44f,0x431,0x440,0x44f,0};
-    static const WCHAR ru_month11W[] = {0x43d,0x43e,0x44f,0x431,0x440,0x44f,0};
-    static const WCHAR ru_month12W[] = {0x434,0x435,0x43a,0x430,0x431,0x440,0x44f,0};
-
     static const WCHAR *russian_genitive_names[] =
     {
-        ru_month1W,
-        ru_month2W,
-        ru_month3W,
-        ru_month4W,
-        ru_month5W,
-        ru_month6W,
-        ru_month7W,
-        ru_month8W,
-        ru_month9W,
-        ru_month10W,
-        ru_month11W,
-        ru_month12W,
+        L"\x044f\x043d\x0432\x0430\x0440\x044f",
+        L"\x0444\x0435\x0432\x0440\x0430\x043b\x044f",
+        L"\x043c\x0430\x0440\x0442\x0430",
+        L"\x0430\x043f\x0440\x0435\x043b\x044f",
+        L"\x043c\x0430\x044f",
+        L"\x0438\x044e\x043d\x044f",
+        L"\x0438\x044e\x043b\x044f",
+        L"\x0430\x0432\x0433\x0443\x0441\x0442\x0430",
+        L"\x0441\x0435\x043d\x0442\x044f\x0431\x0440\x044f",
+        L"\x043e\x043a\x0442\x044f\x0431\x0440\x044f",
+        L"\x043d\x043e\x044f\x0431\x0440\x044f",
+        L"\x0434\x0435\x043a\x0430\x0431\x0440\x044f",
         NULL
     };
 
-    TRACE("%#x, %p\n", lcid, str);
+    TRACE("%#lx, %p.\n", lcid, str);
 
     if (PRIMARYLANGID(LANGIDFROMLCID(lcid)) == LANG_ARABIC)
         *str = (LPOLESTR *)arabic_hijri;
diff --git a/dll/win32/oleaut32/oleaut32.rc b/dll/win32/oleaut32/oleaut32.rc
index bcc5be83f79..c4a330b815a 100644
--- a/dll/win32/oleaut32/oleaut32.rc
+++ b/dll/win32/oleaut32/oleaut32.rc
@@ -18,8 +18,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include <windef.h>
-
 #include "resource.h"
 
 /* UTF-8 */
@@ -120,13 +118,10 @@
 /* @makedep: oleaut32.rgs */
 1 WINE_REGISTRY oleaut32.rgs
 
-2 WINE_REGISTRY "oleaut32_oaidl.rgs"
-3 WINE_REGISTRY "oleaut32_ocidl.rgs"
-
 #define WINE_FILEDESCRIPTION_STR "Wine OLE dll"
 #define WINE_FILENAME_STR "oleaut32.dll"
-#define WINE_FILEVERSION 6, 0, 6001, 18000 /* version from Vista SP1 */
-#define WINE_FILEVERSION_STR "6.0.6001.18000"
+#define WINE_FILEVERSION 10, 0, 19043, 1466 /* version from Win10 2009 */
+#define WINE_FILEVERSION_STR "10.0.19043.1466"
 #define WINE_EXTRAVALUES VALUE "OLESelfRegister",""
 
-#include <wine/wine_common_ver.rc>
+#include "wine/wine_common_ver.rc"
diff --git a/dll/win32/oleaut32/oleaut32.spec b/dll/win32/oleaut32/oleaut32.spec
index 06ef3d351fd..21b52f1f06e 100644
--- a/dll/win32/oleaut32/oleaut32.spec
+++ b/dll/win32/oleaut32/oleaut32.spec
@@ -140,14 +140,12 @@
 141 stdcall VarAdd(ptr ptr ptr)
 142 stdcall VarAnd(ptr ptr ptr)
 143 stdcall VarDiv(ptr ptr ptr)
-@ stdcall -private DllCanUnloadNow()
-@ stdcall -private DllGetClassObject(ptr ptr ptr)
+144 stub OACreateTypeLib2
 146 stdcall DispCallFunc(ptr long long long long ptr ptr ptr)
 147 stdcall VariantChangeTypeEx(ptr ptr long long long)
 148 stdcall SafeArrayPtrOfIndex(ptr ptr ptr)
 149 stdcall SysStringByteLen(ptr)
 150 stdcall SysAllocStringByteLen(ptr long)
-@ stdcall -private DllRegisterServer()
 152 stdcall VarEqv(ptr ptr ptr)
 153 stdcall VarIdiv(ptr ptr ptr)
 154 stdcall VarImp(ptr ptr ptr)
@@ -196,9 +194,9 @@
 197 stdcall VarDecFromStr(wstr long long ptr)
 198 stdcall VarDecFromDisp(ptr long ptr)
 199 stdcall VarDecFromBool(long ptr)
-200 stdcall GetErrorInfo(long ptr) ole32.GetErrorInfo
-201 stdcall SetErrorInfo(long ptr) ole32.SetErrorInfo
-202 stdcall CreateErrorInfo(ptr) ole32.CreateErrorInfo
+200 stdcall -import GetErrorInfo(long ptr)
+201 stdcall -import SetErrorInfo(long ptr)
+202 stdcall -import CreateErrorInfo(ptr)
 203 stdcall VarDecRound(ptr long ptr)
 204 stdcall VarDecCmp(ptr ptr)
 205 stdcall VarI2FromI1(long ptr)
@@ -296,8 +294,6 @@
 297 stub LPSAFEARRAY_Unmarshal
 298 stdcall VarDecCmpR8(ptr double)
 299 stdcall VarCyAdd(int64 int64 ptr)
-@ stdcall -private DllUnregisterServer()
-301 stub OACreateTypeLib2
 303 stdcall VarCyMul(int64 int64 ptr)
 304 stdcall VarCyMulI4(int64 long ptr)
 305 stdcall VarCySub(int64 int64 ptr)
@@ -361,6 +357,26 @@
 377 stdcall VarI1FromUI8(int64 ptr)
 378 stdcall VarUI2FromI8(int64 ptr)
 379 stdcall VarUI2FromUI8(int64 ptr)
+380 stub UserHWND_from_local
+381 stub UserHWND_to_local
+382 stub UserHWND_free_inst
+383 stub UserHWND_free_local
+384 stub UserBSTR_from_local
+385 stub UserBSTR_to_local
+386 stub UserBSTR_free_inst
+387 stub UserBSTR_free_local
+388 stub UserVARIANT_from_local
+389 stub UserVARIANT_to_local
+390 stub UserVARIANT_free_inst
+391 stub UserVARIANT_free_local
+392 stub UserEXCEPINFO_from_local
+393 stub UserEXCEPINFO_to_local
+394 stub UserEXCEPINFO_free_inst
+395 stub UserEXCEPINFO_free_local
+396 stub UserMSG_from_local
+397 stub UserMSG_to_local
+398 stub UserMSG_free_inst
+399 stub UserMSG_free_local
 401 stdcall OleLoadPictureEx(ptr long long ptr long long long ptr)
 402 stub OleLoadPictureFileEx
 411 stdcall SafeArrayCreateVector(long long long)
@@ -396,3 +412,8 @@
 441 stdcall VarUI8FromDec(long ptr)
 442 stdcall RegisterTypeLibForUser(ptr wstr wstr)
 443 stdcall UnRegisterTypeLibForUser(ptr long long long long)
+
+@ stdcall -private DllCanUnloadNow()
+@ stdcall -private DllGetClassObject(ptr ptr ptr)
+@ stdcall -private DllRegisterServer()
+@ stdcall -private DllUnregisterServer()
diff --git a/dll/win32/oleaut32/oleaut32_oaidl.idl b/dll/win32/oleaut32/oleaut32_oaidl.idl
index 2874be0603f..306137c9a9d 100644
--- a/dll/win32/oleaut32/oleaut32_oaidl.idl
+++ b/dll/win32/oleaut32/oleaut32_oaidl.idl
@@ -31,4 +31,4 @@ cpp_quote("#endif   /* oleaut32_oaidl.idl hack */")
     threading(both),
     uuid(b196b286-bab4-101a-b69c-00aa00341d07)
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
diff --git a/dll/win32/oleaut32/oleaut32_oaidl.rgs b/dll/win32/oleaut32/oleaut32_oaidl.rgs
deleted file mode 100644
index ebd7b5a2624..00000000000
--- a/dll/win32/oleaut32/oleaut32_oaidl.rgs
+++ /dev/null
@@ -1,78 +0,0 @@
-HKCR
-{
-    NoRemove Interface
-    {
-        '{00020400-0000-0000-C000-000000000046}' = s 'IDispatch'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{00020404-0000-0000-C000-000000000046}' = s 'IEnumVARIANT'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{00020403-0000-0000-C000-000000000046}' = s 'ITypeComp'
-        {
-            NumMethods = s 5
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{00020401-0000-0000-C000-000000000046}' = s 'ITypeInfo'
-        {
-            NumMethods = s 22
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{00020412-0000-0000-C000-000000000046}' = s 'ITypeInfo2'
-        {
-            NumMethods = s 37
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{00020402-0000-0000-C000-000000000046}' = s 'ITypeLib'
-        {
-            NumMethods = s 13
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{00020411-0000-0000-C000-000000000046}' = s 'ITypeLib2'
-        {
-            NumMethods = s 17
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{1CF2B120-547D-101B-8E65-08002B2BD119}' = s 'IErrorInfo'
-        {
-            NumMethods = s 8
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{22F03340-547D-101B-8E65-08002B2BD119}' = s 'ICreateErrorInfo'
-        {
-            NumMethods = s 8
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{DF0B3D60-548F-101B-8E65-08002B2BD119}' = s 'ISupportErrorInfo'
-        {
-            NumMethods = s 4
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{0000002E-0000-0000-C000-000000000046}' = s 'ITypeFactory'
-        {
-            NumMethods = s 4
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{3127CA40-446E-11CE-8135-00AA004BB851}' = s 'IErrorLog'
-        {
-            NumMethods = s 4
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{55272A00-42CB-11CE-8135-00AA004BB851}' = s 'IPropertyBag'
-        {
-            NumMethods = s 5
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-    }
-    NoRemove CLSID
-    {
-        '{B196B286-BAB4-101A-B69C-00AA00341D07}' = s 'PSFactoryBuffer'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-        }
-    }
-}
\ No newline at end of file
diff --git a/dll/win32/oleaut32/oleaut32_ocidl.idl b/dll/win32/oleaut32/oleaut32_ocidl.idl
index 5f7664e0fb3..94792630dfe 100644
--- a/dll/win32/oleaut32/oleaut32_ocidl.idl
+++ b/dll/win32/oleaut32/oleaut32_ocidl.idl
@@ -25,7 +25,7 @@
     threading(both),
     uuid(b196b286-bab4-101a-b69c-00aa00341d07)
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
 
 [
     helpstring("Standard Font"),
diff --git a/dll/win32/oleaut32/oleaut32_ocidl.rgs b/dll/win32/oleaut32/oleaut32_ocidl.rgs
deleted file mode 100644
index e8b25ae3b2e..00000000000
--- a/dll/win32/oleaut32/oleaut32_ocidl.rgs
+++ /dev/null
@@ -1,252 +0,0 @@
-HKCR
-{
-    NoRemove Interface
-    {
-        '{BEF6E002-A874-101A-8BBA-00AA00300CAB}' = s 'IFont'
-        {
-            NumMethods = s 27
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{BEF6E003-A874-101A-8BBA-00AA00300CAB}' = s 'IFontDisp'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{4EF6100A-AF88-11D0-9846-00C04FC29993}' = s 'IFontEventsDisp'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{7BF80980-BF32-101A-8BBB-00AA00300CAB}' = s 'IPicture'
-        {
-            NumMethods = s 17
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{7BF80981-BF32-101A-8BBB-00AA00300CAB}' = s 'IPictureDisp'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{B196B288-BAB4-101A-B69C-00AA00341D07}' = s 'IOleControl'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{B196B289-BAB4-101A-B69C-00AA00341D07}' = s 'IOleControlSite'
-        {
-            NumMethods = s 10
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{9C2CAD80-3424-11CF-B670-00AA004CD6D8}' = s 'IOleInPlaceSiteEx'
-        {
-            NumMethods = s 18
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{B196B28F-BAB4-101A-B69C-00AA00341D07}' = s 'IClassFactory2'
-        {
-            NumMethods = s 8
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{B196B283-BAB4-101A-B69C-00AA00341D07}' = s 'IProvideClassInfo'
-        {
-            NumMethods = s 4
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{A6BC3AC0-DBAA-11CE-9DE3-00AA004BB851}' = s 'IProvideClassInfo2'
-        {
-            NumMethods = s 5
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{A7ABA9C1-8983-11CF-8F20-00805F2CD064}' = s 'IProvideMultipleClassInfo'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{B196B286-BAB4-101A-B69C-00AA00341D07}' = s 'IConnectionPoint'
-        {
-            NumMethods = s 8
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{B196B284-BAB4-101A-B69C-00AA00341D07}' = s 'IConnectionPointContainer'
-        {
-            NumMethods = s 5
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{B196B287-BAB4-101A-B69C-00AA00341D07}' = s 'IEnumConnections'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{B196B285-BAB4-101A-B69C-00AA00341D07}' = s 'IEnumConnectionPoints'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{B196B28D-BAB4-101A-B69C-00AA00341D07}' = s 'IPropertyPage'
-        {
-            NumMethods = s 14
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{01E44665-24AC-101B-84ED-08002B2EC713}' = s 'IPropertyPage2'
-        {
-            NumMethods = s 15
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{B196B28C-BAB4-101A-B69C-00AA00341D07}' = s 'IPropertyPageSite'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{9BFBBC02-EFF1-101A-84ED-00AA00341D07}' = s 'IPropertyNotifySink'
-        {
-            NumMethods = s 5
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{742B0E01-14E6-101B-914E-00AA00300CAB}' = s 'ISimpleFrameSite'
-        {
-            NumMethods = s 5
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{7FD52380-4E07-101B-AE2D-08002B2EC713}' = s 'IPersistStreamInit'
-        {
-            NumMethods = s 9
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{BD1AE5E0-A6AE-11CE-BD37-504200C10000}' = s 'IPersistMemory'
-        {
-            NumMethods = s 9
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{37D84F60-42CB-11CE-8135-00AA004BB851}' = s 'IPersistPropertyBag'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{22F55882-280B-11D0-A8A9-00A0C90C2004}' = s 'IPropertyBag2'
-        {
-            NumMethods = s 8
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{22F55881-280B-11D0-A8A9-00A0C90C2004}' = s 'IPersistPropertyBag2'
-        {
-            NumMethods = s 8
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{B196B28B-BAB4-101A-B69C-00AA00341D07}' = s 'ISpecifyPropertyPages'
-        {
-            NumMethods = s 4
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{376BD3AA-3845-101B-84ED-08002B2EC713}' = s 'IPerPropertyBrowsing'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{3AF24290-0C96-11CE-A0CF-00AA00600AB8}' = s 'IAdviseSinkEx'
-        {
-            NumMethods = s 9
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{55980BA0-35AA-11CF-B671-00AA004CD6D8}' = s 'IPointerInactive'
-        {
-            NumMethods = s 6
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{FC4801A3-2BA9-11CF-A229-00AA003D7352}' = s 'IObjectWithSite'
-        {
-            NumMethods = s 5
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{894AD3B0-EF97-11CE-9BC9-00AA00608E01}' = s 'IOleUndoUnit'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{A1FAF330-EF97-11CE-9BC9-00AA00608E01}' = s 'IOleParentUndoUnit'
-        {
-            NumMethods = s 12
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{B3E7C340-EF97-11CE-9BC9-00AA00608E01}' = s 'IEnumOleUndoUnits'
-        {
-            NumMethods = s 7
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{D001F200-EF97-11CE-9BC9-00AA00608E01}' = s 'IOleUndoManager'
-        {
-            NumMethods = s 15
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-        '{CF51ED10-62FE-11CF-BF86-00A0C9034836}' = s 'IQuickActivate'
-        {
-            NumMethods = s 6
-            ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
-        }
-    }
-    NoRemove CLSID
-    {
-        '{B196B286-BAB4-101A-B69C-00AA00341D07}' = s 'PSFactoryBuffer'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-        }
-        '{0BE35203-8F91-11CE-9DE3-00AA004BB851}' = s 'Standard Font'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-            ProgId = s 'StdFont'
-        }
-        '{46763EE0-CAB2-11CE-8C20-00AA0051E5D4}' = s 'Obsolete Font'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-            ProgId = s 'OldFont'
-        }
-        '{0BE35204-8F91-11CE-9DE3-00AA004BB851}' = s 'Standard Picture'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Apartment' }
-            ProgId = s 'StdPicture'
-        }
-        '{00020420-0000-0000-C000-000000000046}' = s 'PSDispatch'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-        }
-        '{00020421-0000-0000-C000-000000000046}' = s 'PSEnumVariant'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-        }
-        '{00020422-0000-0000-C000-000000000046}' = s 'PSTypeInfo'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-        }
-        '{00020423-0000-0000-C000-000000000046}' = s 'PSTypeLib'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-        }
-        '{00020424-0000-0000-C000-000000000046}' = s 'PSOAInterface'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-        }
-        '{00020425-0000-0000-C000-000000000046}' = s 'PSTypeComp'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-        }
-        '{DF0B3D60-548F-101B-8E65-08002B2BD119}' = s 'PSSupportErrorInfo'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-        }
-        '{0000002F-0000-0000-C000-000000000046}' = s 'CLSID_RecordInfo'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-        }
-    }
-    'StdFont' = s 'Standard Font'
-    {
-        CLSID = s '{0BE35203-8F91-11CE-9DE3-00AA004BB851}'
-    }
-    'OldFont' = s 'Obsolete Font'
-    {
-        CLSID = s '{46763EE0-CAB2-11CE-8C20-00AA0051E5D4}'
-    }
-    'StdPicture' = s 'Standard Picture'
-    {
-        CLSID = s '{0BE35204-8F91-11CE-9DE3-00AA004BB851}'
-    }
-}
\ No newline at end of file
diff --git a/dll/win32/oleaut32/olefont.c b/dll/win32/oleaut32/olefont.c
index b82ffbf1b54..f1af3f4cb70 100644
--- a/dll/win32/oleaut32/olefont.c
+++ b/dll/win32/oleaut32/olefont.c
@@ -26,9 +26,6 @@
 #include <string.h>
 
 #define COBJMACROS
-#define NONAMELESSUNION
-#define NONAMELESSSTRUCT
-
 #include "winerror.h"
 #include "windef.h"
 #include "winbase.h"
@@ -117,7 +114,7 @@ static void HFONTItem_Delete(PHFONTItem item)
 {
   DeleteObject(item->gdiFont);
   list_remove(&item->entry);
-  HeapFree(GetProcessHeap(), 0, item);
+  free(item);
 }
 
 /* Find hfont item entry in the list.  Should be called while holding the crit sect */
@@ -136,7 +133,7 @@ static HFONTItem *find_hfontitem(HFONT hfont)
 /* Add an item to the list with one internal reference */
 static HRESULT add_hfontitem(HFONT hfont)
 {
-    HFONTItem *new_item = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_item));
+    HFONTItem *new_item = malloc(sizeof(*new_item));
 
     if(!new_item) return E_OUTOFMEMORY;
 
@@ -226,17 +223,6 @@ static HRESULT dec_ext_ref(HFONT hfont)
     return hr;
 }
 
-static WCHAR *strdupW(const WCHAR* str)
-{
-    WCHAR *ret;
-    DWORD size = (lstrlenW(str) + 1) * sizeof(WCHAR);
-
-    ret = HeapAlloc(GetProcessHeap(), 0, size);
-    if(ret)
-        memcpy(ret, str, size);
-    return ret;
-}
-
 /***********************************************************************
  * Declaration of the implementation class for the IFont interface
  */
@@ -255,7 +241,6 @@ struct OLEFontImpl
   IPersistStream              IPersistStream_iface;
   IConnectionPointContainer   IConnectionPointContainer_iface;
   IPersistPropertyBag         IPersistPropertyBag_iface;
-  IPersistStreamInit          IPersistStreamInit_iface;
   /*
    * Reference count for that instance of the class.
    */
@@ -311,11 +296,6 @@ static inline OLEFontImpl *impl_from_IPersistPropertyBag( IPersistPropertyBag *i
     return CONTAINING_RECORD(iface, OLEFontImpl, IPersistPropertyBag_iface);
 }
 
-static inline OLEFontImpl *impl_from_IPersistStreamInit( IPersistStreamInit *iface )
-{
-    return CONTAINING_RECORD(iface, OLEFontImpl, IPersistStreamInit_iface);
-}
-
 
 /***********************************************************************
  * Prototypes for the implementation functions for the IFont
@@ -344,12 +324,12 @@ HRESULT WINAPI OleCreateFontIndirect(
   *ppvObj = 0;
 
   if (!lpFontDesc) {
-    static WCHAR fname[] = { 'S','y','s','t','e','m',0 };
+    static WCHAR fname[] = L"System";
 
     fd.cbSizeofstruct = sizeof(fd);
     fd.lpstrName      = fname;
-    fd.cySize.s.Lo    = 80000;
-    fd.cySize.s.Hi    = 0;
+    fd.cySize.Lo      = 80000;
+    fd.cySize.Hi      = 0;
     fd.sWeight 	      = 0;
     fd.sCharset       = 0;
     fd.fItalic        = FALSE;
@@ -357,6 +337,8 @@ HRESULT WINAPI OleCreateFontIndirect(
     fd.fStrikethrough = FALSE;
     lpFontDesc = &fd;
   }
+  else if (!lpFontDesc->lpstrName)
+    return CTL_E_INVALIDPROPERTYVALUE;
 
   newFont = OLEFontImpl_Construct(lpFontDesc);
   if (!newFont) return E_OUTOFMEMORY;
@@ -380,25 +362,17 @@ HRESULT WINAPI OleCreateFontIndirect(
  */
 static void OLEFont_SendNotify(OLEFontImpl* this, DISPID dispID)
 {
-  static const WCHAR wszName[] = {'N','a','m','e',0};
-  static const WCHAR wszSize[] = {'S','i','z','e',0};
-  static const WCHAR wszBold[] = {'B','o','l','d',0};
-  static const WCHAR wszItalic[] = {'I','t','a','l','i','c',0};
-  static const WCHAR wszUnder[] = {'U','n','d','e','r','l','i','n','e',0};
-  static const WCHAR wszStrike[] = {'S','t','r','i','k','e','t','h','r','o','u','g','h',0};
-  static const WCHAR wszWeight[] = {'W','e','i','g','h','t',0};
-  static const WCHAR wszCharset[] = {'C','h','a','r','s','e','t',0};
   static const LPCWSTR dispid_mapping[] =
   {
-    wszName,
-    NULL,
-    wszSize,
-    wszBold,
-    wszItalic,
-    wszUnder,
-    wszStrike,
-    wszWeight,
-    wszCharset
+      L"Name",
+      NULL,
+      L"Size",
+      L"Bold",
+      L"Italic",
+      L"Underline",
+      L"Strikethrough",
+      L"Weight",
+      L"Charset"
   };
 
   IEnumConnections *pEnum;
@@ -491,10 +465,6 @@ static HRESULT WINAPI OLEFontImpl_QueryInterface(
   {
     *ppvObject = &this->IPersistPropertyBag_iface;
   }
-  else if (IsEqualGUID(&IID_IPersistStreamInit, riid))
-  {
-    *ppvObject = &this->IPersistStreamInit_iface;
-  }
 
   if (!*ppvObject)
   {
@@ -507,28 +477,20 @@ static HRESULT WINAPI OLEFontImpl_QueryInterface(
   return S_OK;
 }
 
-/************************************************************************
- * OLEFontImpl_AddRef (IUnknown)
- */
-static ULONG WINAPI OLEFontImpl_AddRef(
-  IFont* iface)
+static ULONG WINAPI OLEFontImpl_AddRef(IFont* iface)
 {
   OLEFontImpl *this = impl_from_IFont(iface);
-  TRACE("(%p)->(ref=%d)\n", this, this->ref);
-  return InterlockedIncrement(&this->ref);
+  ULONG ref = InterlockedIncrement(&this->ref);
+  TRACE("%p, refcount %lu.\n", iface, ref);
+  return ref;
 }
 
-/************************************************************************
- * OLEFontImpl_Release (IUnknown)
- */
 static ULONG WINAPI OLEFontImpl_Release(IFont* iface)
 {
   OLEFontImpl *this = impl_from_IFont(iface);
-  ULONG ref;
+  ULONG ref = InterlockedDecrement(&this->ref);
 
-  TRACE("(%p)->(ref=%d)\n", this, this->ref);
-
-  ref = InterlockedDecrement(&this->ref);
+  TRACE("%p, refcount %lu.\n", iface, ref);
 
   if (ref == 0)
   {
@@ -623,7 +585,7 @@ static void realize_font(OLEFontImpl *This)
      * Ratio is applied here relative to the standard.
      */
 
-    fontHeight = MulDiv( This->description.cySize.s.Lo, This->cyLogical*635, This->cyHimetric*18 );
+    fontHeight = MulDiv( This->description.cySize.Lo, This->cyLogical*635, This->cyHimetric*18 );
 
     logFont.lfHeight          = ((fontHeight%10000L)>5000L) ? (-fontHeight/10000L) - 1 :
                                                                   (-fontHeight/10000L);
@@ -647,8 +609,8 @@ static void realize_font(OLEFontImpl *This)
     GetTextFaceW(hdc, ARRAY_SIZE(text_face), text_face);
     if(lstrcmpiW(text_face, This->description.lpstrName))
     {
-        HeapFree(GetProcessHeap(), 0, This->description.lpstrName);
-        This->description.lpstrName = strdupW(text_face);
+        free(This->description.lpstrName);
+        This->description.lpstrName = wcsdup(text_face);
     }
     GetTextMetricsW(hdc, &tm);
     This->description.sCharset = tm.tmCharSet;
@@ -674,10 +636,7 @@ static HRESULT WINAPI OLEFontImpl_get_Name(
 
   realize_font(this);
 
-  if (this->description.lpstrName!=0)
-    *pname = SysAllocString(this->description.lpstrName);
-  else
-    *pname = 0;
+  *pname = SysAllocString(this->description.lpstrName);
 
   return S_OK;
 }
@@ -695,8 +654,8 @@ static HRESULT WINAPI OLEFontImpl_put_Name(
   if (!name)
     return CTL_E_INVALIDPROPERTYVALUE;
 
-  HeapFree(GetProcessHeap(), 0, This->description.lpstrName);
-  This->description.lpstrName = strdupW(name);
+  free(This->description.lpstrName);
+  This->description.lpstrName = wcsdup(name);
   if (!This->description.lpstrName) return E_OUTOFMEMORY;
 
   TRACE("new name %s\n", debugstr_w(This->description.lpstrName));
@@ -722,38 +681,24 @@ static HRESULT WINAPI OLEFontImpl_get_Size(
    * Convert realized font height in pixels to points descaled by current
    * scaling ratio then scaled up by 10000.
    */
-  psize->s.Lo = MulDiv(this->nRealHeight,
-                       this->cyHimetric * 72 * 10000,
-                       this->cyLogical * 2540);
-  psize->s.Hi = 0;
+  psize->Lo = MulDiv(this->nRealHeight, this->cyHimetric * 72 * 10000, this->cyLogical * 2540);
+  psize->Hi = 0;
 
   return S_OK;
 }
 
-/************************************************************************
- * OLEFontImpl_put_Size (IFont)
- */
-static HRESULT WINAPI OLEFontImpl_put_Size(
-  IFont* iface,
-  CY     size)
+static HRESULT WINAPI OLEFontImpl_put_Size(IFont *iface, CY size)
 {
   OLEFontImpl *this = impl_from_IFont(iface);
-  TRACE("(%p)->(%d)\n", this, size.s.Lo);
-  this->description.cySize.s.Hi = 0;
-  this->description.cySize.s.Lo = size.s.Lo;
+  TRACE("%p, %ld.\n", iface, size.Lo);
+  this->description.cySize.Hi = 0;
+  this->description.cySize.Lo = size.Lo;
   OLEFont_SendNotify(this, DISPID_FONT_SIZE);
 
   return S_OK;
 }
 
-/************************************************************************
- * OLEFontImpl_get_Bold (IFont)
- *
- * See Windows documentation for more details on IFont methods.
- */
-static HRESULT WINAPI OLEFontImpl_get_Bold(
-  IFont*  iface,
-  BOOL* pbold)
+static HRESULT WINAPI OLEFontImpl_get_Bold(IFont *iface, BOOL *pbold)
 {
   OLEFontImpl *this = impl_from_IFont(iface);
   TRACE("(%p)->(%p)\n", this, pbold);
@@ -998,13 +943,13 @@ static HRESULT WINAPI OLEFontImpl_Clone(
 
   *ppfont = NULL;
 
-  newObject = HeapAlloc(GetProcessHeap(), 0, sizeof(OLEFontImpl));
+  newObject = malloc(sizeof(OLEFontImpl));
   if (newObject==NULL)
     return E_OUTOFMEMORY;
 
   *newObject = *this;
   /* allocate separate buffer */
-  newObject->description.lpstrName = strdupW(this->description.lpstrName);
+  newObject->description.lpstrName = wcsdup(this->description.lpstrName);
 
   /* Increment internal ref in hfont item list */
   if(newObject->gdiFont) inc_int_ref(newObject->gdiFont);
@@ -1046,9 +991,9 @@ static HRESULT WINAPI OLEFontImpl_IsEqual(
 
   if(pFontOther == NULL)
     return E_POINTER;
-  else if (left->description.cySize.s.Lo != right->description.cySize.s.Lo)
+  else if (left->description.cySize.Lo != right->description.cySize.Lo)
     return S_FALSE;
-  else if (left->description.cySize.s.Hi != right->description.cySize.s.Hi)
+  else if (left->description.cySize.Hi != right->description.cySize.Hi)
     return S_FALSE;
   else if (left->description.sWeight != right->description.sWeight)
     return S_FALSE;
@@ -1081,7 +1026,8 @@ static HRESULT WINAPI OLEFontImpl_SetRatio(
   LONG   cyHimetric)
 {
   OLEFontImpl *this = impl_from_IFont(iface);
-  TRACE("(%p)->(%d, %d)\n", this, cyLogical, cyHimetric);
+
+  TRACE("%p, %ld, %ld.\n", iface, cyLogical, cyHimetric);
 
   if(cyLogical == 0 || cyHimetric == 0)
     return E_FAIL;
@@ -1247,7 +1193,6 @@ static HRESULT WINAPI OLEFontImpl_GetTypeInfo(
   LCID        lcid,
   ITypeInfo** ppTInfo)
 {
-  static const WCHAR stdole2tlb[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
   ITypeLib *tl;
   HRESULT hres;
 
@@ -1255,16 +1200,16 @@ static HRESULT WINAPI OLEFontImpl_GetTypeInfo(
   TRACE("(%p, iTInfo=%d, lcid=%04x, %p)\n", this, iTInfo, (int)lcid, ppTInfo);
   if (iTInfo != 0)
     return E_FAIL;
-  hres = LoadTypeLib(stdole2tlb, &tl);
+  hres = LoadTypeLib(L"stdole2.tlb", &tl);
   if (FAILED(hres)) {
     ERR("Could not load the stdole2.tlb?\n");
     return hres;
   }
   hres = ITypeLib_GetTypeInfoOfGuid(tl, &IID_IFontDisp, ppTInfo);
   ITypeLib_Release(tl);
-  if (FAILED(hres)) {
-    FIXME("Did not IDispatch typeinfo from typelib, hres %x\n",hres);
-  }
+  if (FAILED(hres))
+    FIXME("Did not IDispatch typeinfo from typelib, hres %#lx.\n", hres);
+
   return hres;
 }
 
@@ -1321,7 +1266,7 @@ static HRESULT WINAPI OLEFontImpl_Invoke(
   OLEFontImpl *this = impl_from_IDispatch(iface);
   HRESULT hr;
 
-  TRACE("%p->(%d,%s,0x%x,0x%x,%p,%p,%p,%p)\n", this, dispIdMember,
+  TRACE("%p, %ld, %s, %#lx, %#x, %p, %p, %p, %p.\n", iface, dispIdMember,
     debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExepInfo,
     puArgErr);
 
@@ -1518,7 +1463,7 @@ static HRESULT WINAPI OLEFontImpl_Invoke(
     }
     break;
   default:
-    ERR("member not found for dispid 0x%x\n", dispIdMember);
+    ERR("member not found for dispid %#lx.\n", dispIdMember);
     return DISP_E_MEMBERNOTFOUND;
   }
 }
@@ -1649,10 +1594,10 @@ static HRESULT WINAPI OLEFontImpl_Load(
   if (cbRead != sizeof(WORD)) return E_FAIL;
 
   /* Size */
-  IStream_Read(pLoadStream, &this->description.cySize.s.Lo, sizeof(DWORD), &cbRead);
+  IStream_Read(pLoadStream, &this->description.cySize.Lo, sizeof(DWORD), &cbRead);
   if (cbRead != sizeof(DWORD)) return E_FAIL;
 
-  this->description.cySize.s.Hi = 0;
+  this->description.cySize.Hi = 0;
 
   /* Name */
   IStream_Read(pLoadStream, &string_size, sizeof(BYTE), &cbRead);
@@ -1661,10 +1606,10 @@ static HRESULT WINAPI OLEFontImpl_Load(
   IStream_Read(pLoadStream, readBuffer, string_size, &cbRead);
   if (cbRead != string_size) return E_FAIL;
 
-  HeapFree(GetProcessHeap(), 0, this->description.lpstrName);
+  free(this->description.lpstrName);
 
   len = MultiByteToWideChar( CP_ACP, 0, readBuffer, string_size, NULL, 0 );
-  this->description.lpstrName = HeapAlloc( GetProcessHeap(), 0, (len+1) * sizeof(WCHAR) );
+  this->description.lpstrName = malloc((len + 1) * sizeof(WCHAR));
   MultiByteToWideChar( CP_ACP, 0, readBuffer, string_size, this->description.lpstrName, len );
   this->description.lpstrName[len] = 0;
 
@@ -1720,28 +1665,25 @@ static HRESULT WINAPI OLEFontImpl_Save(
   if (written != sizeof(WORD)) return E_FAIL;
 
   /* Size */
-  IStream_Write(pOutStream, &this->description.cySize.s.Lo, sizeof(DWORD), &written);
+  IStream_Write(pOutStream, &this->description.cySize.Lo, sizeof(DWORD), &written);
   if (written != sizeof(DWORD)) return E_FAIL;
 
   /* FontName */
-  if (this->description.lpstrName)
-    string_size = WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
-                                       lstrlenW(this->description.lpstrName), NULL, 0, NULL, NULL );
-  else
-    string_size = 0;
+  string_size = WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
+                                     lstrlenW(this->description.lpstrName), NULL, 0, NULL, NULL );
 
   IStream_Write(pOutStream, &string_size, sizeof(BYTE), &written);
   if (written != sizeof(BYTE)) return E_FAIL;
 
   if (string_size)
   {
-      if (!(writeBuffer = HeapAlloc( GetProcessHeap(), 0, string_size ))) return E_OUTOFMEMORY;
+      if (!(writeBuffer = malloc(string_size))) return E_OUTOFMEMORY;
       WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
                            lstrlenW(this->description.lpstrName),
                            writeBuffer, string_size, NULL, NULL );
 
       IStream_Write(pOutStream, writeBuffer, string_size, &written);
-      HeapFree(GetProcessHeap(), 0, writeBuffer);
+      free(writeBuffer);
 
       if (written != string_size) return E_FAIL;
   }
@@ -1771,10 +1713,9 @@ static HRESULT WINAPI OLEFontImpl_GetSizeMax(
   pcbSize->u.LowPart += sizeof(DWORD); /* Size */
   pcbSize->u.LowPart += sizeof(BYTE);  /* StrLength */
 
-  if (this->description.lpstrName!=0)
-      pcbSize->u.LowPart += WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
-                                                 lstrlenW(this->description.lpstrName),
-                                                 NULL, 0, NULL, NULL );
+  pcbSize->u.LowPart += WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
+                                             lstrlenW(this->description.lpstrName),
+                                             NULL, 0, NULL, NULL );
 
   return S_OK;
 }
@@ -1922,20 +1863,13 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
          Italic          =   0   'False
          Strikethrough   =   0   'False
 */
-    static const WCHAR sAttrName[] = {'N','a','m','e',0};
-    static const WCHAR sAttrSize[] = {'S','i','z','e',0};
-    static const WCHAR sAttrCharset[] = {'C','h','a','r','s','e','t',0};
-    static const WCHAR sAttrWeight[] = {'W','e','i','g','h','t',0};
-    static const WCHAR sAttrUnderline[] = {'U','n','d','e','r','l','i','n','e',0};
-    static const WCHAR sAttrItalic[] = {'I','t','a','l','i','c',0};
-    static const WCHAR sAttrStrikethrough[] = {'S','t','r','i','k','e','t','h','r','o','u','g','h',0};
     OLEFontImpl *this = impl_from_IPersistPropertyBag(iface);
     VARIANT value;
     HRESULT iRes;
 
     VariantInit(&value);
 
-    iRes = IPropertyBag_Read(pPropBag, sAttrName, &value, pErrorLog);
+    iRes = IPropertyBag_Read(pPropBag, L"Name", &value, pErrorLog);
     if (iRes == S_OK)
     {
         iRes = VariantChangeType(&value, &value, 0, VT_BSTR);
@@ -1948,7 +1882,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
     VariantClear(&value);
 
     if (iRes == S_OK) {
-        iRes = IPropertyBag_Read(pPropBag, sAttrSize, &value, pErrorLog);
+        iRes = IPropertyBag_Read(pPropBag, L"Size", &value, pErrorLog);
         if (iRes == S_OK)
         {
             iRes = VariantChangeType(&value, &value, 0, VT_CY);
@@ -1962,7 +1896,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
     }
 
     if (iRes == S_OK) {
-        iRes = IPropertyBag_Read(pPropBag, sAttrCharset, &value, pErrorLog);
+        iRes = IPropertyBag_Read(pPropBag, L"Charset", &value, pErrorLog);
         if (iRes == S_OK)
         {
             iRes = VariantChangeType(&value, &value, 0, VT_I2);
@@ -1976,7 +1910,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
     }
 
     if (iRes == S_OK) {
-        iRes = IPropertyBag_Read(pPropBag, sAttrWeight, &value, pErrorLog);
+        iRes = IPropertyBag_Read(pPropBag, L"Weight", &value, pErrorLog);
         if (iRes == S_OK)
         {
             iRes = VariantChangeType(&value, &value, 0, VT_I2);
@@ -1990,7 +1924,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
     }
 
     if (iRes == S_OK) {
-        iRes = IPropertyBag_Read(pPropBag, sAttrUnderline, &value, pErrorLog);
+        iRes = IPropertyBag_Read(pPropBag, L"Underline", &value, pErrorLog);
         if (iRes == S_OK)
         {
             iRes = VariantChangeType(&value, &value, 0, VT_BOOL);
@@ -2004,7 +1938,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
     }
 
     if (iRes == S_OK) {
-        iRes = IPropertyBag_Read(pPropBag, sAttrItalic, &value, pErrorLog);
+        iRes = IPropertyBag_Read(pPropBag, L"Italic", &value, pErrorLog);
         if (iRes == S_OK)
         {
             iRes = VariantChangeType(&value, &value, 0, VT_BOOL);
@@ -2018,7 +1952,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
     }
 
     if (iRes == S_OK) {
-        iRes = IPropertyBag_Read(pPropBag, sAttrStrikethrough, &value, pErrorLog);
+        iRes = IPropertyBag_Read(pPropBag, L"Strikethrough", &value, pErrorLog);
         if (iRes == S_OK)
         {
             iRes = VariantChangeType(&value, &value, 0, VT_BOOL);
@@ -2032,7 +1966,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
     }
 
     if (FAILED(iRes))
-        WARN("-- 0x%08x\n", iRes);
+        WARN("-- %#lx.\n", iRes);
     return iRes;
 }
 
@@ -2056,86 +1990,6 @@ static const IPersistPropertyBagVtbl OLEFontImpl_IPersistPropertyBag_VTable =
   OLEFontImpl_IPersistPropertyBag_Save
 };
 
-/************************************************************************
- * OLEFontImpl implementation of IPersistStreamInit.
- */
-static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_QueryInterface(
-   IPersistStreamInit *iface, REFIID riid, LPVOID *ppvObj
-) {
-  OLEFontImpl *this = impl_from_IPersistStreamInit(iface);
-  return IFont_QueryInterface(&this->IFont_iface,riid,ppvObj);
-}
-
-static ULONG WINAPI OLEFontImpl_IPersistStreamInit_AddRef(
-   IPersistStreamInit *iface
-) {
-  OLEFontImpl *this = impl_from_IPersistStreamInit(iface);
-  return IFont_AddRef(&this->IFont_iface);
-}
-
-static ULONG WINAPI OLEFontImpl_IPersistStreamInit_Release(
-   IPersistStreamInit *iface
-) {
-  OLEFontImpl *this = impl_from_IPersistStreamInit(iface);
-  return IFont_Release(&this->IFont_iface);
-}
-
-static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_GetClassID(
-   IPersistStreamInit *iface, CLSID *classid
-) {
-  FIXME("(%p,%p), stub!\n", iface, classid);
-  return E_FAIL;
-}
-
-static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_IsDirty(
-   IPersistStreamInit *iface
-) {
-  FIXME("(%p), stub!\n", iface);
-  return E_FAIL;
-}
-
-static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_Load(
-   IPersistStreamInit *iface, LPSTREAM pStm
-) {
-  FIXME("(%p,%p), stub!\n", iface, pStm);
-  return E_FAIL;
-}
-
-static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_Save(
-   IPersistStreamInit *iface, LPSTREAM pStm, BOOL fClearDirty
-) {
-  FIXME("(%p,%p,%d), stub!\n", iface, pStm, fClearDirty);
-  return E_FAIL;
-}
-
-static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_GetSizeMax(
-   IPersistStreamInit *iface, ULARGE_INTEGER *pcbSize
-) {
-  FIXME("(%p,%p), stub!\n", iface, pcbSize);
-  return E_FAIL;
-}
-
-static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_InitNew(
-   IPersistStreamInit *iface
-) {
-  FIXME("(%p), stub!\n", iface);
-  return S_OK;
-}
-
-static const IPersistStreamInitVtbl OLEFontImpl_IPersistStreamInit_VTable = 
-{
-  OLEFontImpl_IPersistStreamInit_QueryInterface,
-  OLEFontImpl_IPersistStreamInit_AddRef,
-  OLEFontImpl_IPersistStreamInit_Release,
-
-  OLEFontImpl_IPersistStreamInit_GetClassID,
-  OLEFontImpl_IPersistStreamInit_IsDirty,
-  OLEFontImpl_IPersistStreamInit_Load,
-  OLEFontImpl_IPersistStreamInit_Save,
-  OLEFontImpl_IPersistStreamInit_GetSizeMax,
-  OLEFontImpl_IPersistStreamInit_InitNew
-};
-
 /************************************************************************
  * OLEFontImpl_Construct
  *
@@ -2149,7 +2003,7 @@ static OLEFontImpl* OLEFontImpl_Construct(const FONTDESC *fontDesc)
 {
   OLEFontImpl* newObject;
 
-  newObject = HeapAlloc(GetProcessHeap(), 0, sizeof(OLEFontImpl));
+  newObject = malloc(sizeof(OLEFontImpl));
 
   if (newObject==0)
     return newObject;
@@ -2159,12 +2013,11 @@ static OLEFontImpl* OLEFontImpl_Construct(const FONTDESC *fontDesc)
   newObject->IPersistStream_iface.lpVtbl = &OLEFontImpl_IPersistStream_VTable;
   newObject->IConnectionPointContainer_iface.lpVtbl = &OLEFontImpl_IConnectionPointContainer_VTable;
   newObject->IPersistPropertyBag_iface.lpVtbl = &OLEFontImpl_IPersistPropertyBag_VTable;
-  newObject->IPersistStreamInit_iface.lpVtbl = &OLEFontImpl_IPersistStreamInit_VTable;
 
   newObject->ref = 1;
 
   newObject->description.cbSizeofstruct = sizeof(FONTDESC);
-  newObject->description.lpstrName      = strdupW(fontDesc->lpstrName);
+  newObject->description.lpstrName      = wcsdup(fontDesc->lpstrName);
   newObject->description.cySize         = fontDesc->cySize;
   newObject->description.sWeight        = fontDesc->sWeight;
   newObject->description.sCharset       = fontDesc->sCharset;
@@ -2205,14 +2058,14 @@ static void OLEFontImpl_Destroy(OLEFontImpl* fontDesc)
 {
   TRACE("(%p)\n", fontDesc);
 
-  HeapFree(GetProcessHeap(), 0, fontDesc->description.lpstrName);
+  free(fontDesc->description.lpstrName);
 
   if (fontDesc->pPropertyNotifyCP)
       IConnectionPoint_Release(fontDesc->pPropertyNotifyCP);
   if (fontDesc->pFontEventsCP)
       IConnectionPoint_Release(fontDesc->pFontEventsCP);
 
-  HeapFree(GetProcessHeap(), 0, fontDesc);
+  free(fontDesc);
 }
 
 /*******************************************************************************
diff --git a/dll/win32/oleaut32/olepicture.c b/dll/win32/oleaut32/olepicture.c
index 05dd10b13c4..a461d28f6eb 100644
--- a/dll/win32/oleaut32/olepicture.c
+++ b/dll/win32/oleaut32/olepicture.c
@@ -41,8 +41,6 @@
 #include <string.h>
 
 #define COBJMACROS
-#define NONAMELESSUNION
-
 #include "winerror.h"
 #include "windef.h"
 #include "winbase.h"
@@ -201,8 +199,8 @@ static void OLEPictureImpl_SetBitmap(OLEPictureImpl *This)
   BITMAP bm;
   HDC hdcRef;
 
-  TRACE("bitmap handle %p\n", This->desc.u.bmp.hbitmap);
-  if(GetObjectW(This->desc.u.bmp.hbitmap, sizeof(bm), &bm) != sizeof(bm)) {
+  TRACE("bitmap handle %p\n", This->desc.bmp.hbitmap);
+  if(GetObjectW(This->desc.bmp.hbitmap, sizeof(bm), &bm) != sizeof(bm)) {
     ERR("GetObject fails\n");
     return;
   }
@@ -230,8 +228,8 @@ static void OLEPictureImpl_SetIcon(OLEPictureImpl * This)
 {
     ICONINFO infoIcon;
 
-    TRACE("icon handle %p\n", This->desc.u.icon.hicon);
-    if (GetIconInfo(This->desc.u.icon.hicon, &infoIcon)) {
+    TRACE("icon handle %p\n", This->desc.icon.hicon);
+    if (GetIconInfo(This->desc.icon.hicon, &infoIcon)) {
         HDC hdcRef;
         BITMAP bm;
 
@@ -254,22 +252,10 @@ static void OLEPictureImpl_SetIcon(OLEPictureImpl * This)
         DeleteObject(infoIcon.hbmMask);
         if (infoIcon.hbmColor) DeleteObject(infoIcon.hbmColor);
     } else {
-        ERR("GetIconInfo() fails on icon %p\n", This->desc.u.icon.hicon);
+        ERR("GetIconInfo() fails on icon %p\n", This->desc.icon.hicon);
     }
 }
 
-static void OLEPictureImpl_SetEMF(OLEPictureImpl *This)
-{
-    ENHMETAHEADER emh;
-
-    GetEnhMetaFileHeader(This->desc.u.emf.hemf, sizeof(emh), &emh);
-
-    This->origWidth = 0;
-    This->origHeight = 0;
-    This->himetricWidth = emh.rclFrame.right - emh.rclFrame.left;
-    This->himetricHeight = emh.rclFrame.bottom - emh.rclFrame.top;
-}
-
 /************************************************************************
  * OLEPictureImpl_Construct
  *
@@ -290,7 +276,7 @@ static HRESULT OLEPictureImpl_Construct(LPPICTDESC pictDesc, BOOL fOwn, OLEPictu
   /*
    * Allocate space for the object.
    */
-  newObject = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(OLEPictureImpl));
+  newObject = calloc(1, sizeof(OLEPictureImpl));
   if (!newObject)
     return E_OUTOFMEMORY;
 
@@ -307,7 +293,7 @@ static HRESULT OLEPictureImpl_Construct(LPPICTDESC pictDesc, BOOL fOwn, OLEPictu
                         &newObject->pCP);
   if (hr != S_OK)
   {
-    HeapFree(GetProcessHeap(), 0, newObject);
+    free(newObject);
     return hr;
   }
 
@@ -338,9 +324,9 @@ static HRESULT OLEPictureImpl_Construct(LPPICTDESC pictDesc, BOOL fOwn, OLEPictu
 	break;
 
       case PICTYPE_METAFILE:
-	TRACE("metafile handle %p\n", pictDesc->u.wmf.hmeta);
-	newObject->himetricWidth = pictDesc->u.wmf.xExt;
-	newObject->himetricHeight = pictDesc->u.wmf.yExt;
+	TRACE("metafile handle %p\n", pictDesc->wmf.hmeta);
+	newObject->himetricWidth = pictDesc->wmf.xExt;
+	newObject->himetricHeight = pictDesc->wmf.yExt;
 	break;
 
       case PICTYPE_NONE:
@@ -353,7 +339,8 @@ static HRESULT OLEPictureImpl_Construct(LPPICTDESC pictDesc, BOOL fOwn, OLEPictu
         break;
 
       case PICTYPE_ENHMETAFILE:
-        OLEPictureImpl_SetEMF(newObject);
+        FIXME("EMF is not supported\n");
+        newObject->himetricWidth = newObject->himetricHeight = 0;
         break;
 
       default:
@@ -386,18 +373,18 @@ static void OLEPictureImpl_Destroy(OLEPictureImpl* Obj)
   if(Obj->fOwn) { /* We need to destroy the picture */
     switch(Obj->desc.picType) {
     case PICTYPE_BITMAP:
-      DeleteObject(Obj->desc.u.bmp.hbitmap);
+      DeleteObject(Obj->desc.bmp.hbitmap);
       if (Obj->hbmMask != NULL) DeleteObject(Obj->hbmMask);
       if (Obj->hbmXor != NULL) DeleteObject(Obj->hbmXor);
       break;
     case PICTYPE_METAFILE:
-      DeleteMetaFile(Obj->desc.u.wmf.hmeta);
+      DeleteMetaFile(Obj->desc.wmf.hmeta);
       break;
     case PICTYPE_ICON:
-      DestroyIcon(Obj->desc.u.icon.hicon);
+      DestroyIcon(Obj->desc.icon.hicon);
       break;
     case PICTYPE_ENHMETAFILE:
-      DeleteEnhMetaFile(Obj->desc.u.emf.hemf);
+      DeleteEnhMetaFile(Obj->desc.emf.hemf);
       break;
     case PICTYPE_NONE:
     case PICTYPE_UNINITIALIZED:
@@ -408,53 +395,34 @@ static void OLEPictureImpl_Destroy(OLEPictureImpl* Obj)
       break;
     }
   }
-  HeapFree(GetProcessHeap(), 0, Obj->data);
-  HeapFree(GetProcessHeap(), 0, Obj);
+  free(Obj->data);
+  free(Obj);
 }
 
-
-/************************************************************************
- * OLEPictureImpl_AddRef (IUnknown)
- *
- * See Windows documentation for more details on IUnknown methods.
- */
 static ULONG WINAPI OLEPictureImpl_AddRef(
   IPicture* iface)
 {
   OLEPictureImpl *This = impl_from_IPicture(iface);
   ULONG refCount = InterlockedIncrement(&This->ref);
 
-  TRACE("(%p)->(ref before=%d)\n", This, refCount - 1);
+  TRACE("%p, refcount %lu.\n", iface, refCount);
 
   return refCount;
 }
 
-/************************************************************************
- * OLEPictureImpl_Release (IUnknown)
- *
- * See Windows documentation for more details on IUnknown methods.
- */
 static ULONG WINAPI OLEPictureImpl_Release(
       IPicture* iface)
 {
   OLEPictureImpl *This = impl_from_IPicture(iface);
   ULONG refCount = InterlockedDecrement(&This->ref);
 
-  TRACE("(%p)->(ref before=%d)\n", This, refCount + 1);
+  TRACE("%p, refcount %lu.\n", iface, refCount);
 
-  /*
-   * If the reference count goes down to 0, perform suicide.
-   */
   if (!refCount) OLEPictureImpl_Destroy(This);
 
   return refCount;
 }
 
-/************************************************************************
- * OLEPictureImpl_QueryInterface (IUnknown)
- *
- * See Windows documentation for more details on IUnknown methods.
- */
 static HRESULT WINAPI OLEPictureImpl_QueryInterface(
   IPicture*  iface,
   REFIID  riid,
@@ -533,16 +501,16 @@ static HRESULT WINAPI OLEPictureImpl_get_Handle(IPicture *iface,
     *phandle = 0;
     break;
   case PICTYPE_BITMAP:
-    *phandle = HandleToUlong(This->desc.u.bmp.hbitmap);
+    *phandle = HandleToUlong(This->desc.bmp.hbitmap);
     break;
   case PICTYPE_METAFILE:
-    *phandle = HandleToUlong(This->desc.u.wmf.hmeta);
+    *phandle = HandleToUlong(This->desc.wmf.hmeta);
     break;
   case PICTYPE_ICON:
-    *phandle = HandleToUlong(This->desc.u.icon.hicon);
+    *phandle = HandleToUlong(This->desc.icon.hicon);
     break;
   case PICTYPE_ENHMETAFILE:
-    *phandle = HandleToUlong(This->desc.u.emf.hemf);
+    *phandle = HandleToUlong(This->desc.emf.hemf);
     break;
   default:
     FIXME("Unimplemented type %d\n", This->desc.picType);
@@ -566,7 +534,7 @@ static HRESULT WINAPI OLEPictureImpl_get_hPal(IPicture *iface,
 
     if (This->desc.picType == PICTYPE_BITMAP)
     {
-        *phandle = HandleToUlong(This->desc.u.bmp.hpal);
+        *phandle = HandleToUlong(This->desc.bmp.hpal);
         return S_OK;
     }
 
@@ -589,26 +557,18 @@ static HRESULT WINAPI OLEPictureImpl_get_Type(IPicture *iface,
   return S_OK;
 }
 
-/************************************************************************
- * OLEPictureImpl_get_Width
- */
-static HRESULT WINAPI OLEPictureImpl_get_Width(IPicture *iface,
-					       OLE_XSIZE_HIMETRIC *pwidth)
+static HRESULT WINAPI OLEPictureImpl_get_Width(IPicture *iface, OLE_XSIZE_HIMETRIC *pwidth)
 {
   OLEPictureImpl *This = impl_from_IPicture(iface);
-  TRACE("(%p)->(%p): width is %d\n", This, pwidth, This->himetricWidth);
+  TRACE("%p, %p.\n", iface, pwidth);
   *pwidth = This->himetricWidth;
   return S_OK;
 }
 
-/************************************************************************
- * OLEPictureImpl_get_Height
- */
-static HRESULT WINAPI OLEPictureImpl_get_Height(IPicture *iface,
-						OLE_YSIZE_HIMETRIC *pheight)
+static HRESULT WINAPI OLEPictureImpl_get_Height(IPicture *iface, OLE_YSIZE_HIMETRIC *pheight)
 {
   OLEPictureImpl *This = impl_from_IPicture(iface);
-  TRACE("(%p)->(%p): height is %d\n", This, pheight, This->himetricHeight);
+  TRACE("%p, %p.\n", iface, pheight);
   *pheight = This->himetricHeight;
   return S_OK;
 }
@@ -667,8 +627,8 @@ static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
 					    LPCRECT prcWBounds)
 {
   OLEPictureImpl *This = impl_from_IPicture(iface);
-  TRACE("(%p)->(%p, (%d,%d), (%d,%d) <- (%d,%d), (%d,%d), %p)\n",
-	This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, prcWBounds);
+  TRACE("%p, %p, (%ld,%ld), (%ld,%ld), (%ld,%ld), (%ld,%ld), %p)\n", iface, hdc, x, y, cx, cy, xSrc, ySrc,
+          cxSrc, cySrc, prcWBounds);
   if(prcWBounds)
   TRACE("prcWBounds %s\n", wine_dbgstr_rect(prcWBounds));
 
@@ -699,7 +659,7 @@ static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
     else
     {
         hbmMask = 0;
-        hbmXor = This->desc.u.bmp.hbitmap;
+        hbmXor = This->desc.bmp.hbitmap;
     }
 
     render_masked_bitmap(This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, hbmMask, hbmXor);
@@ -710,7 +670,7 @@ static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
   {
     ICONINFO info;
 
-    if (!GetIconInfo(This->desc.u.icon.hicon, &info))
+    if (!GetIconInfo(This->desc.icon.hicon, &info))
         return E_FAIL;
 
     render_masked_bitmap(This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, info.hbmMask, info.hbmColor);
@@ -736,7 +696,7 @@ static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
     SetViewportOrgEx(hdc, x, y, &prevOrg);
     SetViewportExtEx(hdc, cx, cy, &prevExt);
 
-    if (!PlayMetaFile(hdc, This->desc.u.wmf.hmeta))
+    if (!PlayMetaFile(hdc, This->desc.wmf.hmeta))
         ERR("PlayMetaFile failed!\n");
 
     /* We're done, restore the DC to the previous settings for converting
@@ -752,7 +712,7 @@ static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
   case PICTYPE_ENHMETAFILE:
   {
     RECT rc = { x, y, x + cx, y + cy };
-    PlayEnhMetaFile(hdc, This->desc.u.emf.hemf, &rc);
+    PlayEnhMetaFile(hdc, This->desc.emf.hemf, &rc);
     break;
   }
 
@@ -775,7 +735,7 @@ static HRESULT WINAPI OLEPictureImpl_set_hPal(IPicture *iface,
 
     if (This->desc.picType == PICTYPE_BITMAP)
     {
-        This->desc.u.bmp.hpal = ULongToHandle(hpal);
+        This->desc.bmp.hpal = ULongToHandle(hpal);
         OLEPicture_SendNotify(This,DISPID_PICT_HPAL);
         return S_OK;
     }
@@ -809,10 +769,10 @@ static HRESULT WINAPI OLEPictureImpl_SelectPicture(IPicture *iface,
       if (phdcOut)
 	  *phdcOut = This->hDCCur;
       if (This->hDCCur) SelectObject(This->hDCCur,This->stock_bitmap);
-      if (hdcIn) SelectObject(hdcIn,This->desc.u.bmp.hbitmap);
+      if (hdcIn) SelectObject(hdcIn,This->desc.bmp.hbitmap);
       This->hDCCur = hdcIn;
       if (phbmpOut)
-	  *phbmpOut = HandleToUlong(This->desc.u.bmp.hbitmap);
+	  *phbmpOut = HandleToUlong(This->desc.bmp.hbitmap);
       return S_OK;
   } else {
       FIXME("Don't know how to select picture type %d\n",This->desc.picType);
@@ -859,6 +819,19 @@ static HRESULT WINAPI OLEPictureImpl_PictureChanged(IPicture *iface)
   return S_OK;
 }
 
+/************************************************************************
+ * OLEPictureImpl_SaveAsFile
+ */
+static HRESULT WINAPI OLEPictureImpl_SaveAsFile(IPicture *iface,
+						IStream *pstream,
+						BOOL SaveMemCopy,
+						LONG *pcbSize)
+{
+  OLEPictureImpl *This = impl_from_IPicture(iface);
+  FIXME("(%p)->(%p, %d, %p), hacked stub.\n", This, pstream, SaveMemCopy, pcbSize);
+  return IStream_Write(pstream,This->data,This->datalen,(ULONG*)pcbSize);
+}
+
 /************************************************************************
  * OLEPictureImpl_get_Attributes
  */
@@ -1008,13 +981,40 @@ static HRESULT WINAPI OLEPictureImpl_IsDirty(
   return E_NOTIMPL;
 }
 
+static HRESULT OLEPictureImpl_LoadDIB(OLEPictureImpl *This, BYTE *xbuf, ULONG xread)
+{
+    BITMAPFILEHEADER	*bfh = (BITMAPFILEHEADER*)xbuf;
+    BITMAPINFO		*bi = (BITMAPINFO*)(bfh+1);
+    HDC			hdcref;
+
+    /* Does not matter whether this is a coreheader or not, we only use
+     * components which are in both
+     */
+    hdcref = GetDC(0);
+    This->desc.bmp.hbitmap = CreateDIBitmap(
+	hdcref,
+	&(bi->bmiHeader),
+	CBM_INIT,
+	xbuf+bfh->bfOffBits,
+	bi,
+       DIB_RGB_COLORS
+    );
+    ReleaseDC(0, hdcref);
+    if (This->desc.bmp.hbitmap == 0)
+        return E_FAIL;
+    This->desc.picType = PICTYPE_BITMAP;
+    OLEPictureImpl_SetBitmap(This);
+    return S_OK;
+}
+
 static HRESULT OLEPictureImpl_LoadWICSource(OLEPictureImpl *This, IWICBitmapSource *src)
 {
     HRESULT hr;
     BITMAPINFOHEADER bih;
+    HDC hdcref;
     UINT width, height;
     UINT stride, buffersize;
-    BYTE *bits, *mask = NULL;
+    LPBYTE bits=NULL;
     WICRect rc;
     IWICBitmapSource *real_source;
     UINT x, y;
@@ -1042,28 +1042,34 @@ static HRESULT OLEPictureImpl_LoadWICSource(OLEPictureImpl *This, IWICBitmapSour
     stride = 4 * width;
     buffersize = stride * height;
 
-    mask = HeapAlloc(GetProcessHeap(), 0, buffersize);
-    if (!mask)
+    bits = malloc(buffersize);
+    if (!bits)
     {
         hr = E_OUTOFMEMORY;
         goto end;
     }
 
-    This->desc.u.bmp.hbitmap = CreateDIBSection(0, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void **)&bits, NULL, 0);
-    if (This->desc.u.bmp.hbitmap == 0)
-    {
-        hr = E_FAIL;
-        goto end;
-    }
-
     rc.X = 0;
     rc.Y = 0;
     rc.Width = width;
     rc.Height = height;
     hr = IWICBitmapSource_CopyPixels(real_source, &rc, stride, buffersize, bits);
     if (FAILED(hr))
+        goto end;
+
+    hdcref = GetDC(0);
+    This->desc.bmp.hbitmap = CreateDIBitmap(
+        hdcref,
+        &bih,
+        CBM_INIT,
+        bits,
+        (BITMAPINFO*)&bih,
+        DIB_RGB_COLORS);
+
+    if (This->desc.bmp.hbitmap == 0)
     {
-        DeleteObject(This->desc.u.bmp.hbitmap);
+        hr = E_FAIL;
+        ReleaseDC(0, hdcref);
         goto end;
     }
 
@@ -1077,25 +1083,23 @@ static HRESULT OLEPictureImpl_LoadWICSource(OLEPictureImpl *This, IWICBitmapSour
             if((*pixel & 0x80000000) == 0)
             {
                 has_alpha = TRUE;
-                *(DWORD *)(mask + stride * y + 4 * x) = black;
+                *pixel = black;
             }
             else
-                *(DWORD *)(mask + stride * y + 4 * x) = white;
+                *pixel = white;
         }
     }
 
     if (has_alpha)
     {
-        HDC hdcref, hdcBmp, hdcXor, hdcMask;
+        HDC hdcBmp, hdcXor, hdcMask;
         HBITMAP hbmoldBmp, hbmoldXor, hbmoldMask;
 
-        hdcref = GetDC(0);
-
         This->hbmXor = CreateDIBitmap(
             hdcref,
             &bih,
             CBM_INIT,
-            mask,
+            bits,
             (BITMAPINFO*)&bih,
             DIB_RGB_COLORS
         );
@@ -1105,7 +1109,7 @@ static HRESULT OLEPictureImpl_LoadWICSource(OLEPictureImpl *This, IWICBitmapSour
         hdcXor = CreateCompatibleDC(NULL);
         hdcMask = CreateCompatibleDC(NULL);
 
-        hbmoldBmp = SelectObject(hdcBmp,This->desc.u.bmp.hbitmap);
+        hbmoldBmp = SelectObject(hdcBmp,This->desc.bmp.hbitmap);
         hbmoldXor = SelectObject(hdcXor,This->hbmXor);
         hbmoldMask = SelectObject(hdcMask,This->hbmMask);
 
@@ -1120,11 +1124,12 @@ static HRESULT OLEPictureImpl_LoadWICSource(OLEPictureImpl *This, IWICBitmapSour
         DeleteDC(hdcBmp);
         DeleteDC(hdcXor);
         DeleteDC(hdcMask);
-        ReleaseDC(0, hdcref);
     }
 
+    ReleaseDC(0, hdcref);
+
 end:
-    HeapFree(GetProcessHeap(), 0, mask);
+    free(bits);
     IWICBitmapSource_Release(real_source);
     return hr;
 }
@@ -1191,7 +1196,7 @@ static HRESULT OLEPictureImpl_LoadIcon(OLEPictureImpl *This, BYTE *xbuf, ULONG x
     HDC hdcRef;
     int	i;
 
-    TRACE("(this %p, xbuf %p, xread %u)\n", This, xbuf, xread);
+    TRACE("(this %p, xbuf %p, xread %lu)\n", This, xbuf, xread);
 
     /*
     FIXME("icon.idReserved=%d\n",cifd->idReserved);
@@ -1229,13 +1234,13 @@ static HRESULT OLEPictureImpl_LoadIcon(OLEPictureImpl *This, BYTE *xbuf, ULONG x
     }
     if (xread < cifd->idEntries[i].dwDIBOffset + cifd->idEntries[i].dwDIBSize)
     {
-        ERR("Icon data address %u is over %u bytes available.\n",
+        ERR("Icon data address %lu is over %lu bytes available.\n",
             cifd->idEntries[i].dwDIBOffset + cifd->idEntries[i].dwDIBSize, xread);
         return E_FAIL;
     }
     if (cifd->idType == 2)
     {
-        LPBYTE buf = HeapAlloc(GetProcessHeap(), 0, cifd->idEntries[i].dwDIBSize + 4);
+        BYTE *buf = malloc(cifd->idEntries[i].dwDIBSize + 4);
         memcpy(buf, &cifd->idEntries[i].xHotspot, 4);
         memcpy(buf + 4, xbuf+cifd->idEntries[i].dwDIBOffset, cifd->idEntries[i].dwDIBSize);
         hicon = CreateIconFromResourceEx(
@@ -1247,7 +1252,7 @@ static HRESULT OLEPictureImpl_LoadIcon(OLEPictureImpl *This, BYTE *xbuf, ULONG x
 		    cifd->idEntries[i].bHeight,
 		    0
 	);
-	HeapFree(GetProcessHeap(), 0, buf);
+	free(buf);
     }
     else
     {
@@ -1266,7 +1271,7 @@ static HRESULT OLEPictureImpl_LoadIcon(OLEPictureImpl *This, BYTE *xbuf, ULONG x
 	return E_FAIL;
     } else {
 	This->desc.picType = PICTYPE_ICON;
-	This->desc.u.icon.hicon = hicon;
+	This->desc.icon.hicon = hicon;
 	This->origWidth = cifd->idEntries[i].bWidth;
 	This->origHeight = cifd->idEntries[i].bHeight;
 	hdcRef = CreateCompatibleDC(0);
@@ -1289,7 +1294,7 @@ static HRESULT OLEPictureImpl_LoadEnhMetafile(OLEPictureImpl *This,
     GetEnhMetaFileHeader(hemf, sizeof(hdr), &hdr);
 
     This->desc.picType = PICTYPE_ENHMETAFILE;
-    This->desc.u.emf.hemf = hemf;
+    This->desc.emf.hemf = hemf;
 
     This->origWidth = 0;
     This->origHeight = 0;
@@ -1315,9 +1320,9 @@ static HRESULT OLEPictureImpl_LoadAPM(OLEPictureImpl *This,
     if (!hmf) return E_FAIL;
 
     This->desc.picType = PICTYPE_METAFILE;
-    This->desc.u.wmf.hmeta = hmf;
-    This->desc.u.wmf.xExt = 0;
-    This->desc.u.wmf.yExt = 0;
+    This->desc.wmf.hmeta = hmf;
+    This->desc.wmf.xExt = 0;
+    This->desc.wmf.yExt = 0;
 
     This->origWidth = 0;
     This->origHeight = 0;
@@ -1368,7 +1373,7 @@ static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface, IStream *pStm)
    */
   hr = IStream_Stat(pStm,&statstg,STATFLAG_NONAME);
   if (hr != S_OK) {
-      TRACE("stat failed with hres %x, proceeding to read all data.\n",hr);
+      TRACE("stat failed with hres %#lx, proceeding to read all data.\n",hr);
       statfailed = TRUE;
       /* we will read at least 8 byte ... just right below */
       statstg.cbSize.QuadPart = 8;
@@ -1380,7 +1385,7 @@ static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface, IStream *pStm)
   do {
       hr = IStream_Read(pStm, header, 8, &xread);
       if (hr != S_OK || xread!=8) {
-          ERR("Failure while reading picture header (hr is %x, nread is %d).\n",hr,xread);
+          ERR("Failure while reading picture header (hr is %#lx, nread is %ld).\n",hr,xread);
           return (hr?hr:E_FAIL);
       }
       headerread += xread;
@@ -1388,7 +1393,7 @@ static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface, IStream *pStm)
 
       if (!memcmp(&(header[0]),"lt\0\0", 4) && (statfailed || (header[1] + headerread <= statstg.cbSize.QuadPart))) {
           if (toread != 0 && toread != header[1]) 
-              FIXME("varying lengths of image data (prev=%u curr=%u), only last one will be used\n",
+              FIXME("varying lengths of image data (prev=%lu curr=%lu), only last one will be used\n",
                   toread, header[1]);
           toread = header[1];
           if (statfailed)
@@ -1413,7 +1418,7 @@ static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface, IStream *pStm)
               else toread -= 8;
               xread = 8;
           } else {
-              FIXME("Unknown stream header magic: %08x\n", header[0]);
+              FIXME("Unknown stream header magic: %#lx.\n", header[0]);
               toread = header[1];
           }
       }
@@ -1425,7 +1430,7 @@ static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface, IStream *pStm)
       ULONG nread = 42;
 
       TRACE("Reading all data from stream.\n");
-      xbuf = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, origsize);
+      xbuf = calloc(1, origsize);
       if (headerisdata)
           memcpy (xbuf, header, 8);
       while (1) {
@@ -1438,19 +1443,20 @@ static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface, IStream *pStm)
           if (!nread || hr != S_OK) /* done, or error */
               break;
           if (xread == origsize) {
-              origsize += sizeinc;
               sizeinc = 2*sizeinc; /* exponential increase */
-              xbuf = HeapReAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, xbuf, origsize);
+              xbuf = realloc(xbuf, origsize + sizeinc);
+              memset(xbuf + origsize, 0, sizeinc);
+              origsize += sizeinc;
           }
       }
       if (hr != S_OK)
-          TRACE("hr in no-stat loader case is %08x\n", hr);
-      TRACE("loaded %d bytes.\n", xread);
+          TRACE("hr in no-stat loader case is %#lx.\n", hr);
+      TRACE("loaded %ld bytes.\n", xread);
       This->datalen = xread;
       This->data    = xbuf;
   } else {
       This->datalen = toread+(headerisdata?8:0);
-      xbuf = This->data = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, This->datalen);
+      xbuf = This->data = calloc(1, This->datalen);
       if (!xbuf)
           return E_OUTOFMEMORY;
 
@@ -1465,7 +1471,7 @@ static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface, IStream *pStm)
               break;
       }
       if (xread != This->datalen)
-          ERR("Could only read %d of %d bytes out of stream?\n",xread,This->datalen);
+          ERR("Could only read %ld of %d bytes out of stream?\n", xread, This->datalen);
   }
   if (This->datalen == 0) { /* Marks the "NONE" picture */
       This->desc.picType = PICTYPE_NONE;
@@ -1488,7 +1494,7 @@ static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface, IStream *pStm)
     hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICJpegDecoder, xbuf, xread);
     break;
   case BITMAP_FORMAT_BMP: /* Bitmap */
-    hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICBmpDecoder, xbuf, xread);
+    hr = OLEPictureImpl_LoadDIB(This, xbuf, xread);
     break;
   case BITMAP_FORMAT_PNG: /* PNG */
     hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICPngDecoder, xbuf, xread);
@@ -1508,14 +1514,14 @@ static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface, IStream *pStm)
     hr = OLEPictureImpl_LoadEnhMetafile(This, xbuf, xread);
     if (hr == S_OK) break;
 
-    FIXME("Unknown magic %04x, %d read bytes:\n",magic,xread);
+    FIXME("Unknown magic %04x, %ld read bytes:\n", magic, xread);
     hr=E_FAIL;
     for (i=0;i<xread+8;i++) {
-	if (i<8) MESSAGE("%02x ",((unsigned char*)header)[i]);
-	else MESSAGE("%02x ",xbuf[i-8]);
-        if (i % 10 == 9) MESSAGE("\n");
+	if (i<8) FIXME("%02x ",((unsigned char*)header)[i]);
+	else FIXME("%02x ",xbuf[i-8]);
+        if (i % 10 == 9) FIXME("\n");
     }
-    MESSAGE("\n");
+    FIXME("\n");
     break;
   }
   }
@@ -1527,69 +1533,121 @@ static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface, IStream *pStm)
   return hr;
 }
 
-static BOOL serializeBMP(HBITMAP hBitmap, void ** ppBuffer, unsigned int * pLength)
+/* pass NULL buffer to fetch size */
+static HRESULT serializeBMP(HBITMAP hbmp, void **buffer, unsigned int *length)
 {
-    BOOL success = FALSE;
-    HDC hDC;
-    BITMAPINFO * pInfoBitmap;
-    int iNumPaletteEntries;
-    unsigned char * pPixelData;
-    BITMAPFILEHEADER * pFileHeader;
-    BITMAPINFO * pInfoHeader;
+    char infobuf[sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)] = { 0 };
+    BITMAPINFO *info = (BITMAPINFO *)infobuf;
+    BITMAP bm;
+    HBITMAP hdib = NULL;
+    BITMAPINFO *bitmap;
+    BITMAPFILEHEADER *filehdr;
+    int numentries;
+    HDC hdc;
+    HRESULT hr = S_OK;
+    unsigned char *data = NULL;
 
-    pInfoBitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
-        sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
+    hdc = GetDC(0);
+    if (!GetObjectW(hbmp, sizeof(bm), &bm)) {
+        hr = E_INVALIDARG;
+        goto done;
+    }
+
+    /* Convert 16bpp/32bpp bitmap to 24bpp */
+    if (bm.bmBitsPixel == 16 || bm.bmBitsPixel == 32) {
+        void *bits;
+        info->bmiHeader.biSize = sizeof(info->bmiHeader);
+        info->bmiHeader.biWidth = bm.bmWidth;
+        info->bmiHeader.biHeight = bm.bmHeight;
+        info->bmiHeader.biPlanes = 1;
+        info->bmiHeader.biBitCount = 24;
+        info->bmiHeader.biCompression = BI_RGB;
+        hdib = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &bits, NULL, 0);
+        if (!hdib) {
+            hr = E_OUTOFMEMORY;
+            goto done;
+        }
+        if (buffer) {
+            HDC src, dst;
+            src = CreateCompatibleDC(hdc);
+            dst = CreateCompatibleDC(hdc);
+            SelectObject(src, hbmp);
+            SelectObject(dst, hdib);
+            if (!BitBlt(dst, 0, 0, bm.bmWidth, bm.bmHeight, src, 0, 0, SRCCOPY))
+                hr = E_INVALIDARG;
+            DeleteDC(src);
+            DeleteDC(dst);
+            if (FAILED(hr))
+                goto done;
+        }
+        hbmp = hdib;
+    }
 
     /* Find out bitmap size and padded length */
-    hDC = GetDC(0);
-    pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
-    GetDIBits(hDC, hBitmap, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
-
-    /* Fetch bitmap palette & pixel data */
-
-    pPixelData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pInfoBitmap->bmiHeader.biSizeImage);
-    GetDIBits(hDC, hBitmap, 0, pInfoBitmap->bmiHeader.biHeight, pPixelData, pInfoBitmap, DIB_RGB_COLORS);
+    info->bmiHeader.biSize = sizeof(info->bmiHeader);
+    if (!GetDIBits(hdc, hbmp, 0, 0, NULL, info, DIB_RGB_COLORS)) {
+        hr = E_INVALIDARG;
+        goto done;
+    }
 
     /* Calculate the total length required for the BMP data */
-    if (pInfoBitmap->bmiHeader.biClrUsed != 0) {
-	iNumPaletteEntries = pInfoBitmap->bmiHeader.biClrUsed;
-	if (iNumPaletteEntries > 256) iNumPaletteEntries = 256;
+    if (info->bmiHeader.biClrUsed != 0) {
+        numentries = info->bmiHeader.biClrUsed;
+    if (numentries > 256)
+        numentries = 256;
     } else {
-	if (pInfoBitmap->bmiHeader.biBitCount <= 8)
-	    iNumPaletteEntries = 1 << pInfoBitmap->bmiHeader.biBitCount;
-	else
-    	    iNumPaletteEntries = 0;
+        if (info->bmiHeader.biBitCount <= 8)
+            numentries = 1 << info->bmiHeader.biBitCount;
+        else
+            numentries = 0;
     }
-    *pLength =
+
+    *length =
         sizeof(BITMAPFILEHEADER) +
         sizeof(BITMAPINFOHEADER) +
-        iNumPaletteEntries * sizeof(RGBQUAD) +
-        pInfoBitmap->bmiHeader.biSizeImage;
-    *ppBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *pLength);
+        numentries * sizeof(RGBQUAD) +
+        info->bmiHeader.biSizeImage;
+
+    if (!buffer)
+        goto done;
+
+    /* Fetch bitmap palette & pixel data */
+    if (!(data = malloc(info->bmiHeader.biSizeImage))) {
+        hr = E_OUTOFMEMORY;
+        goto done;
+    }
+
+    if (!GetDIBits(hdc, hbmp, 0, info->bmiHeader.biHeight, data, info, DIB_RGB_COLORS)) {
+        hr = E_INVALIDARG;
+        goto done;
+    }
+
+    if (!(*buffer = malloc(*length))) {
+        hr = E_OUTOFMEMORY;
+        goto done;
+    }
 
     /* Fill the BITMAPFILEHEADER */
-    pFileHeader = *ppBuffer;
-    pFileHeader->bfType = BITMAP_FORMAT_BMP;
-    pFileHeader->bfSize = *pLength;
-    pFileHeader->bfOffBits =
+    filehdr = *buffer;
+    filehdr->bfType = BITMAP_FORMAT_BMP;
+    filehdr->bfSize = *length;
+    filehdr->bfReserved1 = 0;
+    filehdr->bfReserved2 = 0;
+    filehdr->bfOffBits =
         sizeof(BITMAPFILEHEADER) +
         sizeof(BITMAPINFOHEADER) +
-        iNumPaletteEntries * sizeof(RGBQUAD);
+        numentries * sizeof(RGBQUAD);
 
     /* Fill the BITMAPINFOHEADER and the palette data */
-    pInfoHeader = (BITMAPINFO *)((unsigned char *)(*ppBuffer) + sizeof(BITMAPFILEHEADER));
-    memcpy(pInfoHeader, pInfoBitmap, sizeof(BITMAPINFOHEADER) + iNumPaletteEntries * sizeof(RGBQUAD));
-    memcpy(
-        (unsigned char *)(*ppBuffer) +
-            sizeof(BITMAPFILEHEADER) +
-            sizeof(BITMAPINFOHEADER) +
-            iNumPaletteEntries * sizeof(RGBQUAD),
-        pPixelData, pInfoBitmap->bmiHeader.biSizeImage);
-    success = TRUE;
+    bitmap = (BITMAPINFO *)((unsigned char *)(*buffer) + sizeof(BITMAPFILEHEADER));
+    memcpy(bitmap, info, sizeof(BITMAPINFOHEADER) + numentries * sizeof(RGBQUAD));
+    memcpy((unsigned char *)(*buffer) + filehdr->bfOffBits, data, bitmap->bmiHeader.biSizeImage);
 
-    HeapFree(GetProcessHeap(), 0, pPixelData);
-    HeapFree(GetProcessHeap(), 0, pInfoBitmap);
-    return success;
+done:
+    free(data);
+    ReleaseDC(0, hdc);
+    if (hdib) DeleteObject(hdib);
+    return hr;
 }
 
 static BOOL serializeIcon(HICON hIcon, void ** ppBuffer, unsigned int * pLength)
@@ -1604,7 +1662,7 @@ static BOOL serializeIcon(HICON hIcon, void ** ppBuffer, unsigned int * pLength)
 		unsigned char * pIconData = NULL;
 		unsigned int iDataSize = 0;
 
-        pInfoBitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
+        pInfoBitmap = calloc(1, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
 
 		/* Find out icon size */
 		hDC = GetDC(0);
@@ -1636,7 +1694,7 @@ static BOOL serializeIcon(HICON hIcon, void ** ppBuffer, unsigned int * pLength)
 */
 			/* Let's start with one CURSORICONFILEDIR and one CURSORICONFILEDIRENTRY */
 			iDataSize += 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY) + sizeof(BITMAPINFOHEADER);
-			pIconData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, iDataSize);
+			pIconData = calloc(1, iDataSize);
 
 			/* Fill out the CURSORICONFILEDIR */
 			pIconDir = (CURSORICONFILEDIR *)pIconData;
@@ -1685,7 +1743,7 @@ static BOOL serializeIcon(HICON hIcon, void ** ppBuffer, unsigned int * pLength)
 			iDataSize += pIconBitmapHeader->biHeight * iLengthScanLineMask;
 			pIconBitmapHeader->biSizeImage += pIconBitmapHeader->biHeight * iLengthScanLineMask;
 			pIconBitmapHeader->biHeight *= 2;
-			pIconData = HeapReAlloc(GetProcessHeap(), 0, pIconData, iDataSize);
+			pIconData = realloc(pIconData, iDataSize);
 			pIconEntry = (CURSORICONFILEDIRENTRY *)(pIconData + 3 * sizeof(WORD));
 			pIconBitmapHeader = (BITMAPINFOHEADER *)(pIconData + 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
 			pIconEntry->dwDIBSize = iDataSize - (3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
@@ -1735,25 +1793,13 @@ static BOOL serializeIcon(HICON hIcon, void ** ppBuffer, unsigned int * pLength)
 		if (hDC) ReleaseDC(0, hDC);
 		DeleteObject(infoIcon.hbmMask);
 		if (infoIcon.hbmColor) DeleteObject(infoIcon.hbmColor);
-		HeapFree(GetProcessHeap(), 0, pInfoBitmap);
+		free(pInfoBitmap);
 	} else {
-		printf("ERROR: Unable to get icon information (error %u)\n",
-			GetLastError());
+		ERR("Unable to get icon information (error %lu)\n", GetLastError());
 	}
         return success;
 }
 
-static BOOL serializeEMF(HENHMETAFILE hemf, void **buf, unsigned *size)
-{
-    *size = GetEnhMetaFileBits(hemf, 0, NULL);
-    if (!*size) return FALSE;
-
-    *buf = HeapAlloc(GetProcessHeap(), 0, *size);
-    if (!*buf) return FALSE;
-
-    return GetEnhMetaFileBits(hemf, *size, *buf) != 0;
-}
-
 static HRESULT WINAPI OLEPictureImpl_Save(
   IPersistStream* iface,IStream*pStm,BOOL fClearDirty)
 {
@@ -1762,7 +1808,6 @@ static HRESULT WINAPI OLEPictureImpl_Save(
     unsigned int iDataSize;
     DWORD header[2];
     ULONG dummy;
-    BOOL serializeResult = FALSE;
     OLEPictureImpl *This = impl_from_IPersistStream(iface);
 
     TRACE("%p %p %d\n", This, pStm, fClearDirty);
@@ -1776,12 +1821,12 @@ static HRESULT WINAPI OLEPictureImpl_Save(
 
     case PICTYPE_ICON:
         if (This->bIsDirty || !This->data) {
-            if (!serializeIcon(This->desc.u.icon.hicon, &pIconData, &iDataSize)) {
+            if (!serializeIcon(This->desc.icon.hicon, &pIconData, &iDataSize)) {
                 ERR("(%p,%p,%d), serializeIcon() failed\n", This, pStm, fClearDirty);
                 hResult = E_FAIL;
                 break;
             }
-            HeapFree(GetProcessHeap(), 0, This->data);
+            free(This->data);
             This->data = pIconData;
             This->datalen = iDataSize;
         }
@@ -1796,7 +1841,7 @@ static HRESULT WINAPI OLEPictureImpl_Save(
         if (This->bIsDirty || !This->data) {
             switch (This->keepOrigFormat ? This->loadtime_format : BITMAP_FORMAT_BMP) {
             case BITMAP_FORMAT_BMP:
-                serializeResult = serializeBMP(This->desc.u.bmp.hbitmap, &pIconData, &iDataSize);
+                hResult = serializeBMP(This->desc.bmp.hbitmap, &pIconData, &iDataSize);
                 break;
             case BITMAP_FORMAT_JPEG:
                 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format JPEG) not implemented!\n",This,pStm,fClearDirty);
@@ -1812,13 +1857,10 @@ static HRESULT WINAPI OLEPictureImpl_Save(
                 break;
             }
 
-            if (!serializeResult)
-            {
-                hResult = E_FAIL;
+            if (hResult != S_OK)
                 break;
-            }
 
-            HeapFree(GetProcessHeap(), 0, This->data);
+            free(This->data);
             This->data = pIconData;
             This->datalen = iDataSize;
         }
@@ -1829,31 +1871,12 @@ static HRESULT WINAPI OLEPictureImpl_Save(
         IStream_Write(pStm, This->data, This->datalen, &dummy);
         hResult = S_OK;
         break;
-
-    case PICTYPE_ENHMETAFILE:
-        if (This->bIsDirty || !This->data)
-        {
-            serializeResult = serializeEMF(This->desc.u.emf.hemf, &pIconData, &iDataSize);
-            if (!serializeResult)
-            {
-                hResult = E_FAIL;
-                break;
-            }
-
-            HeapFree(GetProcessHeap(), 0, This->data);
-            This->data = pIconData;
-            This->datalen = iDataSize;
-        }
-        header[0] = 0x0000746c;
-        header[1] = This->datalen;
-        IStream_Write(pStm, header, 2 * sizeof(DWORD), &dummy);
-        IStream_Write(pStm, This->data, This->datalen, &dummy);
-        hResult = S_OK;
-        break;
-
     case PICTYPE_METAFILE:
         FIXME("(%p,%p,%d), PICTYPE_METAFILE not implemented!\n",This,pStm,fClearDirty);
         break;
+    case PICTYPE_ENHMETAFILE:
+        FIXME("(%p,%p,%d),PICTYPE_ENHMETAFILE not implemented!\n",This,pStm,fClearDirty);
+        break;
     default:
         FIXME("(%p,%p,%d), [unknown type] not implemented!\n",This,pStm,fClearDirty);
         break;
@@ -1862,107 +1885,63 @@ static HRESULT WINAPI OLEPictureImpl_Save(
     return hResult;
 }
 
-static HRESULT WINAPI OLEPictureImpl_GetSizeMax(
-  IPersistStream* iface,ULARGE_INTEGER*pcbSize)
+static HRESULT WINAPI OLEPictureImpl_GetSizeMax(IPersistStream *iface, ULARGE_INTEGER *size)
 {
-  OLEPictureImpl *This = impl_from_IPersistStream(iface);
-  FIXME("(%p,%p),stub!\n",This,pcbSize);
-  return E_NOTIMPL;
-}
+    HRESULT hr = E_NOTIMPL;
+    OLEPictureImpl *This = impl_from_IPersistStream(iface);
+    unsigned int datasize = This->datalen;
 
-/************************************************************************
- * OLEPictureImpl_SaveAsFile
- */
-static HRESULT WINAPI OLEPictureImpl_SaveAsFile(IPicture *iface,
-    IStream *stream, BOOL mem_copy, LONG *size)
-{
-    OLEPictureImpl *This = impl_from_IPicture(iface);
-    void *data;
-    unsigned data_size;
-    ULONG written;
-    HRESULT hr;
+    FIXME("(%p,%p), partial stub!\n", This, size);
 
-    FIXME("(%p)->(%p,%d,%p): semi-stub\n", This, stream, mem_copy, size);
+    if (!size)
+        return E_INVALIDARG;
 
-    switch (This->desc.picType)
-    {
+    switch (This->desc.picType) {
     case PICTYPE_NONE:
-        return S_OK;
-
+        hr = S_OK;
+        break;
     case PICTYPE_ICON:
-        if (!mem_copy) return E_FAIL;
-
-        if (This->bIsDirty || !This->data)
-        {
-            if (!serializeIcon(This->desc.u.icon.hicon, &data, &data_size))
-                return E_FAIL;
-            HeapFree(GetProcessHeap(), 0, This->data);
-            This->data = data;
-            This->datalen = data_size;
-        }
-        hr = IStream_Write(stream, This->data, This->datalen, &written);
-        if (hr == S_OK && size) *size = written;
-        return hr;
-
+        FIXME("(%p), PICTYPE_ICON not implemented!\n",This);
+        break;
     case PICTYPE_BITMAP:
-        if (!mem_copy) return E_FAIL;
-
-        if (This->bIsDirty || !This->data)
-        {
-            switch (This->keepOrigFormat ? This->loadtime_format : BITMAP_FORMAT_BMP)
-            {
+        if (This->bIsDirty || !This->data) {
+            switch (This->keepOrigFormat ? This->loadtime_format : BITMAP_FORMAT_BMP) {
             case BITMAP_FORMAT_BMP:
-                if (!serializeBMP(This->desc.u.bmp.hbitmap, &data, &data_size))
-                    return E_FAIL;
+                hr = serializeBMP(This->desc.bmp.hbitmap, NULL, &datasize);
                 break;
             case BITMAP_FORMAT_JPEG:
-                FIXME("BITMAP_FORMAT_JPEG is not implemented\n");
-                return E_NOTIMPL;
+                FIXME("(%p), PICTYPE_BITMAP (format JPEG) not implemented!\n",This);
+                break;
             case BITMAP_FORMAT_GIF:
-                FIXME("BITMAP_FORMAT_GIF is not implemented\n");
-                return E_NOTIMPL;
+                FIXME("(%p), PICTYPE_BITMAP (format GIF) not implemented!\n",This);
+                break;
             case BITMAP_FORMAT_PNG:
-                FIXME("BITMAP_FORMAT_PNG is not implemented\n");
-                return E_NOTIMPL;
+                FIXME("(%p), PICTYPE_BITMAP (format PNG) not implemented!\n",This);
+                break;
             default:
-                FIXME("PICTYPE_BITMAP/%#x is not implemented\n", This->loadtime_format);
-                return E_NOTIMPL;
+                FIXME("(%p), PICTYPE_BITMAP (format UNKNOWN, using BMP?) not implemented!\n",This);
+                break;
             }
+        } else hr = S_OK;
 
-            HeapFree(GetProcessHeap(), 0, This->data);
-            This->data = data;
-            This->datalen = data_size;
-        }
-        hr = IStream_Write(stream, This->data, This->datalen, &written);
-        if (hr == S_OK && size) *size = written;
-        return hr;
-
+        break;
     case PICTYPE_METAFILE:
-        FIXME("PICTYPE_METAFILE is not implemented\n");
-        return E_NOTIMPL;
-
+        FIXME("(%p), PICTYPE_METAFILE not implemented!\n",This);
+        break;
     case PICTYPE_ENHMETAFILE:
-        if (!mem_copy) return E_FAIL;
-
-        if (This->bIsDirty || !This->data)
-        {
-            if (!serializeEMF(This->desc.u.emf.hemf, &data, &data_size))
-                return E_FAIL;
-            HeapFree(GetProcessHeap(), 0, This->data);
-            This->data = data;
-            This->datalen = data_size;
-        }
-        hr = IStream_Write(stream, This->data, This->datalen, &written);
-        if (hr == S_OK && size) *size = written;
-        return hr;
-
+        FIXME("(%p), PICTYPE_ENHMETAFILE not implemented!\n",This);
+        break;
     default:
-        FIXME("%#x is not implemented\n", This->desc.picType);
+        FIXME("(%p), [unknown type] not implemented!\n",This);
         break;
     }
-    return E_NOTIMPL;
+
+    size->HighPart = 0;
+    size->LowPart = datasize + 8;
+    return hr;
 }
 
+
 /************************************************************************
  *    IDispatch
  */
@@ -2035,7 +2014,6 @@ static HRESULT WINAPI OLEPictureImpl_GetTypeInfo(
   LCID        lcid,
   ITypeInfo** ppTInfo)
 {
-  static const WCHAR stdole2tlb[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
   ITypeLib *tl;
   HRESULT hres;
 
@@ -2044,7 +2022,7 @@ static HRESULT WINAPI OLEPictureImpl_GetTypeInfo(
   if (iTInfo != 0)
     return E_FAIL;
 
-  hres = LoadTypeLib(stdole2tlb, &tl);
+  hres = LoadTypeLib(L"stdole2.tlb", &tl);
   if (FAILED(hres))
   {
     ERR("Could not load stdole2.tlb\n");
@@ -2053,7 +2031,7 @@ static HRESULT WINAPI OLEPictureImpl_GetTypeInfo(
 
   hres = ITypeLib_GetTypeInfoOfGuid(tl, &IID_IPictureDisp, ppTInfo);
   if (FAILED(hres))
-    ERR("Did not get IPictureDisp typeinfo from typelib, hres %x\n", hres);
+    ERR("Did not get IPictureDisp typeinfo from typelib, hres %#lx.\n", hres);
 
   return hres;
 }
@@ -2249,7 +2227,7 @@ static HRESULT WINAPI OLEPictureImpl_Invoke(
     break;
   }
 
-  ERR("invalid dispid 0x%x or wFlags 0x%x\n", dispIdMember, wFlags);
+  ERR("invalid dispid %#lx or wFlags 0x%x\n", dispIdMember, wFlags);
   return DISP_E_MEMBERNOTFOUND;
 }
 
@@ -2348,7 +2326,7 @@ HRESULT WINAPI OleLoadPicture( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
   IPicture	*newpic;
   HRESULT hr;
 
-  TRACE("(%p,%d,%d,%s,%p), partially implemented.\n",
+  TRACE("%p, %ld, %d, %s, %p), partially implemented.\n",
 	lpstream, lSize, fRunmode, debugstr_guid(riid), ppvObj);
 
   hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
@@ -2387,7 +2365,7 @@ HRESULT WINAPI OleLoadPictureEx( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
   IPicture	*newpic;
   HRESULT hr;
 
-  FIXME("(%p,%d,%d,%s,x=%d,y=%d,f=%x,%p), partially implemented.\n",
+  FIXME("%p, %ld, %d, %s, %lu, %lu, %#lx, %p, partially implemented.\n",
 	lpstream, lSize, fRunmode, debugstr_guid(riid), xsiz, ysiz, flags, ppvObj);
 
   hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
@@ -2498,15 +2476,13 @@ HRESULT WINAPI OleLoadPicturePath( LPOLESTR szURLorPath, LPUNKNOWN punkCaller,
 		DWORD dwReserved, OLE_COLOR clrReserved, REFIID riid,
 		LPVOID *ppvRet )
 {
-  static const WCHAR file[] = { 'f','i','l','e',':',0 };
   IStream *stream;
   HRESULT hRes;
   WCHAR *file_candidate;
   WCHAR path_buf[MAX_PATH];
 
-  TRACE("(%s,%p,%d,%08x,%s,%p): stub\n",
-        debugstr_w(szURLorPath), punkCaller, dwReserved, clrReserved,
-        debugstr_guid(riid), ppvRet);
+  TRACE("%s, %p, %ld, %#lx, %s, %p.\n", debugstr_w(szURLorPath), punkCaller, dwReserved,
+        clrReserved, debugstr_guid(riid), ppvRet);
 
   if (!szURLorPath || !ppvRet)
       return E_INVALIDARG;
@@ -2514,7 +2490,7 @@ HRESULT WINAPI OleLoadPicturePath( LPOLESTR szURLorPath, LPUNKNOWN punkCaller,
   *ppvRet = NULL;
 
   /* Convert file URLs to DOS paths. */
-  if (wcsncmp(szURLorPath, file, 5) == 0) {
+  if (wcsncmp(szURLorPath, L"file:", 5) == 0) {
       DWORD size;
       hRes = CoInternetParseUrl(szURLorPath, PARSE_PATH_FROM_URL, 0, path_buf,
                                 ARRAY_SIZE(path_buf), &size, 0);
diff --git a/dll/win32/oleaut32/olepropframe.c b/dll/win32/oleaut32/olepropframe.c
index ecffdc9218a..cad1a2ad5c2 100644
--- a/dll/win32/oleaut32/olepropframe.c
+++ b/dll/win32/oleaut32/olepropframe.c
@@ -22,8 +22,6 @@
 #include <stdarg.h>
 
 #define COBJMACROS
-#define NONAMELESSUNION
-
 #include "windef.h"
 #include "winbase.h"
 #include "wingdi.h"
@@ -93,7 +91,7 @@ static ULONG WINAPI PropertyPageSite_AddRef(IPropertyPageSite* iface)
     PropertyPageSite *this = impl_from_IPropertyPageSite(iface);
     LONG ref = InterlockedIncrement(&this->ref);
 
-    TRACE("(%p) ref=%d\n", this, ref);
+    TRACE("%p, refcount %ld.\n", iface, ref);
     return ref;
 }
 
@@ -102,7 +100,7 @@ static ULONG WINAPI PropertyPageSite_Release(IPropertyPageSite* iface)
     PropertyPageSite *this = impl_from_IPropertyPageSite(iface);
     LONG ref = InterlockedDecrement(&this->ref);
 
-    TRACE("(%p) ref=%d\n", this, ref);
+    TRACE("%p, refcount %ld.\n", iface, ref);
     if(!ref)
         HeapFree(GetProcessHeap(), 0, this);
     return ref;
@@ -111,7 +109,7 @@ static ULONG WINAPI PropertyPageSite_Release(IPropertyPageSite* iface)
 static HRESULT WINAPI PropertyPageSite_OnStatusChange(
         IPropertyPageSite *iface, DWORD dwFlags)
 {
-    TRACE("(%p, %x)\n", iface, dwFlags);
+    TRACE("%p, %lx.\n", iface, dwFlags);
     return S_OK;
 }
 
@@ -154,8 +152,6 @@ static IPropertyPageSiteVtbl PropertyPageSiteVtbl = {
  */
 HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
 {
-    static const WCHAR comctlW[] = { 'c','o','m','c','t','l','3','2','.','d','l','l',0 };
-
     PROPSHEETHEADERW property_sheet;
     PROPSHEETPAGEW property_sheet_page;
     struct {
@@ -180,7 +176,7 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
     if(!lpParams)
         return E_POINTER;
 
-    TRACE("(%d %p %d %d %s %d %p %d %p %d %d)\n", lpParams->cbStructSize,
+    TRACE("%ld, %p, %d, %d, %s, %ld, %p, %ld, %p, %ld, %ld.\n", lpParams->cbStructSize,
             lpParams->hWndOwner, lpParams->x, lpParams->y,
             debugstr_w(lpParams->lpszCaption), lpParams->cObjects,
             lpParams->lplpUnk, lpParams->cPages, lpParams->lpPages,
@@ -198,7 +194,7 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
         FIXME("dispidInitialProperty not yet implemented\n");
 
     hdc = GetDC(NULL);
-    hcomctl = LoadLibraryW(comctlW);
+    hcomctl = LoadLibraryW(L"comctl32.dll");
     if(hcomctl)
         property_sheet_dialog_find = FindResourceW(hcomctl,
                 MAKEINTRESOURCEW(1006 /*IDD_PROPSHEET*/), (LPWSTR)RT_DIALOG);
@@ -246,14 +242,14 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
         property_sheet.pszCaption = lpParams->lpszCaption;
     }
 
-    property_sheet.u3.phpage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+    property_sheet.phpage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
             lpParams->cPages*sizeof(HPROPSHEETPAGE));
     property_page = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
             lpParams->cPages*sizeof(IPropertyPage*));
     dialogs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
             lpParams->cPages*sizeof(*dialogs));
-    if(!property_sheet.u3.phpage || !property_page || !dialogs) {
-        HeapFree(GetProcessHeap(), 0, property_sheet.u3.phpage);
+    if(!property_sheet.phpage || !property_page || !dialogs) {
+        HeapFree(GetProcessHeap(), 0, property_sheet.phpage);
         HeapFree(GetProcessHeap(), 0, property_page);
         HeapFree(GetProcessHeap(), 0, dialogs);
         return E_OUTOFMEMORY;
@@ -288,7 +284,7 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
         res = IPropertyPage_SetObjects(property_page[i],
                 lpParams->cObjects, lpParams->lplpUnk);
         if(FAILED(res))
-            WARN("SetObjects() failed, hr %#x.\n", res);
+            WARN("SetObjects() failed, hr %#lx.\n", res);
 
         res = IPropertyPage_GetPageInfo(property_page[i], &page_info);
         if(FAILED(res))
@@ -297,11 +293,11 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
         dialogs[i].template.cx = MulDiv(page_info.size.cx, 4, font_width);
         dialogs[i].template.cy = MulDiv(page_info.size.cy, 8, font_height);
 
-        property_sheet_page.u.pResource = &dialogs[i].template;
+        property_sheet_page.pResource = &dialogs[i].template;
         property_sheet_page.lParam = (LPARAM)property_page[i];
         property_sheet_page.pszTitle = page_info.pszTitle;
 
-        property_sheet.u3.phpage[property_sheet.nPages++] =
+        property_sheet.phpage[property_sheet.nPages++] =
             CreatePropertySheetPageW(&property_sheet_page);
     }
 
@@ -314,7 +310,7 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
 
     HeapFree(GetProcessHeap(), 0, dialogs);
     HeapFree(GetProcessHeap(), 0, property_page);
-    HeapFree(GetProcessHeap(), 0, property_sheet.u3.phpage);
+    HeapFree(GetProcessHeap(), 0, property_sheet.phpage);
     return S_OK;
 }
 
diff --git a/dll/win32/oleaut32/precomp.h b/dll/win32/oleaut32/precomp.h
index 4e80f66694e..8c3435ee5e7 100644
--- a/dll/win32/oleaut32/precomp.h
+++ b/dll/win32/oleaut32/precomp.h
@@ -9,8 +9,6 @@
 #define _INC_WINDOWS
 
 #define COBJMACROS
-#define NONAMELESSUNION
-#define NONAMELESSSTRUCT
 
 #include <windef.h>
 #include <winbase.h>
diff --git a/dll/win32/oleaut32/recinfo.c b/dll/win32/oleaut32/recinfo.c
index 44d46595e85..dfe7625a986 100644
--- a/dll/win32/oleaut32/recinfo.c
+++ b/dll/win32/oleaut32/recinfo.c
@@ -19,8 +19,6 @@
 #include <stdarg.h>
 
 #define COBJMACROS
-#define NONAMELESSUNION
-
 #include "windef.h"
 #include "winbase.h"
 #include "objbase.h"
@@ -163,7 +161,7 @@ static ULONG WINAPI IRecordInfoImpl_AddRef(IRecordInfo *iface)
 {
     IRecordInfoImpl *This = impl_from_IRecordInfo(iface);
     ULONG ref = InterlockedIncrement(&This->ref);
-    TRACE("(%p) -> %d\n", This, ref);
+    TRACE("%p, refcount %lu.\n", iface, ref);
     return ref;
 }
 
@@ -172,16 +170,16 @@ static ULONG WINAPI IRecordInfoImpl_Release(IRecordInfo *iface)
     IRecordInfoImpl *This = impl_from_IRecordInfo(iface);
     ULONG ref = InterlockedDecrement(&This->ref);
 
-    TRACE("(%p) -> %d\n", This, ref);
+    TRACE("%p, refcount %lu.\n", iface, ref);
 
     if(!ref) {
         int i;
         for(i=0; i<This->n_vars; i++)
             SysFreeString(This->fields[i].name);
         SysFreeString(This->name);
-        HeapFree(GetProcessHeap(), 0, This->fields);
+        free(This->fields);
         ITypeInfo_Release(This->pTypeInfo);
-        HeapFree(GetProcessHeap(), 0, This);
+        free(This);
     }
     return ref;
 }
@@ -441,8 +439,7 @@ static HRESULT WINAPI IRecordInfoImpl_PutField(IRecordInfo *iface, ULONG wFlags,
     IRecordInfoImpl *This = impl_from_IRecordInfo(iface);
     int i;
 
-    TRACE("(%p)->(%08x %p %s %p)\n", This, wFlags, pvData, debugstr_w(szFieldName),
-                                    pvarField);
+    TRACE("%p, %#lx, %p, %s, %p.\n", iface, wFlags, pvData, debugstr_w(szFieldName), pvarField);
 
     if(!pvData || !szFieldName || !pvarField
             || (wFlags != INVOKE_PROPERTYPUTREF && wFlags != INVOKE_PROPERTYPUT))
@@ -469,7 +466,7 @@ static HRESULT WINAPI IRecordInfoImpl_PutFieldNoCopy(IRecordInfo *iface, ULONG w
     IRecordInfoImpl *This = impl_from_IRecordInfo(iface);
     int i;
 
-    FIXME("(%p)->(%08x %p %s %p) stub\n", This, wFlags, pvData, debugstr_w(szFieldName), pvarField);
+    FIXME("%p, %#lx, %p, %s, %p stub\n", iface, wFlags, pvData, debugstr_w(szFieldName), pvarField);
 
     if(!pvData || !szFieldName || !pvarField
             || (wFlags != INVOKE_PROPERTYPUTREF && wFlags != INVOKE_PROPERTYPUT))
@@ -525,7 +522,7 @@ static PVOID WINAPI IRecordInfoImpl_RecordCreate(IRecordInfo *iface)
 
     TRACE("(%p)\n", This);
 
-    record = HeapAlloc(GetProcessHeap(), 0, This->size);
+    record = CoTaskMemAlloc(This->size);
     IRecordInfo_RecordInit(iface, record);
     TRACE("created record at %p\n", record);
     return record;
@@ -556,9 +553,7 @@ static HRESULT WINAPI IRecordInfoImpl_RecordDestroy(IRecordInfo *iface, PVOID pv
     if(FAILED(hres))
         return hres;
 
-    if(!HeapFree(GetProcessHeap(), 0, pvRecord))
-        return E_INVALIDARG;
-
+    CoTaskMemFree(pvRecord);
     return S_OK;
 }
 
@@ -597,8 +592,8 @@ HRESULT WINAPI GetRecordInfoFromGuids(REFGUID rGuidTypeLib, ULONG uVerMajor,
     ITypeInfo *pTypeInfo;
     ITypeLib *pTypeLib;
     HRESULT hres;
-    
-    TRACE("(%p,%d,%d,%d,%s,%p)\n", rGuidTypeLib, uVerMajor, uVerMinor,
+
+    TRACE("%s, %lu, %lu, %#lx, %s, %p.\n", debugstr_guid(rGuidTypeLib), uVerMajor, uVerMinor,
             lcid, debugstr_guid(rGuidTypeInfo), ppRecInfo);
 
     hres = LoadRegTypeLib(rGuidTypeLib, uVerMajor, uVerMinor, lcid, &pTypeLib);
@@ -637,22 +632,22 @@ HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo* pTI, IRecordInfo** ppRecInfo
     
     hres = ITypeInfo_GetTypeAttr(pTI, &typeattr);
     if(FAILED(hres) || !typeattr) {
-        WARN("GetTypeAttr failed: %08x\n", hres);
+        WARN("GetTypeAttr failed: %#lx.\n", hres);
         return hres;
     }
 
     if(typeattr->typekind == TKIND_ALIAS) {
-        hres = ITypeInfo_GetRefTypeInfo(pTI, typeattr->tdescAlias.u.hreftype, &pTypeInfo);
+        hres = ITypeInfo_GetRefTypeInfo(pTI, typeattr->tdescAlias.hreftype, &pTypeInfo);
         guid = typeattr->guid;
         ITypeInfo_ReleaseTypeAttr(pTI, typeattr);
         if(FAILED(hres)) {
-            WARN("GetRefTypeInfo failed: %08x\n", hres);
+            WARN("GetRefTypeInfo failed: %#lx.\n", hres);
             return hres;
         }
         hres = ITypeInfo_GetTypeAttr(pTypeInfo, &typeattr);
         if(FAILED(hres)) {
             ITypeInfo_Release(pTypeInfo);
-            WARN("GetTypeAttr failed for referenced type: %08x\n", hres);
+            WARN("GetTypeAttr failed for referenced type: %#lx.\n", hres);
             return hres;
         }
     }else  {
@@ -668,7 +663,7 @@ HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo* pTI, IRecordInfo** ppRecInfo
         return E_INVALIDARG;
     }
 
-    ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret));
+    ret = calloc(1, sizeof(*ret));
     ret->IRecordInfo_iface.lpVtbl = &IRecordInfoImplVtbl;
     ret->ref = 1;
     ret->pTypeInfo = pTypeInfo;
@@ -688,7 +683,7 @@ HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo* pTI, IRecordInfo** ppRecInfo
         ret->name = NULL;
     }
 
-    ret->fields = HeapAlloc(GetProcessHeap(), 0, ret->n_vars*sizeof(fieldstr));
+    ret->fields = calloc(ret->n_vars, sizeof(fieldstr));
     for(i = 0; i<ret->n_vars; i++) {
         VARDESC *vardesc;
         hres = ITypeInfo_GetVarDesc(pTypeInfo, i, &vardesc);
@@ -698,12 +693,12 @@ HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo* pTI, IRecordInfo** ppRecInfo
         }
         ret->fields[i].vt = vardesc->elemdescVar.tdesc.vt;
         ret->fields[i].varkind = vardesc->varkind;
-        ret->fields[i].offset = vardesc->u.oInst;
+        ret->fields[i].offset = vardesc->oInst;
         hres = ITypeInfo_GetDocumentation(pTypeInfo, vardesc->memid, &ret->fields[i].name,
                 NULL, NULL, NULL);
         if(FAILED(hres))
-            WARN("GetDocumentation failed: %08x\n", hres);
-        TRACE("field=%s, offset=%d\n", debugstr_w(ret->fields[i].name), ret->fields[i].offset);
+            WARN("GetDocumentation failed: %#lx.\n", hres);
+        TRACE("field=%s, offset=%ld\n", debugstr_w(ret->fields[i].name), ret->fields[i].offset);
         ITypeInfo_ReleaseVarDesc(pTypeInfo, vardesc);
     }
 
diff --git a/dll/win32/oleaut32/safearray.c b/dll/win32/oleaut32/safearray.c
index 0b769358f65..92a73c768da 100644
--- a/dll/win32/oleaut32/safearray.c
+++ b/dll/win32/oleaut32/safearray.c
@@ -287,7 +287,7 @@ static HRESULT SAFEARRAY_DestroyData(SAFEARRAY *psa, ULONG ulStartCell)
     ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
 
     if (ulStartCell > ulCellCount) {
-      FIXME("unexpected ulCellCount %d, start %d\n",ulCellCount,ulStartCell);
+      FIXME("unexpected ulCellCount %ld, start %ld\n", ulCellCount, ulStartCell);
       return E_UNEXPECTED;
     }
 
@@ -372,7 +372,7 @@ static HRESULT SAFEARRAY_CopyData(SAFEARRAY *psa, SAFEARRAY *dest)
 
         /* destination is cleared automatically */
         hRet = VariantCopy(dest_var, src_var);
-        if (FAILED(hRet)) FIXME("VariantCopy failed with 0x%08x, element %u\n", hRet, ulCellCount);
+        if (FAILED(hRet)) FIXME("VariantCopy failed with %#lx, element %lu.\n", hRet, ulCellCount);
         src_var++;
         dest_var++;
       }
@@ -495,7 +495,7 @@ HRESULT WINAPI SafeArrayAllocDescriptor(UINT cDims, SAFEARRAY **ppsaOut)
 
   (*ppsaOut)->cDims = cDims;
 
-  TRACE("(%d): %u bytes allocated for descriptor.\n", cDims, allocSize);
+  TRACE("%d: %lu bytes allocated for descriptor.\n", cDims, allocSize);
   return S_OK;
 }
 
@@ -569,7 +569,7 @@ HRESULT WINAPI SafeArrayAllocData(SAFEARRAY *psa)
     if (psa->pvData)
     {
       hRet = S_OK;
-      TRACE("%u bytes allocated for data at %p (%u objects).\n",
+      TRACE("%lu bytes allocated for data at %p (%lu objects).\n",
             ulSize * psa->cbElements, psa->pvData, ulSize);
     }
     else
@@ -676,7 +676,7 @@ SAFEARRAY* WINAPI SafeArrayCreateEx(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsa
  */
 SAFEARRAY* WINAPI SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements)
 {
-  TRACE("(%s,%d,%u)\n", debugstr_vt(vt), lLbound, cElements);
+  TRACE("%s, %ld, %lu.\n", debugstr_vt(vt), lLbound, cElements);
 
   if (vt == VT_RECORD)
     return NULL;
@@ -708,7 +708,7 @@ SAFEARRAY* WINAPI SafeArrayCreateVectorEx(VARTYPE vt, LONG lLbound, ULONG cEleme
   IRecordInfo* iRecInfo = pvExtra;
   SAFEARRAY* psa;
 
-  TRACE("(%s,%d,%u,%p)\n", debugstr_vt(vt), lLbound, cElements, pvExtra);
+  TRACE("%s, %ld, %lu, %p.\n", debugstr_vt(vt), lLbound, cElements, pvExtra);
 
   if (vt == VT_RECORD)
   {
@@ -886,7 +886,7 @@ HRESULT WINAPI SafeArrayPutElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData
         VARIANT* lpDest = lpvDest;
 
         hRet = VariantCopy(lpDest, lpVariant);
-        if (FAILED(hRet)) FIXME("VariantCopy failed with 0x%x\n", hRet);
+        if (FAILED(hRet)) FIXME("VariantCopy failed with %#lx.\n", hRet);
       }
       else if (psa->fFeatures & FADF_BSTR)
       {
@@ -971,7 +971,7 @@ HRESULT WINAPI SafeArrayGetElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData
         /* The original content of pvData is ignored. */
         V_VT(lpDest) = VT_EMPTY;
         hRet = VariantCopy(lpDest, lpVariant);
-	if (FAILED(hRet)) FIXME("VariantCopy failed with 0x%x\n", hRet);
+        if (FAILED(hRet)) FIXME("VariantCopy failed with %#lx.\n", hRet);
       }
       else if (psa->fFeatures & FADF_BSTR)
       {
@@ -1113,8 +1113,8 @@ UINT WINAPI SafeArrayGetDim(SAFEARRAY *psa)
  */
 UINT WINAPI SafeArrayGetElemsize(SAFEARRAY *psa)
 {
-  TRACE("(%p) returning %d\n", psa, psa ? psa->cbElements : 0u);
-  return psa ? psa->cbElements : 0;
+    TRACE("%p, returning %ld.\n", psa, psa ? psa->cbElements : 0u);
+    return psa ? psa->cbElements : 0;
 }
 
 /*************************************************************************
@@ -1460,10 +1460,10 @@ HRESULT WINAPI SafeArrayRedim(SAFEARRAY *psa, SAFEARRAYBOUND *psabound)
 
   TRACE("(%p,%p)\n", psa, psabound);
   
-  if (!psa || psa->fFeatures & FADF_FIXEDSIZE || !psabound)
+  if (!psa || !psabound)
     return E_INVALIDARG;
 
-  if (psa->cLocks > 0)
+  if (psa->fFeatures & FADF_FIXEDSIZE || psa->cLocks)
     return DISP_E_ARRAYISLOCKED;
 
   hr = SafeArrayLock(psa);
diff --git a/dll/win32/oleaut32/thunks.c b/dll/win32/oleaut32/thunks.c
new file mode 100644
index 00000000000..c6676041f71
--- /dev/null
+++ b/dll/win32/oleaut32/thunks.c
@@ -0,0 +1,187 @@
+/*
+ * oleaut32 thunking
+ *
+ * Copyright 2019, 2024 Alexandre Julliard
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
+ */
+
+#if 0
+#pragma makedep arm64ec_x64
+#endif
+
+#define COBJMACROS
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "wine/asm.h"
+
+#ifdef __i386__
+
+__ASM_GLOBAL_FUNC( call_method,
+                   "pushl %ebp\n\t"
+                   __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
+                   __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
+                   "movl %esp,%ebp\n\t"
+                   __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
+                   "pushl %esi\n\t"
+                   __ASM_CFI(".cfi_rel_offset %esi,-4\n\t")
+                   "pushl %edi\n\t"
+                   __ASM_CFI(".cfi_rel_offset %edi,-8\n\t")
+                   "movl 12(%ebp),%edx\n\t"
+                   "movl %esp,%edi\n\t"
+                   "shll $2,%edx\n\t"
+                   "jz 1f\n\t"
+                   "subl %edx,%edi\n\t"
+                   "andl $~15,%edi\n\t"
+                   "movl %edi,%esp\n\t"
+                   "movl 12(%ebp),%ecx\n\t"
+                   "movl 16(%ebp),%esi\n\t"
+                   "cld\n\t"
+                   "rep; movsl\n"
+                   "1:\tcall *8(%ebp)\n\t"
+                   "subl %esp,%edi\n\t"
+                   "movl 20(%ebp),%ecx\n\t"
+                   "movl %edi,(%ecx)\n\t"
+                   "leal -8(%ebp),%esp\n\t"
+                   "popl %edi\n\t"
+                   __ASM_CFI(".cfi_same_value %edi\n\t")
+                   "popl %esi\n\t"
+                   __ASM_CFI(".cfi_same_value %esi\n\t")
+                   "popl %ebp\n\t"
+                   __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
+                   __ASM_CFI(".cfi_same_value %ebp\n\t")
+                   "ret" )
+__ASM_GLOBAL_FUNC( call_double_method,
+                   "jmp " __ASM_NAME("call_method") )
+
+#elif defined __x86_64__
+
+__ASM_GLOBAL_FUNC( call_method,
+                   "pushq %rbp\n\t"
+                   __ASM_SEH(".seh_pushreg %rbp\n\t")
+                   __ASM_CFI(".cfi_adjust_cfa_offset 8\n\t")
+                   __ASM_CFI(".cfi_rel_offset %rbp,0\n\t")
+                   "movq %rsp,%rbp\n\t"
+                   __ASM_SEH(".seh_setframe %rbp,0\n\t")
+                   __ASM_CFI(".cfi_def_cfa_register %rbp\n\t")
+                   "pushq %rsi\n\t"
+                   __ASM_SEH(".seh_pushreg %rsi\n\t")
+                   __ASM_CFI(".cfi_rel_offset %rsi,-8\n\t")
+                   "pushq %rdi\n\t"
+                   __ASM_SEH(".seh_pushreg %rdi\n\t")
+                   __ASM_CFI(".cfi_rel_offset %rdi,-16\n\t")
+                   __ASM_SEH(".seh_endprologue\n\t")
+                   "movq %rcx,%rax\n\t"
+                   "movq $4,%rcx\n\t"
+                   "cmp %rcx,%rdx\n\t"
+                   "cmovgq %rdx,%rcx\n\t"
+                   "leaq 0(,%rcx,8),%rdx\n\t"
+                   "subq %rdx,%rsp\n\t"
+                   "andq $~15,%rsp\n\t"
+                   "movq %rsp,%rdi\n\t"
+                   "movq %r8,%rsi\n\t"
+                   "rep; movsq\n\t"
+                   "movq 0(%rsp),%rcx\n\t"
+                   "movq 8(%rsp),%rdx\n\t"
+                   "movq 16(%rsp),%r8\n\t"
+                   "movq 24(%rsp),%r9\n\t"
+                   "movq 0(%rsp),%xmm0\n\t"
+                   "movq 8(%rsp),%xmm1\n\t"
+                   "movq 16(%rsp),%xmm2\n\t"
+                   "movq 24(%rsp),%xmm3\n\t"
+                   "callq *%rax\n\t"
+                   "leaq -16(%rbp),%rsp\n\t"
+                   "popq %rdi\n\t"
+                   __ASM_CFI(".cfi_same_value %rdi\n\t")
+                   "popq %rsi\n\t"
+                   __ASM_CFI(".cfi_same_value %rsi\n\t")
+                   __ASM_CFI(".cfi_def_cfa_register %rsp\n\t")
+                   "popq %rbp\n\t"
+                   __ASM_CFI(".cfi_adjust_cfa_offset -8\n\t")
+                   __ASM_CFI(".cfi_same_value %rbp\n\t")
+                   "ret" )
+__ASM_GLOBAL_FUNC( call_double_method,
+                   "jmp " __ASM_NAME("call_method") )
+
+#elif defined __aarch64__
+
+__ASM_GLOBAL_FUNC( call_method,
+                   "stp x29, x30, [sp, #-16]!\n\t"
+                   ".seh_save_fplr_x 16\n\t"
+                   "mov x29, sp\n\t"
+                   ".seh_set_fp\n\t"
+                   ".seh_endprologue\n\t"
+                   "sub sp, sp, x1, lsl #3\n\t"
+                   "cbz x1, 2f\n"
+                   "1:\tsub x1, x1, #1\n\t"
+                   "ldr x4, [x2, x1, lsl #3]\n\t"
+                   "str x4, [sp, x1, lsl #3]\n\t"
+                   "cbnz x1, 1b\n"
+                   "2:\tmov x16, x0\n\t"
+                   "mov x9, x3\n\t"
+                   "ldp d0, d1, [x9]\n\t"
+                   "ldp d2, d3, [x9, #0x10]\n\t"
+                   "ldp d4, d5, [x9, #0x20]\n\t"
+                   "ldp d6, d7, [x9, #0x30]\n\t"
+                   "ldp x0, x1, [x9, #0x40]\n\t"
+                   "ldp x2, x3, [x9, #0x50]\n\t"
+                   "ldp x4, x5, [x9, #0x60]\n\t"
+                   "ldp x6, x7, [x9, #0x70]\n\t"
+                   "ldr x8, [x9, #0x80]\n\t"
+                   "blr x16\n\t"
+                   "mov sp, x29\n\t"
+                   "ldp x29, x30, [sp], #16\n\t"
+                   "ret" )
+__ASM_GLOBAL_FUNC( call_float_method,
+                   "b " __ASM_NAME("call_method") )
+__ASM_GLOBAL_FUNC( call_double_method,
+                   "b " __ASM_NAME("call_method") )
+
+#elif defined __arm__
+
+__ASM_GLOBAL_FUNC( call_method,
+                   /* r0 = *func
+                    * r1 = nb_stk_args
+                    * r2 = *stk_args (pointer to 'nb_stk_args' DWORD values to push on stack)
+                    * r3 = *reg_args (pointer to 8, 64-bit d0-d7 (double) values OR as 16, 32-bit s0-s15 (float) values, followed by 4, 32-bit (DWORD) r0-r3 values)
+                    */
+                   "push {fp, lr}\n\t"
+                   ".seh_save_regs_w {fp,lr}\n\t"
+                   "mov fp, sp\n\t"
+                   ".seh_save_sp fp\n\t"
+                   ".seh_endprologue\n\t"
+                   "lsls r1, r1, #2\n\t"           /* r1 = nb_stk_args * sizeof(DWORD) */
+                   "beq 1f\n\t"                    /* Skip allocation if no stack args */
+                   "add r2, r2, r1\n"              /* Calculate ending address of incoming stack data */
+                   "2:\tldr ip, [r2, #-4]!\n\t"    /* Get next value */
+                   "str ip, [sp, #-4]!\n\t"        /* Push it on the stack */
+                   "subs r1, r1, #4\n\t"           /* Decrement count */
+                   "bgt 2b\n\t"                    /* Loop till done */
+                   "1:\n\t"
+                   "vldm r3!, {s0-s15}\n\t"        /* Load the s0-s15/d0-d7 arguments */
+                   "mov ip, r0\n\t"                /* Save the function call address to ip before we nuke r0 with arguments to pass */
+                   "ldm r3, {r0-r3}\n\t"           /* Load the r0-r3 arguments */
+                   "blx ip\n\t"                    /* Call the target function */
+                   "mov sp, fp\n\t"                /* Clean the stack using fp */
+                   "pop {fp, pc}" )                /* Restore fp and return */
+__ASM_GLOBAL_FUNC( call_float_method,
+                   "b " __ASM_NAME("call_method") )
+__ASM_GLOBAL_FUNC( call_double_method,
+                   "b " __ASM_NAME("call_method") )
+
+#endif
diff --git a/dll/win32/oleaut32/typelib.c b/dll/win32/oleaut32/typelib.c
index 76e5e7f64db..f421a76fe95 100644
--- a/dll/win32/oleaut32/typelib.c
+++ b/dll/win32/oleaut32/typelib.c
@@ -54,8 +54,6 @@
 #include <ctype.h>
 
 #define COBJMACROS
-#define NONAMELESSUNION
-
 #include "winerror.h"
 #include "windef.h"
 #include "winbase.h"
@@ -70,12 +68,13 @@
 #include "wine/debug.h"
 #include "variant.h"
 #include "wine/asm.h"
-#include "wine/heap.h"
 #include "wine/list.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(ole);
 WINE_DECLARE_DEBUG_CHANNEL(typelib);
 
+static const BOOL is_win64 = sizeof(void *) > sizeof(int);
+
 typedef struct
 {
     WORD     offset;
@@ -171,14 +170,13 @@ static void FromLEDWords(void *p_Val, int p_iSize)
  */
 static BOOL find_typelib_key( REFGUID guid, WORD *wMaj, WORD *wMin )
 {
-    static const WCHAR typelibW[] = {'T','y','p','e','l','i','b','\\',0};
     WCHAR buffer[60];
     char key_name[16];
     DWORD len, i;
     INT best_maj = -1, best_min = -1;
     HKEY hkey;
 
-    memcpy( buffer, typelibW, sizeof(typelibW) );
+    lstrcpyW( buffer, L"Typelib\\" );
     StringFromGUID2( guid, buffer + lstrlenW(buffer), 40 );
 
     if (RegOpenKeyExW( HKEY_CLASSES_ROOT, buffer, 0, KEY_READ, &hkey ) != ERROR_SUCCESS)
@@ -208,7 +206,7 @@ static BOOL find_typelib_key( REFGUID guid, WORD *wMaj, WORD *wMin )
                     best_min = v_min;
                     break; /* exact match */
                 }
-                if (*wMin != 0xffff && v_min > best_min) best_min = v_min;
+                if (*wMin != 0xffff && v_min >= *wMin && v_min > best_min) best_min = v_min;
             }
         }
         len = sizeof(key_name);
@@ -239,12 +237,9 @@ static BOOL find_typelib_key( REFGUID guid, WORD *wMaj, WORD *wMin )
 /* buffer must be at least 60 characters long */
 static WCHAR *get_typelib_key( REFGUID guid, WORD wMaj, WORD wMin, WCHAR *buffer )
 {
-    static const WCHAR TypelibW[] = {'T','y','p','e','l','i','b','\\',0};
-    static const WCHAR VersionFormatW[] = {'\\','%','x','.','%','x',0};
-
-    memcpy( buffer, TypelibW, sizeof(TypelibW) );
+    lstrcpyW( buffer, L"Typelib\\" );
     StringFromGUID2( guid, buffer + lstrlenW(buffer), 40 );
-    swprintf( buffer + lstrlenW(buffer), VersionFormatW, wMaj, wMin );
+    swprintf( buffer + lstrlenW(buffer), 20, L"\\%x.%x", wMaj, wMin );
     return buffer;
 }
 
@@ -252,9 +247,7 @@ static WCHAR *get_typelib_key( REFGUID guid, WORD wMaj, WORD wMin, WCHAR *buffer
 /* buffer must be at least 50 characters long */
 static WCHAR *get_interface_key( REFGUID guid, WCHAR *buffer )
 {
-    static const WCHAR InterfaceW[] = {'I','n','t','e','r','f','a','c','e','\\',0};
-
-    memcpy( buffer, InterfaceW, sizeof(InterfaceW) );
+    lstrcpyW( buffer, L"Interface\\" );
     StringFromGUID2( guid, buffer + lstrlenW(buffer), 40 );
     return buffer;
 }
@@ -263,17 +256,12 @@ static WCHAR *get_interface_key( REFGUID guid, WCHAR *buffer )
 /* buffer must be at least 16 characters long */
 static WCHAR *get_lcid_subkey( LCID lcid, SYSKIND syskind, WCHAR *buffer )
 {
-    static const WCHAR LcidFormatW[] = {'%','l','x','\\',0};
-    static const WCHAR win16W[] = {'w','i','n','1','6',0};
-    static const WCHAR win32W[] = {'w','i','n','3','2',0};
-    static const WCHAR win64W[] = {'w','i','n','6','4',0};
-
-    swprintf( buffer, LcidFormatW, lcid );
+    swprintf( buffer, 16, L"%lx\\", lcid );
     switch(syskind)
     {
-    case SYS_WIN16: lstrcatW( buffer, win16W ); break;
-    case SYS_WIN32: lstrcatW( buffer, win32W ); break;
-    case SYS_WIN64: lstrcatW( buffer, win64W ); break;
+    case SYS_WIN16: lstrcatW( buffer, L"win16" ); break;
+    case SYS_WIN32: lstrcatW( buffer, L"win32" ); break;
+    case SYS_WIN64: lstrcatW( buffer, L"win64" ); break;
     default:
         TRACE("Typelib is for unsupported syskind %i\n", syskind);
         return NULL;
@@ -308,7 +296,7 @@ static HRESULT query_typelib_path( REFGUID guid, WORD wMaj, WORD wMin,
     WCHAR Path[MAX_PATH];
     LONG res;
 
-    TRACE_(typelib)("(%s, %x.%x, 0x%x, %p)\n", debugstr_guid(guid), wMaj, wMin, lcid, path);
+    TRACE_(typelib)("%s, %x.%x, %#lx, %p\n", debugstr_guid(guid), wMaj, wMin, lcid, path);
 
     if (redir)
     {
@@ -381,7 +369,7 @@ static HRESULT query_typelib_path( REFGUID guid, WORD wMaj, WORD wMin,
         }
     }
     RegCloseKey( hkey );
-    TRACE_(typelib)("-- 0x%08x\n", hr);
+    TRACE_(typelib)("-- %#lx\n", hr);
     return hr;
 }
 
@@ -406,13 +394,11 @@ static HRESULT query_typelib_path( REFGUID guid, WORD wMaj, WORD wMin,
 HRESULT WINAPI QueryPathOfRegTypeLib( REFGUID guid, WORD wMaj, WORD wMin, LCID lcid, LPBSTR path )
 {
     BOOL redir = TRUE;
-#ifdef _WIN64
-    HRESULT hres = query_typelib_path( guid, wMaj, wMin, SYS_WIN64, lcid, path, TRUE );
+    HRESULT hres = query_typelib_path( guid, wMaj, wMin, is_win64 ? SYS_WIN64 : SYS_WIN32, lcid, path, TRUE );
     if(SUCCEEDED(hres))
         return hres;
     redir = FALSE;
-#endif
-    return query_typelib_path( guid, wMaj, wMin, SYS_WIN32, lcid, path, redir );
+    return query_typelib_path( guid, wMaj, wMin, is_win64 ? SYS_WIN32 : SYS_WIN64, lcid, path, redir );
 }
 
 /******************************************************************************
@@ -422,21 +408,11 @@ HRESULT WINAPI QueryPathOfRegTypeLib( REFGUID guid, WORD wMaj, WORD wMin, LCID l
  *    Success: S_OK
  *    Failure: Status
  */
-HRESULT WINAPI CreateTypeLib(SYSKIND syskind, LPCOLESTR file, ICreateTypeLib **ctlib)
-{
-    ICreateTypeLib2 *typelib2;
-    HRESULT hres;
-
-    FIXME("(%d, %s, %p): forwarding to CreateTypeLib2\n", syskind, debugstr_w(file), ctlib);
-
-    hres = CreateTypeLib2(syskind, file, &typelib2);
-    if(SUCCEEDED(hres))
-    {
-        hres = ICreateTypeLib2_QueryInterface(typelib2, &IID_ICreateTypeLib, (void **)&ctlib);
-        ICreateTypeLib2_Release(typelib2);
-    }
-
-    return hres;
+HRESULT WINAPI CreateTypeLib(
+	SYSKIND syskind, LPCOLESTR szFile, ICreateTypeLib** ppctlib
+) {
+    FIXME("(%d,%s,%p), stub!\n",syskind,debugstr_w(szFile),ppctlib);
+    return E_FAIL;
 }
 
 /******************************************************************************
@@ -507,7 +483,7 @@ HRESULT WINAPI LoadTypeLibEx(
                 break;
         }
 
-    TRACE(" returns %08x\n",res);
+    TRACE(" returns %#lx\n",res);
     return res;
 }
 
@@ -572,26 +548,11 @@ HRESULT WINAPI LoadRegTypeLib(
     return res;
 }
 
-
-/* some string constants shared between RegisterTypeLib and UnRegisterTypeLib */
-static const WCHAR TypeLibW[] = {'T','y','p','e','L','i','b',0};
-static const WCHAR FLAGSW[] = {'F','L','A','G','S',0};
-static const WCHAR HELPDIRW[] = {'H','E','L','P','D','I','R',0};
-static const WCHAR ProxyStubClsidW[] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d',0};
-static const WCHAR ProxyStubClsid32W[] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0};
-
 static void TLB_register_interface(TLIBATTR *libattr, LPOLESTR name, TYPEATTR *tattr, DWORD flag)
 {
     WCHAR keyName[60];
     HKEY key, subKey;
 
-    static const WCHAR typelib_proxy_clsid[] = {'{','0','0','0','2','0','4','2','4','-',
-            '0','0','0','0','-','0','0','0','0','-','C','0','0','0','-',
-            '0','0','0','0','0','0','0','0','0','0','4','6','}',0};
-    static const WCHAR dispatch_proxy_clsid[] = {'{','0','0','0','2','0','4','2','0','-',
-            '0','0','0','0','-','0','0','0','0','-','C','0','0','0','-',
-            '0','0','0','0','0','0','0','0','0','0','4','6','}',0};
-
     get_interface_key( &tattr->guid, keyName );
     if (RegCreateKeyExW(HKEY_CLASSES_ROOT, keyName, 0, NULL, 0,
                         KEY_WRITE | flag, NULL, &key, NULL) == ERROR_SUCCESS)
@@ -599,41 +560,36 @@ static void TLB_register_interface(TLIBATTR *libattr, LPOLESTR name, TYPEATTR *t
         const WCHAR *proxy_clsid;
 
         if (tattr->typekind == TKIND_INTERFACE || (tattr->wTypeFlags & TYPEFLAG_FDUAL))
-            proxy_clsid = typelib_proxy_clsid;
+            proxy_clsid = L"{00020424-0000-0000-C000-000000000046}";
         else
-            proxy_clsid = dispatch_proxy_clsid;
+            proxy_clsid = L"{00020420-0000-0000-C000-000000000046}";
 
         if (name)
             RegSetValueExW(key, NULL, 0, REG_SZ,
                            (BYTE *)name, (lstrlenW(name)+1) * sizeof(OLECHAR));
 
-        if (RegCreateKeyExW(key, ProxyStubClsidW, 0, NULL, 0,
-            KEY_WRITE | flag, NULL, &subKey, NULL) == ERROR_SUCCESS) {
-            RegSetValueExW(subKey, NULL, 0, REG_SZ,
-                           (const BYTE *)proxy_clsid, sizeof(typelib_proxy_clsid));
+        if (!RegCreateKeyExW(key, L"ProxyStubClsid", 0, NULL, 0, KEY_WRITE | flag, NULL, &subKey, NULL))
+        {
+            RegSetValueExW(subKey, NULL, 0, REG_SZ, (const BYTE *)proxy_clsid, (lstrlenW(proxy_clsid) + 1) * sizeof(WCHAR));
             RegCloseKey(subKey);
         }
 
-        if (RegCreateKeyExW(key, ProxyStubClsid32W, 0, NULL, 0,
-            KEY_WRITE | flag, NULL, &subKey, NULL) == ERROR_SUCCESS) {
-            RegSetValueExW(subKey, NULL, 0, REG_SZ,
-                           (const BYTE *)proxy_clsid, sizeof(typelib_proxy_clsid));
+        if (!RegCreateKeyExW(key, L"ProxyStubClsid32", 0, NULL, 0, KEY_WRITE | flag, NULL, &subKey, NULL))
+        {
+            RegSetValueExW(subKey, NULL, 0, REG_SZ, (const BYTE *)proxy_clsid, (lstrlenW(proxy_clsid) + 1) * sizeof(WCHAR));
             RegCloseKey(subKey);
         }
 
-        if (RegCreateKeyExW(key, TypeLibW, 0, NULL, 0,
+        if (RegCreateKeyExW(key, L"TypeLib", 0, NULL, 0,
             KEY_WRITE | flag, NULL, &subKey, NULL) == ERROR_SUCCESS)
         {
             WCHAR buffer[40];
-            static const WCHAR fmtver[] = {'%','x','.','%','x',0 };
-            static const WCHAR VersionW[] = {'V','e','r','s','i','o','n',0};
 
             StringFromGUID2(&libattr->guid, buffer, 40);
             RegSetValueExW(subKey, NULL, 0, REG_SZ,
                            (BYTE *)buffer, (lstrlenW(buffer)+1) * sizeof(WCHAR));
-            swprintf(buffer, fmtver, libattr->wMajorVerNum, libattr->wMinorVerNum);
-            RegSetValueExW(subKey, VersionW, 0, REG_SZ,
-                           (BYTE*)buffer, (lstrlenW(buffer)+1) * sizeof(WCHAR));
+            swprintf(buffer, ARRAY_SIZE(buffer), L"%x.%x", libattr->wMajorVerNum, libattr->wMinorVerNum);
+            RegSetValueExW(subKey, L"Version", 0, REG_SZ, (BYTE *)buffer, (lstrlenW(buffer)+1) * sizeof(WCHAR));
             RegCloseKey(subKey);
         }
 
@@ -670,10 +626,6 @@ HRESULT WINAPI RegisterTypeLib(ITypeLib *ptlib, const WCHAR *szFullPath, const W
     if (FAILED(ITypeLib_GetLibAttr(ptlib, &attr)))
         return E_FAIL;
 
-#ifndef _WIN64
-    if (attr->syskind == SYS_WIN64) return TYPE_E_BADMODULEKIND;
-#endif
-
     get_typelib_key( &attr->guid, attr->wMajorVerNum, attr->wMinorVerNum, keyName );
 
     res = S_OK;
@@ -681,17 +633,22 @@ HRESULT WINAPI RegisterTypeLib(ITypeLib *ptlib, const WCHAR *szFullPath, const W
         KEY_WRITE, NULL, &key, NULL) == ERROR_SUCCESS)
     {
         LPOLESTR doc;
+        LPOLESTR libName;
 
-        /* Set the human-readable name of the typelib */
-        if (FAILED(ITypeLib_GetDocumentation(ptlib, -1, NULL, &doc, NULL, NULL)))
+        /* Set the human-readable name of the typelib to
+           the typelib's doc, if it exists, else to the typelib's name. */
+        if (FAILED(ITypeLib_GetDocumentation(ptlib, -1, &libName, &doc, NULL, NULL)))
             res = E_FAIL;
-        else if (doc)
+        else if (doc || libName)
         {
+            WCHAR *name = doc ? doc : libName;
+
             if (RegSetValueExW(key, NULL, 0, REG_SZ,
-                (BYTE *)doc, (lstrlenW(doc)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS)
+                (BYTE *)name, (lstrlenW(name)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS)
                 res = E_FAIL;
 
             SysFreeString(doc);
+            SysFreeString(libName);
         }
 
         /* Make up the name of the typelib path subkey */
@@ -711,13 +668,13 @@ HRESULT WINAPI RegisterTypeLib(ITypeLib *ptlib, const WCHAR *szFullPath, const W
             res = E_FAIL;
 
         /* Create the flags subkey */
-        if (res == S_OK && RegCreateKeyExW(key, FLAGSW, 0, NULL, 0,
+        if (res == S_OK && RegCreateKeyExW(key, L"FLAGS", 0, NULL, 0,
             KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS)
         {
-            /* FIXME: is %u correct? */
-            static const WCHAR formatW[] = {'%','u',0};
             WCHAR buf[20];
-            swprintf(buf, formatW, attr->wLibFlags);
+
+            /* FIXME: is %u correct? */
+            swprintf(buf, ARRAY_SIZE(buf), L"%u", attr->wLibFlags);
             if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
                                (BYTE *)buf, (lstrlenW(buf) + 1)*sizeof(WCHAR) ) != ERROR_SUCCESS)
                 res = E_FAIL;
@@ -728,21 +685,30 @@ HRESULT WINAPI RegisterTypeLib(ITypeLib *ptlib, const WCHAR *szFullPath, const W
             res = E_FAIL;
 
         /* create the helpdir subkey */
-        if (res == S_OK && RegCreateKeyExW(key, HELPDIRW, 0, NULL, 0,
+        if (res == S_OK && RegCreateKeyExW(key, L"HELPDIR", 0, NULL, 0,
             KEY_WRITE, NULL, &subKey, &disposition) == ERROR_SUCCESS)
         {
             BSTR freeHelpDir = NULL;
-            OLECHAR* pIndexStr;
+            WCHAR *file_name;
 
             /* if we created a new key, and helpDir was null, set the helpdir
                to the directory which contains the typelib. However,
                if we just opened an existing key, we leave the helpdir alone */
             if ((disposition == REG_CREATED_NEW_KEY) && (szHelpDir == NULL)) {
                 szHelpDir = freeHelpDir = SysAllocString(szFullPath);
-                pIndexStr = wcsrchr(szHelpDir, '\\');
-                if (pIndexStr) {
-                    *pIndexStr = 0;
+                file_name = wcsrchr(szHelpDir, '\\');
+                if (file_name && file_name[1]) {
+                    /* possible remove a numeric \index (resource-id) */
+                    WCHAR *end_ptr = file_name + 1;
+                    while ('0' <= *end_ptr && *end_ptr <= '9') end_ptr++;
+                    if (!*end_ptr)
+                    {
+                        *file_name = 0;
+                        file_name = wcsrchr(szHelpDir, '\\');
+                    }
                 }
+                if (file_name)
+                    *file_name = 0;
             }
 
             /* if we have an szHelpDir, set it! */
@@ -863,9 +829,9 @@ static void TLB_unregister_interface(GUID *guid, REGSAM flag)
     if (RegOpenKeyExW(HKEY_CLASSES_ROOT, subKeyName, 0, KEY_WRITE | flag, &subKey) != ERROR_SUCCESS)
         return;
 
-    RegDeleteKeyW(subKey, ProxyStubClsidW);
-    RegDeleteKeyW(subKey, ProxyStubClsid32W);
-    RegDeleteKeyW(subKey, TypeLibW);
+    RegDeleteKeyW(subKey, L"ProxyStubClsid");
+    RegDeleteKeyW(subKey, L"ProxyStubClsid32");
+    RegDeleteKeyW(subKey, L"TypeLib");
     RegCloseKey(subKey);
     RegDeleteKeyExW(HKEY_CLASSES_ROOT, subKeyName, flag, 0);
 }
@@ -986,16 +952,16 @@ enddeleteloop:
         tmpLength = ARRAY_SIZE(subKeyName);
 
         /* if its not FLAGS or HELPDIR, then we must keep the rest of the key */
-        if (!wcscmp(subKeyName, FLAGSW)) continue;
-        if (!wcscmp(subKeyName, HELPDIRW)) continue;
+        if (!wcscmp(subKeyName, L"FLAGS")) continue;
+        if (!wcscmp(subKeyName, L"HELPDIR")) continue;
         deleteOtherStuff = FALSE;
         break;
     }
 
     /* only delete the other parts of the key if we're absolutely sure */
     if (deleteOtherStuff) {
-        RegDeleteKeyW(key, FLAGSW);
-        RegDeleteKeyW(key, HELPDIRW);
+        RegDeleteKeyW(key, L"FLAGS");
+        RegDeleteKeyW(key, L"HELPDIR");
         RegCloseKey(key);
         key = NULL;
 
@@ -1049,7 +1015,7 @@ HRESULT WINAPI UnRegisterTypeLibForUser(
     LCID lcid,	/* [in] locale id */
     SYSKIND syskind)
 {
-    FIXME("(%s, %u, %u, %u, %u) unregistering the typelib system-wide\n",
+    FIXME("%s, %u, %u, %#lx, %u unregistering the typelib system-wide\n",
           debugstr_guid(libid), wVerMajor, wVerMinor, lcid, syskind);
     return UnRegisterTypeLib(libid, wVerMajor, wVerMinor, lcid, syskind);
 }
@@ -1383,19 +1349,18 @@ static void dump_TypeDesc(const TYPEDESC *pTD,char *szVarType) {
     case VT_VARIANT: sprintf(szVarType, "VT_VARIANT"); break;
     case VT_VOID: sprintf(szVarType, "VT_VOID"); break;
     case VT_HRESULT: sprintf(szVarType, "VT_HRESULT"); break;
-    case VT_USERDEFINED: sprintf(szVarType, "VT_USERDEFINED ref = %x",
-				 pTD->u.hreftype); break;
+    case VT_USERDEFINED: sprintf(szVarType, "VT_USERDEFINED ref = %lx", pTD->hreftype); break;
     case VT_LPSTR: sprintf(szVarType, "VT_LPSTR"); break;
     case VT_LPWSTR: sprintf(szVarType, "VT_LPWSTR"); break;
     case VT_PTR: sprintf(szVarType, "ptr to ");
-      dump_TypeDesc(pTD->u.lptdesc, szVarType + 7);
+      dump_TypeDesc(pTD->lptdesc, szVarType + 7);
       break;
     case VT_SAFEARRAY: sprintf(szVarType, "safearray of ");
-      dump_TypeDesc(pTD->u.lptdesc, szVarType + 13);
+      dump_TypeDesc(pTD->lptdesc, szVarType + 13);
       break;
     case VT_CARRAY: sprintf(szVarType, "%d dim array of ",
-			    pTD->u.lpadesc->cDims); /* FIXME print out sizes */
-      dump_TypeDesc(&pTD->u.lpadesc->tdescElem, szVarType + strlen(szVarType));
+			    pTD->lpadesc->cDims); /* FIXME print out sizes */
+      dump_TypeDesc(&pTD->lpadesc->tdescElem, szVarType + strlen(szVarType));
       break;
 
     default: sprintf(szVarType, "unknown(%d)", pTD->vt & VT_TYPEMASK); break;
@@ -1404,7 +1369,7 @@ static void dump_TypeDesc(const TYPEDESC *pTD,char *szVarType) {
 
 static void dump_ELEMDESC(const ELEMDESC *edesc) {
   char buf[200];
-  USHORT flags = edesc->u.paramdesc.wParamFlags;
+  USHORT flags = edesc->paramdesc.wParamFlags;
   dump_TypeDesc(&edesc->tdesc,buf);
   MESSAGE("\t\ttdesc.vartype %d (%s)\n",edesc->tdesc.vt,buf);
   MESSAGE("\t\tu.paramdesc.wParamFlags");
@@ -1416,11 +1381,11 @@ static void dump_ELEMDESC(const ELEMDESC *edesc) {
   if (flags & PARAMFLAG_FOPT) MESSAGE(" PARAMFLAG_FOPT");
   if (flags & PARAMFLAG_FHASDEFAULT) MESSAGE(" PARAMFLAG_FHASDEFAULT");
   if (flags & PARAMFLAG_FHASCUSTDATA) MESSAGE(" PARAMFLAG_FHASCUSTDATA");
-  MESSAGE("\n\t\tu.paramdesc.lpex %p\n",edesc->u.paramdesc.pparamdescex);
+  MESSAGE("\n\t\tu.paramdesc.lpex %p\n",edesc->paramdesc.pparamdescex);
 }
 static void dump_FUNCDESC(const FUNCDESC *funcdesc) {
   int i;
-  MESSAGE("memid is %08x\n",funcdesc->memid);
+  MESSAGE("memid is %#lx\n", funcdesc->memid);
   for (i=0;i<funcdesc->cParams;i++) {
       MESSAGE("Param %d:\n",i);
       dump_ELEMDESC(funcdesc->lprgelemdescParam+i);
@@ -1513,8 +1478,7 @@ static void dump_TLBImpLib(const TLBImpLib *import)
 {
     TRACE_(typelib)("%s %s\n", debugstr_guid(TLB_get_guidref(import->guid)),
 		    debugstr_w(import->name));
-    TRACE_(typelib)("v%d.%d lcid=%x offset=%x\n", import->wVersionMajor,
-		    import->wVersionMinor, import->lcid, import->offset);
+    TRACE_(typelib)("v%d.%d lcid %#lx offset=%x\n", import->wVersionMajor, import->wVersionMinor, import->lcid, import->offset);
 }
 
 static void dump_TLBRefType(const ITypeLibImpl *pTL)
@@ -1523,7 +1487,7 @@ static void dump_TLBRefType(const ITypeLibImpl *pTL)
 
     LIST_FOR_EACH_ENTRY(ref, &pTL->ref_list, TLBRefType, entry)
     {
-        TRACE_(typelib)("href:0x%08x\n", ref->reference);
+        TRACE_(typelib)("href:%#lx\n", ref->reference);
         if(ref->index == -1)
 	    TRACE_(typelib)("%s\n", debugstr_guid(TLB_get_guidref(ref->guid)));
         else
@@ -1542,7 +1506,7 @@ static void dump_TLBImplType(const TLBImplType * impl, UINT n)
     if(!impl)
         return;
     while (n) {
-        TRACE_(typelib)("implementing/inheriting interface hRef = %x implflags %x\n",
+        TRACE_(typelib)("implementing/inheriting interface hRef = %lx implflags %x\n",
             impl->hRef, impl->implflags);
         ++impl;
         --n;
@@ -1559,7 +1523,7 @@ static void dump_DispParms(const DISPPARAMS * pdp)
     {
         TRACE("named args:\n");
         for (index = 0; index < pdp->cNamedArgs; index++)
-            TRACE( "\t0x%x\n", pdp->rgdispidNamedArgs[index] );
+            TRACE( "\t0x%lx\n", pdp->rgdispidNamedArgs[index] );
     }
 
     if (pdp->cArgs && pdp->rgvarg)
@@ -1572,7 +1536,7 @@ static void dump_DispParms(const DISPPARAMS * pdp)
 
 static void dump_TypeInfo(const ITypeInfoImpl * pty)
 {
-    TRACE("%p ref=%u\n", pty, pty->ref);
+    TRACE("%p ref %lu\n", pty, pty->ref);
     TRACE("%s %s\n", debugstr_w(TLB_get_bstr(pty->Name)), debugstr_w(TLB_get_bstr(pty->DocString)));
     TRACE("attr:%s\n", debugstr_guid(TLB_get_guidref(pty->guid)));
     TRACE("kind:%s\n", typekind_desc[pty->typeattr.typekind]);
@@ -1588,9 +1552,9 @@ static void dump_TypeInfo(const ITypeInfoImpl * pty)
 
 static void dump_VARDESC(const VARDESC *v)
 {
-    MESSAGE("memid %d\n",v->memid);
+    MESSAGE("memid %ld\n",v->memid);
     MESSAGE("lpstrSchema %s\n",debugstr_w(v->lpstrSchema));
-    MESSAGE("oInst %d\n",v->u.oInst);
+    MESSAGE("oInst %ld\n", v->oInst);
     dump_ELEMDESC(&(v->elemdescVar));
     MESSAGE("wVarFlags %x\n",v->wVarFlags);
     MESSAGE("varkind %d\n",v->varkind);
@@ -1627,11 +1591,11 @@ static SIZE_T TLB_SizeTypeDesc( const TYPEDESC *tdesc, BOOL alloc_initial_space
     {
     case VT_PTR:
     case VT_SAFEARRAY:
-        size += TLB_SizeTypeDesc(tdesc->u.lptdesc, TRUE);
+        size += TLB_SizeTypeDesc(tdesc->lptdesc, TRUE);
         break;
     case VT_CARRAY:
-        size += FIELD_OFFSET(ARRAYDESC, rgbounds[tdesc->u.lpadesc->cDims]);
-        size += TLB_SizeTypeDesc(&tdesc->u.lpadesc->tdescElem, FALSE);
+        size += FIELD_OFFSET(ARRAYDESC, rgbounds[tdesc->lpadesc->cDims]);
+        size += TLB_SizeTypeDesc(&tdesc->lpadesc->tdescElem, FALSE);
         break;
     }
     return size;
@@ -1652,14 +1616,14 @@ static void *TLB_CopyTypeDesc( TYPEDESC *dest, const TYPEDESC *src, void *buffer
     {
     case VT_PTR:
     case VT_SAFEARRAY:
-        dest->u.lptdesc = buffer;
-        buffer = TLB_CopyTypeDesc(NULL, src->u.lptdesc, buffer);
+        dest->lptdesc = buffer;
+        buffer = TLB_CopyTypeDesc(NULL, src->lptdesc, buffer);
         break;
     case VT_CARRAY:
-        dest->u.lpadesc = buffer;
-        memcpy(dest->u.lpadesc, src->u.lpadesc, FIELD_OFFSET(ARRAYDESC, rgbounds[src->u.lpadesc->cDims]));
-        buffer = (char *)buffer + FIELD_OFFSET(ARRAYDESC, rgbounds[src->u.lpadesc->cDims]);
-        buffer = TLB_CopyTypeDesc(&dest->u.lpadesc->tdescElem, &src->u.lpadesc->tdescElem, buffer);
+        dest->lpadesc = buffer;
+        memcpy(dest->lpadesc, src->lpadesc, FIELD_OFFSET(ARRAYDESC, rgbounds[src->lpadesc->cDims]));
+        buffer = (char *)buffer + FIELD_OFFSET(ARRAYDESC, rgbounds[src->lpadesc->cDims]);
+        buffer = TLB_CopyTypeDesc(&dest->lpadesc->tdescElem, &src->lpadesc->tdescElem, buffer);
         break;
     }
     return buffer;
@@ -1673,7 +1637,7 @@ static inline void TLB_FreeCustData(struct list *custdata_list)
     {
         list_remove(&cd->entry);
         VariantClear(&cd->data);
-        heap_free(cd);
+        free(cd);
     }
 }
 
@@ -1689,43 +1653,59 @@ static BSTR TLB_MultiByteToBSTR(const char *ptr)
     return ret;
 }
 
-static inline TLBFuncDesc *TLB_get_funcdesc_by_memberid(TLBFuncDesc *funcdescs,
-        UINT n, MEMBERID memid)
+static inline TLBFuncDesc *TLB_get_funcdesc_by_memberid(ITypeInfoImpl *typeinfo, MEMBERID memid)
 {
-    while(n){
-        if(funcdescs->funcdesc.memid == memid)
-            return funcdescs;
-        ++funcdescs;
-        --n;
+    int i;
+
+    for (i = 0; i < typeinfo->typeattr.cFuncs; ++i)
+    {
+        if (typeinfo->funcdescs[i].funcdesc.memid == memid)
+            return &typeinfo->funcdescs[i];
     }
+
     return NULL;
 }
 
-static inline TLBVarDesc *TLB_get_vardesc_by_memberid(TLBVarDesc *vardescs,
-        UINT n, MEMBERID memid)
+static inline TLBFuncDesc *TLB_get_funcdesc_by_memberid_invkind(ITypeInfoImpl *typeinfo, MEMBERID memid, INVOKEKIND invkind)
 {
-    while(n){
-        if(vardescs->vardesc.memid == memid)
-            return vardescs;
-        ++vardescs;
-        --n;
+    int i;
+
+    for (i = 0; i < typeinfo->typeattr.cFuncs; ++i)
+    {
+        if (typeinfo->funcdescs[i].funcdesc.memid == memid && typeinfo->funcdescs[i].funcdesc.invkind == invkind)
+            return &typeinfo->funcdescs[i];
     }
+
     return NULL;
 }
 
-static inline TLBVarDesc *TLB_get_vardesc_by_name(TLBVarDesc *vardescs,
-        UINT n, const OLECHAR *name)
+static inline TLBVarDesc *TLB_get_vardesc_by_memberid(ITypeInfoImpl *typeinfo, MEMBERID memid)
 {
-    while(n){
-        if(!lstrcmpiW(TLB_get_bstr(vardescs->Name), name))
-            return vardescs;
-        ++vardescs;
-        --n;
+    int i;
+
+    for (i = 0; i < typeinfo->typeattr.cVars; ++i)
+    {
+        if (typeinfo->vardescs[i].vardesc.memid == memid)
+            return &typeinfo->vardescs[i];
     }
+
     return NULL;
 }
 
-static inline TLBCustData *TLB_get_custdata_by_guid(struct list *custdata_list, REFGUID guid)
+static inline TLBVarDesc *TLB_get_vardesc_by_name(ITypeInfoImpl *typeinfo, const OLECHAR *name)
+{
+    int i;
+
+    for (i = 0; i < typeinfo->typeattr.cVars; ++i)
+    {
+        if (!lstrcmpiW(TLB_get_bstr(typeinfo->vardescs[i].Name), name))
+            return &typeinfo->vardescs[i];
+    }
+
+    return NULL;
+}
+
+static inline TLBCustData *TLB_get_custdata_by_guid(const struct list *custdata_list, REFGUID guid)
 {
     TLBCustData *cust_data;
     LIST_FOR_EACH_ENTRY(cust_data, custdata_list, TLBCustData, entry)
@@ -1734,15 +1714,16 @@ static inline TLBCustData *TLB_get_custdata_by_guid(struct list *custdata_list,
     return NULL;
 }
 
-static inline ITypeInfoImpl *TLB_get_typeinfo_by_name(ITypeInfoImpl **typeinfos,
-        UINT n, const OLECHAR *name)
+static inline ITypeInfoImpl *TLB_get_typeinfo_by_name(ITypeLibImpl *typelib, const OLECHAR *name)
 {
-    while(n){
-        if(!lstrcmpiW(TLB_get_bstr((*typeinfos)->Name), name))
-            return *typeinfos;
-        ++typeinfos;
-        --n;
+    int i;
+
+    for (i = 0; i < typelib->TypeInfoCount; ++i)
+    {
+        if (!lstrcmpiW(TLB_get_bstr(typelib->typeinfos[i]->Name), name))
+            return typelib->typeinfos[i];
     }
+
     return NULL;
 }
 
@@ -1755,7 +1736,7 @@ static TLBVarDesc *TLBVarDesc_Alloc(UINT n)
 {
     TLBVarDesc *ret;
 
-    ret = heap_alloc_zero(sizeof(TLBVarDesc) * n);
+    ret = calloc(n, sizeof(TLBVarDesc));
     if(!ret)
         return NULL;
 
@@ -1771,7 +1752,7 @@ static TLBParDesc *TLBParDesc_Constructor(UINT n)
 {
     TLBParDesc *ret;
 
-    ret = heap_alloc_zero(sizeof(TLBParDesc) * n);
+    ret = calloc(n, sizeof(TLBParDesc));
     if(!ret)
         return NULL;
 
@@ -1792,7 +1773,7 @@ static TLBFuncDesc *TLBFuncDesc_Alloc(UINT n)
 {
     TLBFuncDesc *ret;
 
-    ret = heap_alloc_zero(sizeof(TLBFuncDesc) * n);
+    ret = calloc(n, sizeof(TLBFuncDesc));
     if(!ret)
         return NULL;
 
@@ -1813,7 +1794,7 @@ static TLBImplType *TLBImplType_Alloc(UINT n)
 {
     TLBImplType *ret;
 
-    ret = heap_alloc_zero(sizeof(TLBImplType) * n);
+    ret = calloc(n, sizeof(TLBImplType));
     if(!ret)
         return NULL;
 
@@ -1835,7 +1816,7 @@ static TLBGuid *TLB_append_guid(struct list *guid_list,
             return guid;
     }
 
-    guid = heap_alloc(sizeof(TLBGuid));
+    guid = malloc(sizeof(TLBGuid));
     if (!guid)
         return NULL;
 
@@ -1867,7 +1848,7 @@ static HRESULT TLB_set_custdata(struct list *custdata_list, TLBGuid *tlbguid, VA
     cust_data = TLB_get_custdata_by_guid(custdata_list, TLB_get_guid_null(tlbguid));
 
     if (!cust_data) {
-        cust_data = heap_alloc(sizeof(TLBCustData));
+        cust_data = malloc(sizeof(TLBCustData));
         if (!cust_data)
             return E_OUTOFMEMORY;
 
@@ -1881,6 +1862,18 @@ static HRESULT TLB_set_custdata(struct list *custdata_list, TLBGuid *tlbguid, VA
     return VariantCopy(&cust_data->data, var);
 }
 
+/* Used to update list pointers after list itself was moved. */
+static void TLB_relink_custdata(struct list *custdata_list)
+{
+    if (custdata_list->prev == custdata_list->next)
+        list_init(custdata_list);
+    else
+    {
+        custdata_list->prev->next = custdata_list;
+        custdata_list->next->prev = custdata_list;
+    }
+}
+
 static TLBString *TLB_append_str(struct list *string_list, BSTR new_str)
 {
     TLBString *str;
@@ -1893,13 +1886,13 @@ static TLBString *TLB_append_str(struct list *string_list, BSTR new_str)
             return str;
     }
 
-    str = heap_alloc(sizeof(TLBString));
+    str = malloc(sizeof(TLBString));
     if (!str)
         return NULL;
 
     str->str = SysAllocString(new_str);
     if (!str->str) {
-        heap_free(str);
+        free(str);
         return NULL;
     }
 
@@ -1985,10 +1978,8 @@ static HRESULT TLB_size_instance(ITypeInfoImpl *info, SYSKIND sys,
         break;
     case VT_VARIANT:
         *size = sizeof(VARIANT);
-#ifdef _WIN64
-        if(sys == SYS_WIN32)
-            *size -= 8; /* 32-bit VARIANT is 8 bytes smaller than 64-bit VARIANT */
-#endif
+        if(get_ptr_size(sys) != sizeof(void*))
+            *size += is_win64 ? -8 : 8; /* 32-bit VARIANT is 8 bytes smaller than 64-bit VARIANT */
         break;
     case VT_DECIMAL:
         *size = sizeof(DECIMAL);
@@ -1998,15 +1989,15 @@ static HRESULT TLB_size_instance(ITypeInfoImpl *info, SYSKIND sys,
         break;
     case VT_CARRAY:
         *size = 0;
-        for(i = 0; i < tdesc->u.lpadesc->cDims; ++i)
-            *size += tdesc->u.lpadesc->rgbounds[i].cElements;
-        hr = TLB_size_instance(info, sys, &tdesc->u.lpadesc->tdescElem, &sub, align);
+        for(i = 0; i < tdesc->lpadesc->cDims; ++i)
+            *size += tdesc->lpadesc->rgbounds[i].cElements;
+        hr = TLB_size_instance(info, sys, &tdesc->lpadesc->tdescElem, &sub, align);
         if(FAILED(hr))
             return hr;
         *size *= sub;
         return S_OK;
     case VT_USERDEFINED:
-        return TLB_get_size_from_hreftype(info, tdesc->u.hreftype, size, align);
+        return TLB_get_size_from_hreftype(info, tdesc->hreftype, size, align);
     default:
         FIXME("Unsized VT: 0x%x\n", tdesc->vt);
         return E_FAIL;
@@ -2035,7 +2026,7 @@ static inline void MSFT_Seek(TLBContext *pcx, LONG where)
         if (where > pcx->length)
         {
             /* FIXME */
-            ERR("seek beyond end (%d/%d)\n", where, pcx->length );
+            ERR("seek beyond end (%ld/%d)\n", where, pcx->length );
             TLB_abort();
         }
         pcx->pos = where;
@@ -2045,7 +2036,7 @@ static inline void MSFT_Seek(TLBContext *pcx, LONG where)
 /* read function */
 static DWORD MSFT_Read(void *buffer,  DWORD count, TLBContext *pcx, LONG where )
 {
-    TRACE_(typelib)("pos=0x%08x len=0x%08x 0x%08x 0x%08x 0x%08x\n",
+    TRACE_(typelib)("pos=0x%08x len %#lx, %u, %u, %#lx\n",
        pcx->pos, count, pcx->oStart, pcx->length, where);
 
     MSFT_Seek(pcx, where);
@@ -2090,7 +2081,7 @@ static HRESULT MSFT_ReadAllGuids(TLBContext *pcx)
 
         MSFT_ReadLEWords(&entry, sizeof(MSFT_GuidEntry), pcx, DO_NOT_SEEK);
 
-        guid = heap_alloc(sizeof(TLBGuid));
+        guid = malloc(sizeof(TLBGuid));
 
         guid->offset = offs;
         guid->guid = entry.guid;
@@ -2154,24 +2145,24 @@ static HRESULT MSFT_ReadAllNames(TLBContext *pcx)
         if(len_piece < 8)
             len_piece = 8;
 
-        string = heap_alloc(len_piece + 1);
+        string = malloc(len_piece + 1);
         MSFT_Read(string, len_piece - sizeof(MSFT_NameIntro), pcx, DO_NOT_SEEK);
         string[intro.namelen] = '\0';
 
         lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
                                             string, -1, NULL, 0);
         if (!lengthInChars) {
-            heap_free(string);
+            free(string);
             return E_UNEXPECTED;
         }
 
-        tlbstr = heap_alloc(sizeof(TLBString));
+        tlbstr = malloc(sizeof(TLBString));
 
         tlbstr->offset = offs;
         tlbstr->str = SysAllocStringByteLen(NULL, lengthInChars * sizeof(WCHAR));
         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, string, -1, tlbstr->str, lengthInChars);
 
-        heap_free(string);
+        free(string);
 
         list_add_tail(&pcx->pLibInfo->name_list, &tlbstr->entry);
 
@@ -2256,13 +2247,13 @@ static void MSFT_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx )
             if(size == -1){
                 V_BSTR(pVar) = NULL;
             }else{
-                ptr = heap_alloc_zero(size);
+                int len;
+                ptr = calloc(1, size);
                 MSFT_Read(ptr, size, pcx, DO_NOT_SEEK);
-                V_BSTR(pVar)=SysAllocStringLen(NULL,size);
-                /* FIXME: do we need a AtoW conversion here? */
-                V_UNION(pVar, bstrVal[size])='\0';
-                while(size--) V_UNION(pVar, bstrVal[size])=ptr[size];
-                heap_free(ptr);
+                len = MultiByteToWideChar(CP_ACP, 0, ptr, size, NULL, 0 );
+                V_BSTR(pVar)=SysAllocStringLen(NULL,len);
+                MultiByteToWideChar(CP_ACP, 0, ptr, size, V_BSTR(pVar), len );
+                free(ptr);
             }
 	}
 	size=-4; break;
@@ -2309,7 +2300,7 @@ static int MSFT_CustData( TLBContext *pcx, int offset, struct list *custdata_lis
 
     while(offset >=0){
         count++;
-        pNew=heap_alloc_zero(sizeof(TLBCustData));
+        pNew = calloc(1, sizeof(TLBCustData));
         MSFT_ReadLEDWords(&entry, sizeof(entry), pcx, pcx->pTblDir->pCDGuids.offset+offset);
         pNew->guid = MSFT_ReadGuid(entry.GuidOffset, pcx);
         MSFT_ReadValue(&(pNew->data), entry.DataOffset, pcx);
@@ -2372,7 +2363,7 @@ MSFT_DoFuncs(TLBContext*     pcx,
     int infolen, nameoffset, reclength, i;
     int recoffset = offset + sizeof(INT);
 
-    char *recbuf = heap_alloc(0xffff);
+    char *recbuf = malloc(0xffff);
     MSFT_FuncRecord *pFuncRec = (MSFT_FuncRecord*)recbuf;
     TLBFuncDesc *ptfd_prev = NULL, *ptfd;
 
@@ -2437,7 +2428,10 @@ MSFT_DoFuncs(TLBContext*     pcx,
         ptfd->funcdesc.callconv   =  (pFuncRec->FKCCIC) >> 8 & 0xF;
         ptfd->funcdesc.cParams    =   pFuncRec->nrargs  ;
         ptfd->funcdesc.cParamsOpt =   pFuncRec->nroargs ;
-        ptfd->funcdesc.oVft       =   (pFuncRec->VtableOffset & ~1) * sizeof(void *) / pTI->pTypeLib->ptr_size;
+        if (ptfd->funcdesc.funckind == FUNC_DISPATCH)
+            ptfd->funcdesc.oVft   =   0;
+        else
+            ptfd->funcdesc.oVft   =   (unsigned short)(pFuncRec->VtableOffset & ~1) * sizeof(void *) / pTI->pTypeLib->ptr_size;
         ptfd->funcdesc.wFuncFlags =   LOWORD(pFuncRec->Flags) ;
 
         /* nameoffset is sometimes -1 on the second half of a propget/propput
@@ -2460,7 +2454,7 @@ MSFT_DoFuncs(TLBContext*     pcx,
             MSFT_ParameterInfo paraminfo;
 
             ptfd->funcdesc.lprgelemdescParam =
-                heap_alloc_zero(pFuncRec->nrargs * (sizeof(ELEMDESC) + sizeof(PARAMDESCEX)));
+                calloc(pFuncRec->nrargs, sizeof(ELEMDESC) + sizeof(PARAMDESCEX));
 
             ptfd->pParamDesc = TLBParDesc_Constructor(pFuncRec->nrargs);
 
@@ -2475,7 +2469,7 @@ MSFT_DoFuncs(TLBContext*     pcx,
 			      paraminfo.DataType,
 			      &elemdesc->tdesc);
 
-                elemdesc->u.paramdesc.wParamFlags = paraminfo.Flags;
+                elemdesc->paramdesc.wParamFlags = paraminfo.Flags;
 
                 /* name */
                 if (paraminfo.oName != -1)
@@ -2484,14 +2478,14 @@ MSFT_DoFuncs(TLBContext*     pcx,
                 TRACE_(typelib)("param[%d] = %s\n", j, debugstr_w(TLB_get_bstr(ptfd->pParamDesc[j].Name)));
 
                 /* default value */
-                if ( (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) &&
+                if ( (elemdesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) &&
                      (pFuncRec->FKCCIC & 0x1000) )
                 {
                     INT* pInt = (INT *)((char *)pFuncRec +
                                    reclength -
                                    (pFuncRec->nrargs * 4) * sizeof(INT) );
 
-                    PARAMDESC* pParamDesc = &elemdesc->u.paramdesc;
+                    PARAMDESC* pParamDesc = &elemdesc->paramdesc;
 
                     pParamDesc->pparamdescex = (PARAMDESCEX*)(ptfd->funcdesc.lprgelemdescParam+pFuncRec->nrargs)+j;
                     pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
@@ -2500,7 +2494,7 @@ MSFT_DoFuncs(TLBContext*     pcx,
                         pInt[j], pcx);
                 }
                 else
-                    elemdesc->u.paramdesc.pparamdescex = NULL;
+                    elemdesc->paramdesc.pparamdescex = NULL;
 
                 /* custom info */
                 if (optional > (FIELD_OFFSET(MSFT_FuncRecord, oArgCustData) +
@@ -2531,7 +2525,7 @@ MSFT_DoFuncs(TLBContext*     pcx,
         ++ptfd;
         recoffset += reclength;
     }
-    heap_free(recbuf);
+    free(recbuf);
 }
 
 static void MSFT_DoVars(TLBContext *pcx, ITypeInfoImpl *pTI, int cFuncs,
@@ -2568,6 +2562,9 @@ static void MSFT_DoVars(TLBContext *pcx, ITypeInfoImpl *pTI, int cFuncs,
         if(reclength > FIELD_OFFSET(MSFT_VarRecord, HelpString))
             ptvd->HelpString = MSFT_ReadString(pcx, pVarRec->HelpString);
 
+        if (reclength > FIELD_OFFSET(MSFT_VarRecord, oCustData))
+            MSFT_CustData(pcx, pVarRec->oCustData, &ptvd->custdata_list);
+
         if(reclength > FIELD_OFFSET(MSFT_VarRecord, HelpStringContext))
             ptvd->HelpStringContext = pVarRec->HelpStringContext;
 
@@ -2580,11 +2577,11 @@ static void MSFT_DoVars(TLBContext *pcx, ITypeInfoImpl *pTI, int cFuncs,
             &ptvd->vardesc.elemdescVar.tdesc);
 /*   ptvd->vardesc.lpstrSchema; is reserved (SDK) FIXME?? */
         if(pVarRec->VarKind == VAR_CONST ){
-            ptvd->vardesc.u.lpvarValue = heap_alloc_zero(sizeof(VARIANT));
-            MSFT_ReadValue(ptvd->vardesc.u.lpvarValue,
+            ptvd->vardesc.lpvarValue = calloc(1, sizeof(VARIANT));
+            MSFT_ReadValue(ptvd->vardesc.lpvarValue,
                 pVarRec->OffsValue, pcx);
         } else
-            ptvd->vardesc.u.oInst=pVarRec->OffsValue;
+            ptvd->vardesc.oInst=pVarRec->OffsValue;
         recoffset += reclength;
     }
 }
@@ -2612,10 +2609,9 @@ static void MSFT_DoImplTypes(TLBContext *pcx, ITypeInfoImpl *pTI, int count,
     }
 }
 
-#ifdef _WIN64
-/* when a 32-bit typelib is loaded in 64-bit mode, we need to resize pointers
+/* when a typelib is loaded in a different 32/64-bit mode, we need to resize pointers
  * and some structures, and fix the alignment */
-static void TLB_fix_32on64_typeinfo(ITypeInfoImpl *info)
+static void TLB_fix_typeinfo_ptr_size(ITypeInfoImpl *info)
 {
     if(info->typeattr.typekind == TKIND_ALIAS){
         switch(info->tdescAlias->vt){
@@ -2631,11 +2627,13 @@ static void TLB_fix_32on64_typeinfo(ITypeInfoImpl *info)
             break;
         case VT_CARRAY:
         case VT_USERDEFINED:
-            TLB_size_instance(info, SYS_WIN64, info->tdescAlias, &info->typeattr.cbSizeInstance, &info->typeattr.cbAlignment);
+            TLB_size_instance(info, is_win64 ? SYS_WIN64 : SYS_WIN32, info->tdescAlias,
+                              &info->typeattr.cbSizeInstance, &info->typeattr.cbAlignment);
             break;
         case VT_VARIANT:
             info->typeattr.cbSizeInstance = sizeof(VARIANT);
-            info->typeattr.cbAlignment = 8;
+            info->typeattr.cbAlignment = sizeof(void *);
+            break;
         default:
             if(info->typeattr.cbSizeInstance < sizeof(void*))
                 info->typeattr.cbAlignment = info->typeattr.cbSizeInstance;
@@ -2650,7 +2648,6 @@ static void TLB_fix_32on64_typeinfo(ITypeInfoImpl *info)
         info->typeattr.cbAlignment = sizeof(void*);
     }
 }
-#endif
 
 /*
  * process a typeinfo record
@@ -2689,7 +2686,7 @@ static ITypeInfoImpl * MSFT_DoTypeInfo(
     if (ptiRet->typeattr.typekind == TKIND_ALIAS) {
         TYPEDESC tmp;
         MSFT_GetTdesc(pcx, tiBase.datatype1, &tmp);
-        ptiRet->tdescAlias = heap_alloc(TLB_SizeTypeDesc(&tmp, TRUE));
+        ptiRet->tdescAlias = malloc(TLB_SizeTypeDesc(&tmp, TRUE));
         TLB_CopyTypeDesc(NULL, &tmp, ptiRet->tdescAlias);
     }
 
@@ -2779,24 +2776,24 @@ static HRESULT MSFT_ReadAllStrings(TLBContext *pcx)
         if(len_piece < 8)
             len_piece = 8;
 
-        string = heap_alloc(len_piece + 1);
+        string = malloc(len_piece + 1);
         MSFT_Read(string, len_piece - sizeof(INT16), pcx, DO_NOT_SEEK);
         string[len_str] = '\0';
 
         lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
                                             string, -1, NULL, 0);
         if (!lengthInChars) {
-            heap_free(string);
+            free(string);
             return E_UNEXPECTED;
         }
 
-        tlbstr = heap_alloc(sizeof(TLBString));
+        tlbstr = malloc(sizeof(TLBString));
 
         tlbstr->offset = offs;
         tlbstr->str = SysAllocStringByteLen(NULL, lengthInChars * sizeof(WCHAR));
         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, string, -1, tlbstr->str, lengthInChars);
 
-        heap_free(string);
+        free(string);
 
         list_add_tail(&pcx->pLibInfo->string_list, &tlbstr->entry);
 
@@ -2816,7 +2813,7 @@ static HRESULT MSFT_ReadAllRefs(TLBContext *pcx)
 
         MSFT_ReadLEDWords(&impinfo, sizeof(impinfo), pcx, DO_NOT_SEEK);
 
-        ref = heap_alloc_zero(sizeof(TLBRefType));
+        ref = calloc(1, sizeof(TLBRefType));
         list_add_tail(&pcx->pLibInfo->ref_list, &ref->entry);
 
         LIST_FOR_EACH_ENTRY(pImpLib, &pcx->pLibInfo->implib_list, TLBImpLib, entry)
@@ -2903,7 +2900,7 @@ static ULONG WINAPI TLB_PEFile_Release(IUnknown *iface)
             FreeResource(This->typelib_global);
         if (This->dll)
             FreeLibrary(This->dll);
-        heap_free(This);
+        free(This);
     }
     return refs;
 }
@@ -2920,7 +2917,7 @@ static HRESULT TLB_PEFile_Open(LPCWSTR path, INT index, LPVOID *ppBase, DWORD *p
     TLB_PEFile *This;
     HRESULT hr = TYPE_E_CANTLOADLIBRARY;
 
-    This = heap_alloc(sizeof(TLB_PEFile));
+    This = malloc(sizeof(TLB_PEFile));
     if (!This)
         return E_OUTOFMEMORY;
 
@@ -2936,8 +2933,7 @@ static HRESULT TLB_PEFile_Open(LPCWSTR path, INT index, LPVOID *ppBase, DWORD *p
 
     if (This->dll)
     {
-        static const WCHAR TYPELIBW[] = {'T','Y','P','E','L','I','B',0};
-        This->typelib_resource = FindResourceW(This->dll, MAKEINTRESOURCEW(index), TYPELIBW);
+        This->typelib_resource = FindResourceW(This->dll, MAKEINTRESOURCEW(index), L"TYPELIB");
         if (This->typelib_resource)
         {
             This->typelib_global = LoadResource(This->dll, This->typelib_resource);
@@ -2999,8 +2995,8 @@ static ULONG WINAPI TLB_NEFile_Release(IUnknown *iface)
     ULONG refs = InterlockedDecrement(&This->refs);
     if (!refs)
     {
-        heap_free(This->typelib_base);
-        heap_free(This);
+        free(This->typelib_base);
+        free(This);
     }
     return refs;
 }
@@ -3069,13 +3065,13 @@ static BOOL find_ne_resource( HFILE lzfd, LPCSTR typeid, LPCSTR resid,
     }
 
     /* Read in resource table */
-    resTab = heap_alloc( resTabSize );
+    resTab = malloc( resTabSize );
     if ( !resTab ) return FALSE;
 
     LZSeek( lzfd, nehd.ne_rsrctab + nehdoffset, SEEK_SET );
     if ( resTabSize != LZRead( lzfd, (char*)resTab, resTabSize ) )
     {
-        heap_free( resTab );
+        free( resTab );
         return FALSE;
     }
 
@@ -3107,7 +3103,7 @@ static BOOL find_ne_resource( HFILE lzfd, LPCSTR typeid, LPCSTR resid,
         }
     }
     TRACE("No typeid entry found for %p\n", typeid );
-    heap_free( resTab );
+    free( resTab );
     return FALSE;
 
  found_type:
@@ -3130,7 +3126,7 @@ static BOOL find_ne_resource( HFILE lzfd, LPCSTR typeid, LPCSTR resid,
             if (nameInfo->id == id) goto found_name;
     }
     TRACE("No resid entry found for %p\n", typeid );
-    heap_free( resTab );
+    free( resTab );
     return FALSE;
 
  found_name:
@@ -3138,7 +3134,7 @@ static BOOL find_ne_resource( HFILE lzfd, LPCSTR typeid, LPCSTR resid,
     if ( resLen ) *resLen = nameInfo->length << *(WORD *)resTab;
     if ( resOff ) *resOff = nameInfo->offset << *(WORD *)resTab;
 
-    heap_free( resTab );
+    free( resTab );
     return TRUE;
 }
 
@@ -3149,7 +3145,7 @@ static HRESULT TLB_NEFile_Open(LPCWSTR path, INT index, LPVOID *ppBase, DWORD *p
     HRESULT hr = TYPE_E_CANTLOADLIBRARY;
     TLB_NEFile *This;
 
-    This = heap_alloc(sizeof(TLB_NEFile));
+    This = malloc(sizeof(TLB_NEFile));
     if (!This) return E_OUTOFMEMORY;
 
     This->IUnknown_iface.lpVtbl = &TLB_NEFile_Vtable;
@@ -3162,7 +3158,7 @@ static HRESULT TLB_NEFile_Open(LPCWSTR path, INT index, LPVOID *ppBase, DWORD *p
         DWORD reslen, offset;
         if( find_ne_resource( lzfd, "TYPELIB", MAKEINTRESOURCEA(index), &reslen, &offset ) )
         {
-            This->typelib_base = heap_alloc(reslen);
+            This->typelib_base = malloc(reslen);
             if( !This->typelib_base )
                 hr = E_OUTOFMEMORY;
             else
@@ -3227,7 +3223,7 @@ static ULONG WINAPI TLB_Mapping_Release(IUnknown *iface)
             CloseHandle(This->mapping);
         if (This->file != INVALID_HANDLE_VALUE)
             CloseHandle(This->file);
-        heap_free(This);
+        free(This);
     }
     return refs;
 }
@@ -3243,7 +3239,7 @@ static HRESULT TLB_Mapping_Open(LPCWSTR path, LPVOID *ppBase, DWORD *pdwTLBLengt
 {
     TLB_Mapping *This;
 
-    This = heap_alloc(sizeof(TLB_Mapping));
+    This = malloc(sizeof(TLB_Mapping));
     if (!This)
         return E_OUTOFMEMORY;
 
@@ -3305,7 +3301,7 @@ static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath
         {
             int str_len = index_str - pszFileName - 1;
             index = idx;
-            file = heap_alloc((str_len + 1) * sizeof(WCHAR));
+            file = malloc((str_len + 1) * sizeof(WCHAR));
             memcpy(file, pszFileName, str_len * sizeof(WCHAR));
             file[str_len] = 0;
         }
@@ -3325,31 +3321,11 @@ static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath
         }
     }
 
-    if(file != pszFileName) heap_free(file);
+    if(file != pszFileName) free(file);
 
-    h = CreateFileW(pszPath, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    h = CreateFileW(pszPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
     if(h != INVALID_HANDLE_VALUE){
-        FILE_NAME_INFORMATION size_info;
-        BOOL br;
-
-        /* GetFileInformationByHandleEx returns the path of the file without
-         * WOW64 redirection */
-        br = GetFileInformationByHandleEx(h, FileNameInfo, &size_info, sizeof(size_info));
-        if(br || GetLastError() == ERROR_MORE_DATA){
-            FILE_NAME_INFORMATION *info;
-            DWORD size = sizeof(*info) + size_info.FileNameLength + sizeof(WCHAR);
-
-            info = HeapAlloc(GetProcessHeap(), 0, size);
-
-            br = GetFileInformationByHandleEx(h, FileNameInfo, info, size);
-            if(br){
-                info->FileName[info->FileNameLength / sizeof(WCHAR)] = 0;
-                lstrcpynW(pszPath + 2, info->FileName, cchPath - 2);
-            }
-
-            HeapFree(GetProcessHeap(), 0, info);
-        }
-
+        GetFinalPathNameByHandleW(h, pszPath, cchPath, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
         CloseHandle(h);
     }
 
@@ -3388,7 +3364,7 @@ static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath
                 *ppTypeLib = ITypeLib2_Constructor_SLTG(pBase, dwTLBLength);
             else
             {
-                FIXME("Header type magic 0x%08x not supported.\n",dwSignature);
+                FIXME("Header type magic %#lx not supported.\n", dwSignature);
                 ret = TYPE_E_CANTLOADLIBRARY;
             }
         }
@@ -3401,8 +3377,7 @@ static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath
 	ITypeLibImpl *impl = impl_from_ITypeLib2(*ppTypeLib);
 
 	TRACE("adding to cache\n");
-	impl->path = heap_alloc((lstrlenW(pszPath)+1) * sizeof(WCHAR));
-	lstrcpyW(impl->path, pszPath);
+	impl->path = wcsdup(pszPath);
 	/* We should really canonicalise the path here. */
         impl->index = index;
 
@@ -3415,7 +3390,7 @@ static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath
     else
     {
         if(ret != E_FAIL)
-            ERR("Loading of typelib %s failed with error %d\n", debugstr_w(pszFileName), GetLastError());
+            ERR("Loading of typelib %s failed with error %ld\n", debugstr_w(pszFileName), GetLastError());
 
         ret = TYPE_E_CANTLOADLIBRARY;
     }
@@ -3430,7 +3405,7 @@ static ITypeLibImpl* TypeLibImpl_Constructor(void)
 {
     ITypeLibImpl* pTypeLibImpl;
 
-    pTypeLibImpl = heap_alloc_zero(sizeof(ITypeLibImpl));
+    pTypeLibImpl = calloc(1, sizeof(ITypeLibImpl));
     if (!pTypeLibImpl) return NULL;
 
     pTypeLibImpl->ITypeLib2_iface.lpVtbl = &tlbvt;
@@ -3463,7 +3438,7 @@ static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
     ITypeLibImpl * pTypeLibImpl;
     int i;
 
-    TRACE("%p, TLB length = %d\n", pLib, dwTLBLength);
+    TRACE("%p, TLB length = %ld\n", pLib, dwTLBLength);
 
     pTypeLibImpl = TypeLibImpl_Constructor();
     if (!pTypeLibImpl) return NULL;
@@ -3491,15 +3466,15 @@ static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
     lPSegDir = sizeof(tlbHeader) + (tlbHeader.nrtypeinfos)*4 + ((tlbHeader.varflags & HELPDLLFLAG)? 4 :0);
 
     /* now read the segment directory */
-    TRACE("read segment directory (at %d)\n",lPSegDir);
+    TRACE("read segment directory (at %ld)\n",lPSegDir);
     MSFT_ReadLEDWords(&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);
     cx.pTblDir = &tlbSegDir;
 
     /* just check two entries */
     if ( tlbSegDir.pTypeInfoTab.res0c != 0x0F || tlbSegDir.pImpInfo.res0c != 0x0F)
     {
-        ERR("cannot find the table directory, ptr=0x%x\n",lPSegDir);
-	heap_free(pTypeLibImpl);
+        ERR("cannot find the table directory, ptr %#lx\n",lPSegDir);
+	free(pTypeLibImpl);
 	return NULL;
     }
 
@@ -3548,7 +3523,7 @@ static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
         int i, j, cTD = tlbSegDir.pTypdescTab.length / (2*sizeof(INT));
         INT16 td[4];
         pTypeLibImpl->ctTypeDesc = cTD;
-        pTypeLibImpl->pTypeDesc = heap_alloc_zero( cTD * sizeof(TYPEDESC));
+        pTypeLibImpl->pTypeDesc = calloc(cTD, sizeof(TYPEDESC));
         MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
         for(i=0; i<cTD; )
 	{
@@ -3558,18 +3533,18 @@ static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
 	    {
 	        /* FIXME: check safearray */
                 if(td[3] < 0)
-                    pTypeLibImpl->pTypeDesc[i].u.lptdesc = &std_typedesc[td[2]];
+                    pTypeLibImpl->pTypeDesc[i].lptdesc = &std_typedesc[td[2]];
                 else
-                    pTypeLibImpl->pTypeDesc[i].u.lptdesc = &pTypeLibImpl->pTypeDesc[td[2]/8];
+                    pTypeLibImpl->pTypeDesc[i].lptdesc = &pTypeLibImpl->pTypeDesc[td[2]/8];
             }
 	    else if(td[0] == VT_CARRAY)
             {
 	        /* array descr table here */
-	        pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)(INT_PTR)td[2];  /* temp store offset in*/
+	        pTypeLibImpl->pTypeDesc[i].lpadesc = (void *)(INT_PTR)td[2];  /* temp store offset in*/
             }
             else if(td[0] == VT_USERDEFINED)
 	    {
-                pTypeLibImpl->pTypeDesc[i].u.hreftype = MAKELONG(td[2],td[3]);
+                pTypeLibImpl->pTypeDesc[i].hreftype = MAKELONG(td[2],td[3]);
             }
 	    if(++i<cTD) MSFT_ReadLEWords(td, sizeof(td), &cx, DO_NOT_SEEK);
         }
@@ -3580,27 +3555,27 @@ static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
             if(pTypeLibImpl->pTypeDesc[i].vt != VT_CARRAY) continue;
             if(tlbSegDir.pArrayDescriptions.offset>0)
 	    {
-                MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (INT_PTR)pTypeLibImpl->pTypeDesc[i].u.lpadesc);
-                pTypeLibImpl->pTypeDesc[i].u.lpadesc = heap_alloc_zero(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
+                MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (INT_PTR)pTypeLibImpl->pTypeDesc[i].lpadesc);
+                pTypeLibImpl->pTypeDesc[i].lpadesc = calloc(1, sizeof(ARRAYDESC) + sizeof(SAFEARRAYBOUND) * (td[3] - 1));
 
                 if(td[1]<0)
-                    pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem.vt = td[0] & VT_TYPEMASK;
+                    pTypeLibImpl->pTypeDesc[i].lpadesc->tdescElem.vt = td[0] & VT_TYPEMASK;
                 else
-                    pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem = cx.pLibInfo->pTypeDesc[td[0]/(2*sizeof(INT))];
+                    pTypeLibImpl->pTypeDesc[i].lpadesc->tdescElem = cx.pLibInfo->pTypeDesc[td[0]/(2*sizeof(INT))];
 
-                pTypeLibImpl->pTypeDesc[i].u.lpadesc->cDims = td[2];
+                pTypeLibImpl->pTypeDesc[i].lpadesc->cDims = td[2];
 
                 for(j = 0; j<td[2]; j++)
 		{
-                    MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements,
+                    MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].lpadesc->rgbounds[j].cElements,
                                       sizeof(INT), &cx, DO_NOT_SEEK);
-                    MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound,
+                    MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].lpadesc->rgbounds[j].lLbound,
                                       sizeof(INT), &cx, DO_NOT_SEEK);
                 }
             }
 	    else
 	    {
-                pTypeLibImpl->pTypeDesc[i].u.lpadesc = NULL;
+                pTypeLibImpl->pTypeDesc[i].lpadesc = NULL;
                 ERR("didn't find array description data\n");
             }
         }
@@ -3617,7 +3592,7 @@ static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
 	{
             char *name;
 
-            pImpLib = heap_alloc_zero(sizeof(TLBImpLib));
+            pImpLib = calloc(1, sizeof(TLBImpLib));
             pImpLib->offset = offset - tlbSegDir.pImpFiles.offset;
             MSFT_ReadLEDWords(&oGuid, sizeof(INT), &cx, offset);
 
@@ -3627,10 +3602,10 @@ static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
             MSFT_ReadLEWords(& size,                      sizeof(UINT16), &cx, DO_NOT_SEEK);
 
             size >>= 2;
-            name = heap_alloc_zero(size+1);
+            name = calloc(1, size + 1);
             MSFT_Read(name, size, &cx, DO_NOT_SEEK);
             pImpLib->name = TLB_MultiByteToBSTR(name);
-            heap_free(name);
+            free(name);
 
             pImpLib->guid = MSFT_ReadGuid(oGuid, &cx);
             offset = (offset + sizeof(INT) + sizeof(DWORD) + sizeof(LCID) + sizeof(UINT16) + size + 3) & ~3;
@@ -3648,7 +3623,7 @@ static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
     {
         ITypeInfoImpl **ppTI;
 
-        ppTI = pTypeLibImpl->typeinfos = heap_alloc_zero(sizeof(ITypeInfoImpl*) * tlbHeader.nrtypeinfos);
+        ppTI = pTypeLibImpl->typeinfos = calloc(tlbHeader.nrtypeinfos, sizeof(ITypeInfoImpl*));
 
         for(i = 0; i < tlbHeader.nrtypeinfos; i++)
         {
@@ -3659,12 +3634,11 @@ static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
         }
     }
 
-#ifdef _WIN64
-    if(pTypeLibImpl->syskind == SYS_WIN32){
+    if (pTypeLibImpl->ptr_size != sizeof(void *))
+    {
         for(i = 0; i < pTypeLibImpl->TypeInfoCount; ++i)
-            TLB_fix_32on64_typeinfo(pTypeLibImpl->typeinfos[i]);
+            TLB_fix_typeinfo_ptr_size(pTypeLibImpl->typeinfos[i]);
     }
-#endif
 
     TRACE("(%p)\n", pTypeLibImpl);
     return &pTypeLibImpl->ITypeLib2_iface;
@@ -3677,7 +3651,7 @@ static BOOL TLB_GUIDFromString(const char *str, GUID *guid)
   int i;
   short s;
 
-  if(sscanf(str, "%x-%hx-%hx-%hx", &guid->Data1, &guid->Data2, &guid->Data3, &s) != 4) {
+  if(sscanf(str, "%lx-%hx-%hx-%hx", &guid->Data1, &guid->Data2, &guid->Data3, &s) != 4) {
     FIXME("Can't parse guid %s\n", debugstr_guid(guid));
     return FALSE;
   }
@@ -3693,87 +3667,6 @@ static BOOL TLB_GUIDFromString(const char *str, GUID *guid)
   return TRUE;
 }
 
-struct bitstream
-{
-    const BYTE *buffer;
-    DWORD       length;
-    WORD        current;
-};
-
-static const char *lookup_code(const BYTE *table, DWORD table_size, struct bitstream *bits)
-{
-    const BYTE *p = table;
-
-    while (p < table + table_size && *p == 0x80)
-    {
-        if (p + 2 >= table + table_size) return NULL;
-
-        if (!(bits->current & 0xff))
-        {
-            if (!bits->length) return NULL;
-            bits->current = (*bits->buffer << 8) | 1;
-            bits->buffer++;
-            bits->length--;
-        }
-
-        if (bits->current & 0x8000)
-        {
-            p += 3;
-        }
-        else
-        {
-            p = table + (*(p + 2) | (*(p + 1) << 8));
-        }
-
-        bits->current <<= 1;
-    }
-
-    if (p + 1 < table + table_size && *(p + 1))
-    {
-        /* FIXME: Whats the meaning of *p? */
-        const BYTE *q = p + 1;
-        while (q < table + table_size && *q) q++;
-        return (q < table + table_size) ? (const char *)(p + 1) : NULL;
-    }
-
-    return NULL;
-}
-
-static const TLBString *decode_string(const BYTE *table, const char *stream, DWORD stream_length, ITypeLibImpl *lib)
-{
-    DWORD buf_size, table_size;
-    const char *p;
-    struct bitstream bits;
-    BSTR buf;
-    TLBString *tlbstr;
-
-    if (!stream_length) return NULL;
-
-    bits.buffer = (const BYTE *)stream;
-    bits.length = stream_length;
-    bits.current = 0;
-
-    buf_size = *(const WORD *)table;
-    table += sizeof(WORD);
-    table_size = *(const DWORD *)table;
-    table += sizeof(DWORD);
-
-    buf = SysAllocStringLen(NULL, buf_size);
-    buf[0] = 0;
-
-    while ((p = lookup_code(table, table_size, &bits)))
-    {
-        static const WCHAR spaceW[] = { ' ',0 };
-        if (buf[0]) lstrcatW(buf, spaceW);
-        MultiByteToWideChar(CP_ACP, 0, p, -1, buf + lstrlenW(buf), buf_size - lstrlenW(buf));
-    }
-
-    tlbstr = TLB_append_str(&lib->string_list, buf);
-    SysFreeString(buf);
-
-    return tlbstr;
-}
-
 static WORD SLTG_ReadString(const char *ptr, const TLBString **pStr, ITypeLibImpl *lib)
 {
     WORD bytelen;
@@ -3801,7 +3694,7 @@ static WORD SLTG_ReadStringA(const char *ptr, char **str)
     *str = NULL;
     bytelen = *(const WORD*)ptr;
     if(bytelen == 0xffff) return 2;
-    *str = heap_alloc(bytelen + 1);
+    *str = malloc(bytelen + 1);
     memcpy(*str, ptr + 2, bytelen);
     (*str)[bytelen] = '\0';
     return bytelen + 2;
@@ -3836,7 +3729,7 @@ static DWORD SLTG_ReadLibBlk(LPVOID pLibBlk, ITypeLibImpl *pTypeLibImpl)
 
     ptr += 6;
     if((w = *(WORD*)ptr) != 0xffff) {
-        FIXME("LibBlk.res06 = %04x. Assumung string and skipping\n", w);
+        FIXME("LibBlk.res06 = %04x. Assuming string and skipping\n", w);
         ptr += w;
     }
     ptr += 2;
@@ -3903,19 +3796,19 @@ static WORD *SLTG_DoType(WORD *pType, char *pBlk, TYPEDESC *pTD, const sltg_ref_
     while(!done) {
         if((*pType & 0xe00) == 0xe00) {
 	    pTD->vt = VT_PTR;
-	    pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
-	    pTD = pTD->u.lptdesc;
+	    pTD->lptdesc = calloc(1, sizeof(TYPEDESC));
+	    pTD = pTD->lptdesc;
 	}
 	switch(*pType & 0x3f) {
 	case VT_PTR:
 	    pTD->vt = VT_PTR;
-	    pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
-	    pTD = pTD->u.lptdesc;
+	    pTD->lptdesc = calloc(1, sizeof(TYPEDESC));
+	    pTD = pTD->lptdesc;
 	    break;
 
 	case VT_USERDEFINED:
 	    pTD->vt = VT_USERDEFINED;
-            sltg_get_typelib_ref(ref_lookup, *(++pType) / 4, &pTD->u.hreftype);
+            sltg_get_typelib_ref(ref_lookup, *(++pType) / 4, &pTD->hreftype);
 	    done = TRUE;
 	    break;
 
@@ -3927,12 +3820,12 @@ static WORD *SLTG_DoType(WORD *pType, char *pBlk, TYPEDESC *pTD, const sltg_ref_
 	    SAFEARRAY *pSA = (SAFEARRAY *)(pBlk + *(++pType));
 
 	    pTD->vt = VT_CARRAY;
-	    pTD->u.lpadesc = heap_alloc_zero(sizeof(ARRAYDESC) + (pSA->cDims - 1) * sizeof(SAFEARRAYBOUND));
-	    pTD->u.lpadesc->cDims = pSA->cDims;
-	    memcpy(pTD->u.lpadesc->rgbounds, pSA->rgsabound,
+	    pTD->lpadesc = calloc(1, sizeof(ARRAYDESC) + (pSA->cDims - 1) * sizeof(SAFEARRAYBOUND));
+	    pTD->lpadesc->cDims = pSA->cDims;
+	    memcpy(pTD->lpadesc->rgbounds, pSA->rgsabound,
 		   pSA->cDims * sizeof(SAFEARRAYBOUND));
 
-	    pTD = &pTD->u.lpadesc->tdescElem;
+	    pTD = &pTD->lpadesc->tdescElem;
 	    break;
 	  }
 
@@ -3943,8 +3836,8 @@ static WORD *SLTG_DoType(WORD *pType, char *pBlk, TYPEDESC *pTD, const sltg_ref_
 
 	    pType++;
 	    pTD->vt = VT_SAFEARRAY;
-	    pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
-	    pTD = pTD->u.lptdesc;
+	    pTD->lptdesc = calloc(1, sizeof(TYPEDESC));
+	    pTD = pTD->lptdesc;
 	    break;
 	  }
 	default:
@@ -3962,19 +3855,19 @@ static WORD *SLTG_DoElem(WORD *pType, char *pBlk,
 {
     /* Handle [in/out] first */
     if((*pType & 0xc000) == 0xc000)
-        pElem->u.paramdesc.wParamFlags = PARAMFLAG_NONE;
+        pElem->paramdesc.wParamFlags = PARAMFLAG_NONE;
     else if(*pType & 0x8000)
-        pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN | PARAMFLAG_FOUT;
+        pElem->paramdesc.wParamFlags = PARAMFLAG_FIN | PARAMFLAG_FOUT;
     else if(*pType & 0x4000)
-        pElem->u.paramdesc.wParamFlags = PARAMFLAG_FOUT;
+        pElem->paramdesc.wParamFlags = PARAMFLAG_FOUT;
     else
-        pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN;
+        pElem->paramdesc.wParamFlags = PARAMFLAG_FIN;
 
     if(*pType & 0x2000)
-        pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FLCID;
+        pElem->paramdesc.wParamFlags |= PARAMFLAG_FLCID;
 
     if(*pType & 0x80)
-        pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FRETVAL;
+        pElem->paramdesc.wParamFlags |= PARAMFLAG_FRETVAL;
 
     return SLTG_DoType(pType, pBlk, &pElem->tdesc, ref_lookup);
 }
@@ -3995,7 +3888,7 @@ static sltg_ref_lookup_t *SLTG_DoRefs(SLTG_RefInfo *pRef, ITypeLibImpl *pTL,
     }
     name = ( (char*)pRef->names + pRef->number);
 
-    table = heap_alloc(sizeof(*table) + ((pRef->number >> 3) - 1) * sizeof(table->refs[0]));
+    table = malloc(sizeof(*table) + ((pRef->number >> 3) - 1) * sizeof(table->refs[0]));
     table->num = pRef->number >> 3;
 
     /* FIXME should scan the existing list and reuse matching refs added by previous typeinfos */
@@ -4007,7 +3900,7 @@ static sltg_ref_lookup_t *SLTG_DoRefs(SLTG_RefInfo *pRef, ITypeLibImpl *pTL,
         char *refname;
 	unsigned int lib_offs, type_num;
 
-	ref_type = heap_alloc_zero(sizeof(TLBRefType));
+	ref_type = calloc(1, sizeof(TLBRefType));
 
 	name += SLTG_ReadStringA(name, &refname);
 	if(sscanf(refname, "*\\R%x*#%x", &lib_offs, &type_num) != 2)
@@ -4024,11 +3917,11 @@ static sltg_ref_lookup_t *SLTG_DoRefs(SLTG_RefInfo *pRef, ITypeLibImpl *pTL,
 		int len;
                 GUID tmpguid;
 
-		import = heap_alloc_zero(sizeof(*import));
+		import = calloc(1, sizeof(*import));
 		import->offset = lib_offs;
 		TLB_GUIDFromString( pNameTable + lib_offs + 4, &tmpguid);
                 import->guid = TLB_append_guid(&pTL->guid_list, &tmpguid, 2);
-		if(sscanf(pNameTable + lib_offs + 40, "}#%hd.%hd#%x#%s",
+		if(sscanf(pNameTable + lib_offs + 40, "}#%hd.%hd#%lx#%s",
 			  &import->wVersionMajor,
 			  &import->wVersionMinor,
 			  &import->lcid, fname) != 4) {
@@ -4054,7 +3947,7 @@ static sltg_ref_lookup_t *SLTG_DoRefs(SLTG_RefInfo *pRef, ITypeLibImpl *pTL,
 	ref_type->reference = typelib_ref;
 	ref_type->index = type_num;
 
-	heap_free(refname);
+        free(refname);
         list_add_tail(&pTL->ref_list, &ref_type->entry);
 
         table->refs[ref] = typelib_ref;
@@ -4105,7 +3998,7 @@ static char *SLTG_DoImpls(char *pBlk, ITypeInfoImpl *pTI,
 }
 
 static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsigned short cVars,
-			const char *pNameTable, const sltg_ref_lookup_t *ref_lookup, const BYTE *hlp_strings)
+			const char *pNameTable, const sltg_ref_lookup_t *ref_lookup)
 {
   TLBVarDesc *pVarDesc;
   const TLBString *prevName = NULL;
@@ -4133,13 +4026,7 @@ static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsign
 
       TRACE_(typelib)("name: %s\n", debugstr_w(TLB_get_bstr(pVarDesc->Name)));
       TRACE_(typelib)("byte_offs = 0x%x\n", pItem->byte_offs);
-      TRACE_(typelib)("memid = 0x%x\n", pItem->memid);
-
-      if (pItem->helpstring != 0xffff)
-      {
-          pVarDesc->HelpString = decode_string(hlp_strings, pBlk + pItem->helpstring, pNameTable - pBlk, pTI->pTypeLib);
-          TRACE_(typelib)("helpstring = %s\n", debugstr_w(pVarDesc->HelpString->str));
-      }
+      TRACE_(typelib)("memid = %#lx\n", pItem->memid);
 
       if(pItem->flags & 0x02)
 	  pType = &pItem->type;
@@ -4165,10 +4052,10 @@ static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsign
       else if (pItem->flags & 0x10) {
         TRACE_(typelib)("VAR_CONST\n");
         pVarDesc->vardesc.varkind = VAR_CONST;
-        pVarDesc->vardesc.u.lpvarValue = heap_alloc(sizeof(VARIANT));
-        V_VT(pVarDesc->vardesc.u.lpvarValue) = VT_INT;
+        pVarDesc->vardesc.lpvarValue = malloc(sizeof(VARIANT));
+        V_VT(pVarDesc->vardesc.lpvarValue) = VT_INT;
         if (pItem->flags & 0x08)
-          V_INT(pVarDesc->vardesc.u.lpvarValue) = pItem->byte_offs;
+          V_INT(pVarDesc->vardesc.lpvarValue) = pItem->byte_offs;
         else {
           switch (pVarDesc->vardesc.elemdescVar.tdesc.vt)
           {
@@ -4186,8 +4073,8 @@ static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsign
                 str = SysAllocStringLen(NULL, alloc_len);
                 MultiByteToWideChar(CP_ACP, 0, pBlk + pItem->byte_offs + 2, len, str, alloc_len);
               }
-              V_VT(pVarDesc->vardesc.u.lpvarValue) = VT_BSTR;
-              V_BSTR(pVarDesc->vardesc.u.lpvarValue) = str;
+              V_VT(pVarDesc->vardesc.lpvarValue) = VT_BSTR;
+              V_BSTR(pVarDesc->vardesc.lpvarValue) = str;
               break;
             }
             case VT_I2:
@@ -4196,7 +4083,7 @@ static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsign
             case VT_UI4:
             case VT_INT:
             case VT_UINT:
-              V_INT(pVarDesc->vardesc.u.lpvarValue) =
+              V_INT(pVarDesc->vardesc.lpvarValue) =
                 *(INT*)(pBlk + pItem->byte_offs);
               break;
             default:
@@ -4206,7 +4093,7 @@ static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsign
       }
       else {
         TRACE_(typelib)("VAR_PERINSTANCE\n");
-        pVarDesc->vardesc.u.oInst = pItem->byte_offs;
+        pVarDesc->vardesc.oInst = pItem->byte_offs;
         pVarDesc->vardesc.varkind = VAR_PERINSTANCE;
       }
 
@@ -4222,8 +4109,7 @@ static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsign
 }
 
 static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI,
-			 unsigned short cFuncs, char *pNameTable, const sltg_ref_lookup_t *ref_lookup,
-			 const BYTE *hlp_strings)
+			 unsigned short cFuncs, char *pNameTable, const sltg_ref_lookup_t *ref_lookup)
 {
     SLTG_Function *pFunc;
     unsigned short i;
@@ -4259,9 +4145,10 @@ static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI,
 	pFuncDesc->funcdesc.callconv = pFunc->nacc & 0x7;
 	pFuncDesc->funcdesc.cParams = pFunc->nacc >> 3;
 	pFuncDesc->funcdesc.cParamsOpt = (pFunc->retnextopt & 0x7e) >> 1;
-	pFuncDesc->funcdesc.oVft = (pFunc->vtblpos & ~1) * sizeof(void *) / pTI->pTypeLib->ptr_size;
-        if (pFunc->helpstring != 0xffff)
-            pFuncDesc->HelpString = decode_string(hlp_strings, pBlk + pFunc->helpstring, pNameTable - pBlk, pTI->pTypeLib);
+	if (pFuncDesc->funcdesc.funckind == FUNC_DISPATCH)
+	    pFuncDesc->funcdesc.oVft = 0;
+        else
+	    pFuncDesc->funcdesc.oVft = (unsigned short)(pFunc->vtblpos & ~1) * sizeof(void *) / pTI->pTypeLib->ptr_size;
 
 	if(pFunc->magic & SLTG_FUNCTION_FLAGS_PRESENT)
 	    pFuncDesc->funcdesc.wFuncFlags = pFunc->funcflags;
@@ -4274,38 +4161,43 @@ static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI,
 	SLTG_DoElem(pType, pBlk, &pFuncDesc->funcdesc.elemdescFunc, ref_lookup);
 
 	pFuncDesc->funcdesc.lprgelemdescParam =
-	  heap_alloc_zero(pFuncDesc->funcdesc.cParams * sizeof(ELEMDESC));
+	  calloc(pFuncDesc->funcdesc.cParams, sizeof(ELEMDESC));
 	pFuncDesc->pParamDesc = TLBParDesc_Constructor(pFuncDesc->funcdesc.cParams);
 
 	pArg = (WORD*)(pBlk + pFunc->arg_off);
 
 	for(param = 0; param < pFuncDesc->funcdesc.cParams; param++) {
-	    char *paramName = pNameTable + (*pArg & ~1);
+	    char *paramName = pNameTable + *pArg;
 	    BOOL HaveOffs;
 	    /* If arg type follows then paramName points to the 2nd
 	       letter of the name, else the next WORD is an offset to
 	       the arg type and paramName points to the first letter.
 	       So let's take one char off paramName and see if we're
-	       pointing at an alpha-numeric char.  However if *pArg is
+	       pointing at an alphanumeric char.  However if *pArg is
 	       0xffff or 0xfffe then the param has no name, the former
 	       meaning that the next WORD is the type, the latter
 	       meaning that the next WORD is an offset to the type. */
 
-	    if(*pArg == 0xffff || *pArg == 0xfffe)
+	    HaveOffs = FALSE;
+	    if(*pArg == 0xffff)
 	        paramName = NULL;
+	    else if(*pArg == 0xfffe) {
+	        paramName = NULL;
+		HaveOffs = TRUE;
+	    }
+	    else if(paramName[-1] && !isalnum(paramName[-1]))
+	        HaveOffs = TRUE;
 
-	    HaveOffs = !(*pArg & 1);
 	    pArg++;
 
-            TRACE_(typelib)("param %d: paramName %s, *pArg %#x\n",
-                param, debugstr_a(paramName), *pArg);
-
 	    if(HaveOffs) { /* the next word is an offset to type */
 	        pType = (WORD*)(pBlk + *pArg);
 		SLTG_DoElem(pType, pBlk,
 			    &pFuncDesc->funcdesc.lprgelemdescParam[param], ref_lookup);
 		pArg++;
 	    } else {
+		if(paramName)
+		  paramName--;
 		pArg = SLTG_DoElem(pArg, pBlk,
                                    &pFuncDesc->funcdesc.lprgelemdescParam[param], ref_lookup);
 	    }
@@ -4313,7 +4205,7 @@ static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI,
 	    /* Are we an optional param ? */
 	    if(pFuncDesc->funcdesc.cParams - param <=
 	       pFuncDesc->funcdesc.cParamsOpt)
-	      pFuncDesc->funcdesc.lprgelemdescParam[param].u.paramdesc.wParamFlags |= PARAMFLAG_FOPT;
+	      pFuncDesc->funcdesc.lprgelemdescParam[param].paramdesc.wParamFlags |= PARAMFLAG_FOPT;
 
 	    if(paramName) {
 	        pFuncDesc->pParamDesc[param].Name = SLTG_ReadName(pNameTable,
@@ -4343,13 +4235,13 @@ static void SLTG_ProcessCoClass(char *pBlk, ITypeInfoImpl *pTI,
     if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
         SLTG_DoImpls(pFirstItem, pTI, FALSE, ref_lookup);
     }
-    heap_free(ref_lookup);
+    free(ref_lookup);
 }
 
 
 static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
 				  char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
-				  const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings)
+				  const SLTG_TypeInfoTail *pTITail)
 {
     char *pFirstItem;
     sltg_ref_lookup_t *ref_lookup = NULL;
@@ -4366,9 +4258,9 @@ static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
     }
 
     if (pTITail->funcs_off != 0xffff)
-        SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup, hlp_strings);
+        SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
 
-    heap_free(ref_lookup);
+    free(ref_lookup);
 
     if (TRACE_ON(typelib))
         dump_TLBFuncDesc(pTI->funcdescs, pTI->typeattr.cFuncs);
@@ -4376,9 +4268,9 @@ static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
 
 static void SLTG_ProcessRecord(char *pBlk, ITypeInfoImpl *pTI,
 			       const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
-			       const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings)
+			       const SLTG_TypeInfoTail *pTITail)
 {
-  SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL, hlp_strings);
+  SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL);
 }
 
 static void SLTG_ProcessAlias(char *pBlk, ITypeInfoImpl *pTI,
@@ -4390,7 +4282,7 @@ static void SLTG_ProcessAlias(char *pBlk, ITypeInfoImpl *pTI,
 
   if (pTITail->simple_alias) {
       /* if simple alias, no more processing required */
-      pTI->tdescAlias = heap_alloc_zero(sizeof(TYPEDESC));
+      pTI->tdescAlias = calloc(1, sizeof(TYPEDESC));
       pTI->tdescAlias->vt = pTITail->tdescalias_vt;
       return;
   }
@@ -4403,15 +4295,15 @@ static void SLTG_ProcessAlias(char *pBlk, ITypeInfoImpl *pTI,
   /* otherwise it is an offset to a type */
   pType = (WORD *)(pBlk + pTITail->tdescalias_vt);
 
-  pTI->tdescAlias = heap_alloc(sizeof(TYPEDESC));
+  pTI->tdescAlias = malloc(sizeof(TYPEDESC));
   SLTG_DoType(pType, pBlk, pTI->tdescAlias, ref_lookup);
 
-  heap_free(ref_lookup);
+  free(ref_lookup);
 }
 
 static void SLTG_ProcessDispatch(char *pBlk, ITypeInfoImpl *pTI,
 				 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
-				 const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings)
+				 const SLTG_TypeInfoTail *pTITail)
 {
   sltg_ref_lookup_t *ref_lookup = NULL;
   if (pTIHeader->href_table != 0xffffffff)
@@ -4419,10 +4311,10 @@ static void SLTG_ProcessDispatch(char *pBlk, ITypeInfoImpl *pTI,
                                   pNameTable);
 
   if (pTITail->vars_off != 0xffff)
-    SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup, hlp_strings);
+    SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
 
   if (pTITail->funcs_off != 0xffff)
-    SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup, hlp_strings);
+    SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
 
   if (pTITail->impls_off != 0xffff)
     SLTG_DoImpls(pBlk + pTITail->impls_off, pTI, FALSE, ref_lookup);
@@ -4432,21 +4324,21 @@ static void SLTG_ProcessDispatch(char *pBlk, ITypeInfoImpl *pTI,
    * ITypeInfo::GetFuncDesc takes the real value for cFuncs from cbSizeVft */
   pTI->typeattr.cbSizeVft = pTI->typeattr.cFuncs * pTI->pTypeLib->ptr_size;
 
-  heap_free(ref_lookup);
+  free(ref_lookup);
   if (TRACE_ON(typelib))
       dump_TLBFuncDesc(pTI->funcdescs, pTI->typeattr.cFuncs);
 }
 
 static void SLTG_ProcessEnum(char *pBlk, ITypeInfoImpl *pTI,
 			     const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
-			     const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings)
+			     const SLTG_TypeInfoTail *pTITail)
 {
-  SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL, hlp_strings);
+  SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL);
 }
 
 static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI,
 			       char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
-			       const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings)
+			       const SLTG_TypeInfoTail *pTITail)
 {
   sltg_ref_lookup_t *ref_lookup = NULL;
   if (pTIHeader->href_table != 0xffffffff)
@@ -4454,11 +4346,11 @@ static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI,
                                   pNameTable);
 
   if (pTITail->vars_off != 0xffff)
-    SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup, hlp_strings);
+    SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
 
   if (pTITail->funcs_off != 0xffff)
-    SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup, hlp_strings);
-  heap_free(ref_lookup);
+    SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
+  free(ref_lookup);
   if (TRACE_ON(typelib))
     dump_TypeInfo(pTI);
 }
@@ -4466,17 +4358,17 @@ static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI,
 /* Because SLTG_OtherTypeInfo is such a painful struct, we make a more
    manageable copy of it into this */
 typedef struct {
+  WORD small_no;
   char *index_name;
   char *other_name;
   WORD res1a;
   WORD name_offs;
-  WORD hlpstr_len;
+  WORD more_bytes;
   char *extra;
   WORD res20;
   DWORD helpcontext;
   WORD res26;
   GUID uuid;
-  WORD typekind;
 } SLTG_InternalOtherTypeInfo;
 
 /****************************************************************************
@@ -4495,13 +4387,13 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
     LPVOID pBlk, pFirstBlk;
     SLTG_LibBlk *pLibBlk;
     SLTG_InternalOtherTypeInfo *pOtherTypeInfoBlks;
+    char *pAfterOTIBlks = NULL;
     char *pNameTable, *ptr;
-    const BYTE *hlp_strings;
     int i;
     DWORD len, order;
     ITypeInfoImpl **ppTypeInfoImpl;
 
-    TRACE_(typelib)("%p, TLB length = %d\n", pLib, dwTLBLength);
+    TRACE_(typelib)("%p, TLB length = %ld\n", pLib, dwTLBLength);
 
 
     pTypeLibImpl = TypeLibImpl_Constructor();
@@ -4510,11 +4402,11 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
     pHeader = pLib;
 
     TRACE_(typelib)("header:\n");
-    TRACE_(typelib)("\tmagic=0x%08x, file blocks = %d\n", pHeader->SLTG_magic,
+    TRACE_(typelib)("\tmagic %#lx, file blocks = %d\n", pHeader->SLTG_magic,
 	  pHeader->nrOfFileBlks );
-    if (pHeader->SLTG_magic != SLTG_SIGNATURE) {
-	FIXME_(typelib)("Header type magic 0x%08x not supported.\n",
-	      pHeader->SLTG_magic);
+    if (pHeader->SLTG_magic != SLTG_SIGNATURE)
+    {
+        FIXME_(typelib)("Header type magic %#lx not supported.\n", pHeader->SLTG_magic);
 	return NULL;
     }
 
@@ -4562,10 +4454,9 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
     len += 0x40;
 
     /* And now TypeInfoCount of SLTG_OtherTypeInfo */
-    pTypeLibImpl->TypeInfoCount = *(WORD *)((char *)pLibBlk + len);
-    len += sizeof(WORD);
 
-    pOtherTypeInfoBlks = heap_alloc_zero(sizeof(*pOtherTypeInfoBlks) * pTypeLibImpl->TypeInfoCount);
+    pOtherTypeInfoBlks = calloc(pTypeLibImpl->TypeInfoCount, sizeof(*pOtherTypeInfoBlks));
+
 
     ptr = (char*)pLibBlk + len;
 
@@ -4573,44 +4464,43 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
 	WORD w, extra;
 	len = 0;
 
-	w = *(WORD*)ptr;
+	pOtherTypeInfoBlks[i].small_no = *(WORD*)ptr;
+
+	w = *(WORD*)(ptr + 2);
 	if(w != 0xffff) {
 	    len += w;
-	    pOtherTypeInfoBlks[i].index_name = heap_alloc(w+1);
-	    memcpy(pOtherTypeInfoBlks[i].index_name, ptr + 2, w);
+	    pOtherTypeInfoBlks[i].index_name = malloc(w + 1);
+	    memcpy(pOtherTypeInfoBlks[i].index_name, ptr + 4, w);
 	    pOtherTypeInfoBlks[i].index_name[w] = '\0';
 	}
-	w = *(WORD*)(ptr + 2 + len);
+	w = *(WORD*)(ptr + 4 + len);
 	if(w != 0xffff) {
-	    TRACE_(typelib)("\twith %s\n", debugstr_an(ptr + 4 + len, w));
-	    pOtherTypeInfoBlks[i].other_name = heap_alloc(w+1);
-	    memcpy(pOtherTypeInfoBlks[i].other_name, ptr + 4 + len, w);
-	    pOtherTypeInfoBlks[i].other_name[w] = '\0';
+	    TRACE_(typelib)("\twith %s\n", debugstr_an(ptr + 6 + len, w));
 	    len += w;
+	    pOtherTypeInfoBlks[i].other_name = malloc(w + 1);
+	    memcpy(pOtherTypeInfoBlks[i].other_name, ptr + 6 + len, w);
+	    pOtherTypeInfoBlks[i].other_name[w] = '\0';
 	}
-	pOtherTypeInfoBlks[i].res1a = *(WORD*)(ptr + 4 + len);
-	pOtherTypeInfoBlks[i].name_offs = *(WORD*)(ptr + 6 + len);
-	extra = pOtherTypeInfoBlks[i].hlpstr_len = *(WORD*)(ptr + 8 + len);
+	pOtherTypeInfoBlks[i].res1a = *(WORD*)(ptr + len + 6);
+	pOtherTypeInfoBlks[i].name_offs = *(WORD*)(ptr + len + 8);
+	extra = pOtherTypeInfoBlks[i].more_bytes = *(WORD*)(ptr + 10 + len);
 	if(extra) {
-	    pOtherTypeInfoBlks[i].extra = heap_alloc(extra);
-	    memcpy(pOtherTypeInfoBlks[i].extra, ptr + 10 + len, extra);
+	    pOtherTypeInfoBlks[i].extra = malloc(extra);
+	    memcpy(pOtherTypeInfoBlks[i].extra, ptr + 12, extra);
 	    len += extra;
 	}
-	pOtherTypeInfoBlks[i].res20 = *(WORD*)(ptr + 10 + len);
-	pOtherTypeInfoBlks[i].helpcontext = *(DWORD*)(ptr + 12 + len);
-	pOtherTypeInfoBlks[i].res26 = *(WORD*)(ptr + 16 + len);
-	memcpy(&pOtherTypeInfoBlks[i].uuid, ptr + 18 + len, sizeof(GUID));
-	pOtherTypeInfoBlks[i].typekind = *(WORD*)(ptr + 18 + sizeof(GUID) + len);
+	pOtherTypeInfoBlks[i].res20 = *(WORD*)(ptr + 12 + len);
+	pOtherTypeInfoBlks[i].helpcontext = *(DWORD*)(ptr + 14 + len);
+	pOtherTypeInfoBlks[i].res26 = *(WORD*)(ptr + 18 + len);
+	memcpy(&pOtherTypeInfoBlks[i].uuid, ptr + 20 + len, sizeof(GUID));
 	len += sizeof(SLTG_OtherTypeInfo);
 	ptr += len;
     }
 
-    /* Get the next DWORD */
-    len = *(DWORD*)ptr;
+    pAfterOTIBlks = ptr;
 
-    hlp_strings = (const BYTE *)ptr + sizeof(DWORD);
-    TRACE("max help string length %#x, help strings length %#x\n",
-        *(WORD *)hlp_strings, *(DWORD *)(hlp_strings + 2));
+    /* Skip this WORD and get the next DWORD */
+    len = *(DWORD*)(pAfterOTIBlks + 2);
 
     /* Now add this to pLibBLk look at what we're pointing at and
        possibly add 0x20, then add 0x216, sprinkle a bit a magic
@@ -4644,7 +4534,7 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
        I'll just follow the links along the BlkEntry chain and read
        them in the order in which they are in the file */
 
-    pTypeLibImpl->typeinfos = heap_alloc_zero(pTypeLibImpl->TypeInfoCount * sizeof(ITypeInfoImpl*));
+    pTypeLibImpl->typeinfos = calloc(pTypeLibImpl->TypeInfoCount, sizeof(ITypeInfoImpl*));
     ppTypeInfoImpl = pTypeLibImpl->typeinfos;
 
     for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
@@ -4657,18 +4547,18 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
 
       if(strcmp(pBlkEntry[order].index_string + (char*)pMagic, pOtherTypeInfoBlks[i].index_name)) {
         FIXME_(typelib)("Index strings don't match\n");
-        heap_free(pOtherTypeInfoBlks);
+        free(pOtherTypeInfoBlks);
         return NULL;
       }
 
       pTIHeader = pBlk;
       if(pTIHeader->magic != SLTG_TIHEADER_MAGIC) {
 	FIXME_(typelib)("TypeInfoHeader magic = %04x\n", pTIHeader->magic);
-       heap_free(pOtherTypeInfoBlks);
+       free(pOtherTypeInfoBlks);
 	return NULL;
       }
-      TRACE_(typelib)("pTIHeader->res06 = %x, pTIHeader->res0e = %x, "
-        "pTIHeader->res16 = %x, pTIHeader->res1e = %x\n",
+      TRACE_(typelib)("pTIHeader->res06 = %lx, pTIHeader->res0e = %lx, "
+        "pTIHeader->res16 = %lx, pTIHeader->res1e = %lx\n",
         pTIHeader->res06, pTIHeader->res0e, pTIHeader->res16, pTIHeader->res1e);
 
       *ppTypeInfoImpl = ITypeInfoImpl_Constructor();
@@ -4676,7 +4566,6 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
       (*ppTypeInfoImpl)->index = i;
       (*ppTypeInfoImpl)->Name = SLTG_ReadName(pNameTable, pOtherTypeInfoBlks[i].name_offs, pTypeLibImpl);
       (*ppTypeInfoImpl)->dwHelpContext = pOtherTypeInfoBlks[i].helpcontext;
-      (*ppTypeInfoImpl)->DocString = decode_string(hlp_strings, pOtherTypeInfoBlks[i].extra, pOtherTypeInfoBlks[i].hlpstr_len, pTypeLibImpl);
       (*ppTypeInfoImpl)->guid = TLB_append_guid(&pTypeLibImpl->guid_list, &pOtherTypeInfoBlks[i].uuid, 2);
       (*ppTypeInfoImpl)->typeattr.typekind = pTIHeader->typekind;
       (*ppTypeInfoImpl)->typeattr.wMajorVerNum = pTIHeader->major_version;
@@ -4709,17 +4598,17 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
       switch(pTIHeader->typekind) {
       case TKIND_ENUM:
 	SLTG_ProcessEnum((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
-                         pTIHeader, pTITail, hlp_strings);
+                         pTIHeader, pTITail);
 	break;
 
       case TKIND_RECORD:
 	SLTG_ProcessRecord((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
-                           pTIHeader, pTITail, hlp_strings);
+                           pTIHeader, pTITail);
 	break;
 
       case TKIND_INTERFACE:
 	SLTG_ProcessInterface((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
-                              pTIHeader, pTITail, hlp_strings);
+                              pTIHeader, pTITail);
 	break;
 
       case TKIND_COCLASS:
@@ -4734,12 +4623,12 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
 
       case TKIND_DISPATCH:
 	SLTG_ProcessDispatch((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
-                             pTIHeader, pTITail, hlp_strings);
+                             pTIHeader, pTITail);
 	break;
 
       case TKIND_MODULE:
 	SLTG_ProcessModule((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
-                           pTIHeader, pTITail, hlp_strings);
+                           pTIHeader, pTITail);
 	break;
 
       default:
@@ -4771,11 +4660,11 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
 
     if(i != pTypeLibImpl->TypeInfoCount) {
       FIXME("Somehow processed %d TypeInfos\n", i);
-      heap_free(pOtherTypeInfoBlks);
+      free(pOtherTypeInfoBlks);
       return NULL;
     }
 
-    heap_free(pOtherTypeInfoBlks);
+    free(pOtherTypeInfoBlks);
     return &pTypeLibImpl->ITypeLib2_iface;
 }
 
@@ -4812,7 +4701,7 @@ static ULONG WINAPI ITypeLib2_fnAddRef( ITypeLib2 *iface)
     ITypeLibImpl *This = impl_from_ITypeLib2(iface);
     ULONG ref = InterlockedIncrement(&This->ref);
 
-    TRACE("(%p) ref=%u\n", This, ref);
+    TRACE("%p, refcount %lu.\n", iface, ref);
 
     return ref;
 }
@@ -4820,9 +4709,12 @@ static ULONG WINAPI ITypeLib2_fnAddRef( ITypeLib2 *iface)
 static ULONG WINAPI ITypeLib2_fnRelease( ITypeLib2 *iface)
 {
     ITypeLibImpl *This = impl_from_ITypeLib2(iface);
-    ULONG ref = InterlockedDecrement(&This->ref);
+    ULONG ref;
 
-    TRACE("(%p) ref=%u\n",This, ref);
+    EnterCriticalSection(&cache_section);
+    ref = InterlockedDecrement(&This->ref);
+
+    TRACE("%p, refcount %lu.\n", iface, ref);
 
     if (!ref)
     {
@@ -4836,38 +4728,36 @@ static ULONG WINAPI ITypeLib2_fnRelease( ITypeLib2 *iface)
       if(This->path)
       {
           TRACE("removing from cache list\n");
-          EnterCriticalSection(&cache_section);
           if(This->entry.next)
               list_remove(&This->entry);
-          LeaveCriticalSection(&cache_section);
-          heap_free(This->path);
+          free(This->path);
       }
       TRACE(" destroying ITypeLib(%p)\n",This);
 
       LIST_FOR_EACH_ENTRY_SAFE(tlbstr, tlbstr_next, &This->string_list, TLBString, entry) {
           list_remove(&tlbstr->entry);
           SysFreeString(tlbstr->str);
-          heap_free(tlbstr);
+          free(tlbstr);
       }
 
       LIST_FOR_EACH_ENTRY_SAFE(tlbstr, tlbstr_next, &This->name_list, TLBString, entry) {
           list_remove(&tlbstr->entry);
           SysFreeString(tlbstr->str);
-          heap_free(tlbstr);
+          free(tlbstr);
       }
 
       LIST_FOR_EACH_ENTRY_SAFE(tlbguid, tlbguid_next, &This->guid_list, TLBGuid, entry) {
           list_remove(&tlbguid->entry);
-          heap_free(tlbguid);
+          free(tlbguid);
       }
 
       TLB_FreeCustData(&This->custdata_list);
 
       for (i = 0; i < This->ctTypeDesc; i++)
           if (This->pTypeDesc[i].vt == VT_CARRAY)
-              heap_free(This->pTypeDesc[i].u.lpadesc);
+              free(This->pTypeDesc[i].lpadesc);
 
-      heap_free(This->pTypeDesc);
+      free(This->pTypeDesc);
 
       LIST_FOR_EACH_ENTRY_SAFE(pImpLib, pImpLibNext, &This->implib_list, TLBImpLib, entry)
       {
@@ -4876,24 +4766,24 @@ static ULONG WINAPI ITypeLib2_fnRelease( ITypeLib2 *iface)
           SysFreeString(pImpLib->name);
 
           list_remove(&pImpLib->entry);
-          heap_free(pImpLib);
+          free(pImpLib);
       }
 
       LIST_FOR_EACH_ENTRY_SAFE(ref_type, ref_type_next, &This->ref_list, TLBRefType, entry)
       {
           list_remove(&ref_type->entry);
-          heap_free(ref_type);
+          free(ref_type);
       }
 
       for (i = 0; i < This->TypeInfoCount; ++i){
-          heap_free(This->typeinfos[i]->tdescAlias);
+          free(This->typeinfos[i]->tdescAlias);
           ITypeInfoImpl_Destroy(This->typeinfos[i]);
       }
-      heap_free(This->typeinfos);
-      heap_free(This);
-      return 0;
+      free(This->typeinfos);
+      free(This);
     }
 
+    LeaveCriticalSection(&cache_section);
     return ref;
 }
 
@@ -4999,7 +4889,7 @@ static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
 
     if (!attr) return E_INVALIDARG;
 
-    *attr = heap_alloc(sizeof(**attr));
+    *attr = malloc(sizeof(**attr));
     if (!*attr) return E_OUTOFMEMORY;
 
     (*attr)->guid = *TLB_get_guid_null(This->guid);
@@ -5138,8 +5028,7 @@ static HRESULT WINAPI ITypeLib2_fnIsName(
     int tic;
     UINT nNameBufLen = (lstrlenW(szNameBuf)+1)*sizeof(WCHAR), fdc, vrc;
 
-    TRACE("(%p)->(%s,%08x,%p)\n", This, debugstr_w(szNameBuf), lHashVal,
-	  pfName);
+    TRACE("%p, %s, %#lx, %p.\n", iface, debugstr_w(szNameBuf), lHashVal, pfName);
 
     *pfName=TRUE;
     for(tic = 0; tic < This->TypeInfoCount; ++tic){
@@ -5188,7 +5077,7 @@ static HRESULT WINAPI ITypeLib2_fnFindName(
     UINT count = 0;
     UINT len;
 
-    TRACE("(%p)->(%s %u %p %p %p)\n", This, debugstr_w(name), hash, ppTInfo, memid, found);
+    TRACE("%p, %s %#lx, %p, %p, %p.\n", iface, debugstr_w(name), hash, ppTInfo, memid, found);
 
     if ((!name && hash == 0) || !ppTInfo || !memid || !found)
         return E_INVALIDARG;
@@ -5213,7 +5102,7 @@ static HRESULT WINAPI ITypeLib2_fnFindName(
             }
         }
 
-        var = TLB_get_vardesc_by_name(pTInfo->vardescs, pTInfo->typeattr.cVars, name);
+        var = TLB_get_vardesc_by_name(pTInfo, name);
         if (var) {
             memid[count] = var->vardesc.memid;
             goto ITypeLib2_fnFindName_exit;
@@ -5243,7 +5132,7 @@ static VOID WINAPI ITypeLib2_fnReleaseTLibAttr(
 {
     ITypeLibImpl *This = impl_from_ITypeLib2(iface);
     TRACE("(%p)->(%p)\n", This, pTLibAttr);
-    heap_free(pTLibAttr);
+    free(pTLibAttr);
 }
 
 /* ITypeLib2::GetCustData
@@ -5309,7 +5198,7 @@ static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
     HRESULT result;
     ITypeInfo *pTInfo;
 
-    FIXME("(%p) index %d lcid %d half implemented stub!\n", This, index, lcid);
+    FIXME("%p, %d, %#lx, partially implemented stub!\n", iface, index, lcid);
 
     /* the help string should be obtained from the helpstringdll,
      * using the _DLLGetDocumentation function, based on the supplied
@@ -5357,11 +5246,12 @@ static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
     return result;
 }
 
-static HRESULT TLB_copy_all_custdata(struct list *custdata_list, CUSTDATA *pCustData)
+static HRESULT TLB_copy_all_custdata(const struct list *custdata_list, CUSTDATA *pCustData)
 {
     TLBCustData *pCData;
     unsigned int ct;
     CUSTDATAITEM *cdi;
+    HRESULT hr = S_OK;
 
     ct = list_count(custdata_list);
 
@@ -5374,11 +5264,13 @@ static HRESULT TLB_copy_all_custdata(struct list *custdata_list, CUSTDATA *pCust
     cdi = pCustData->prgCustData;
     LIST_FOR_EACH_ENTRY(pCData, custdata_list, TLBCustData, entry){
         cdi->guid = *TLB_get_guid_null(pCData->guid);
-        VariantCopy(&cdi->varValue, &pCData->data);
+        VariantInit(&cdi->varValue);
+        hr = VariantCopy(&cdi->varValue, &pCData->data);
+        if(FAILED(hr)) break;
         ++cdi;
     }
 
-    return S_OK;
+    return hr;
 }
 
 
@@ -5452,7 +5344,7 @@ static HRESULT WINAPI ITypeLibComp_fnBind(
     BOOL typemismatch = FALSE;
     int i;
 
-    TRACE("(%p)->(%s, 0x%x, 0x%x, %p, %p, %p)\n", This, debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
+    TRACE("%p, %s, %#lx, %#x, %p, %p, %p.\n", iface, debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
 
     *pDescKind = DESCKIND_NONE;
     pBindPtr->lptcomp = NULL;
@@ -5529,7 +5421,7 @@ static HRESULT WINAPI ITypeLibComp_fnBind(
                     VAR_STATIC  /* varkind */
                 };
 
-                tdesc_appobject.u.hreftype = pTypeInfo->hreftype;
+                tdesc_appobject.hreftype = pTypeInfo->hreftype;
                 tdesc_appobject.vt = VT_USERDEFINED;
 
                 TRACE("found in implicit app object: %s\n", debugstr_w(szName));
@@ -5588,12 +5480,12 @@ static HRESULT WINAPI ITypeLibComp_fnBindType(
     ITypeLibImpl *This = impl_from_ITypeComp(iface);
     ITypeInfoImpl *info;
 
-    TRACE("(%s, %x, %p, %p)\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
+    TRACE("%p, %s, %#lx, %p, %p.\n", iface, debugstr_w(szName), lHash, ppTInfo, ppTComp);
 
     if(!szName || !ppTInfo || !ppTComp)
         return E_INVALIDARG;
 
-    info = TLB_get_typeinfo_by_name(This->typeinfos, This->TypeInfoCount, szName);
+    info = TLB_get_typeinfo_by_name(This, szName);
     if(!info){
         *ppTInfo = NULL;
         *ppTComp = NULL;
@@ -5624,7 +5516,7 @@ static ITypeInfoImpl* ITypeInfoImpl_Constructor(void)
 {
     ITypeInfoImpl *pTypeInfoImpl;
 
-    pTypeInfoImpl = heap_alloc_zero(sizeof(ITypeInfoImpl));
+    pTypeInfoImpl = calloc(1, sizeof(ITypeInfoImpl));
     if (pTypeInfoImpl)
     {
       pTypeInfoImpl->ITypeInfo2_iface.lpVtbl = &tinfvt;
@@ -5672,14 +5564,12 @@ static HRESULT WINAPI ITypeInfo_fnQueryInterface(
     return E_NOINTERFACE;
 }
 
-/* ITypeInfo::AddRef
- */
 static ULONG WINAPI ITypeInfo_fnAddRef( ITypeInfo2 *iface)
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
     ULONG ref = InterlockedIncrement(&This->ref);
 
-    TRACE("(%p)->ref is %u\n",This, ref);
+    TRACE("%p, refcount %lu.\n", iface, ref);
 
     if (ref == 1 /* incremented from 0 */)
         ITypeLib2_AddRef(&This->pTypeLib->ITypeLib2_iface);
@@ -5687,6 +5577,22 @@ static ULONG WINAPI ITypeInfo_fnAddRef( ITypeInfo2 *iface)
     return ref;
 }
 
+static void typeinfo_release_funcdesc(TLBFuncDesc *func)
+{
+    unsigned int i;
+
+    for (i = 0; i < func->funcdesc.cParams; ++i)
+    {
+        ELEMDESC *elemdesc = &func->funcdesc.lprgelemdescParam[i];
+        if (elemdesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
+            VariantClear(&elemdesc->paramdesc.pparamdescex->varDefaultValue);
+        TLB_FreeCustData(&func->pParamDesc[i].custdata_list);
+    }
+    free(func->funcdesc.lprgelemdescParam);
+    free(func->pParamDesc);
+    TLB_FreeCustData(&func->custdata_list);
+}
+
 static void ITypeInfoImpl_Destroy(ITypeInfoImpl *This)
 {
     UINT i;
@@ -5695,20 +5601,9 @@ static void ITypeInfoImpl_Destroy(ITypeInfoImpl *This)
 
     for (i = 0; i < This->typeattr.cFuncs; ++i)
     {
-        int j;
-        TLBFuncDesc *pFInfo = &This->funcdescs[i];
-        for(j = 0; j < pFInfo->funcdesc.cParams; j++)
-        {
-            ELEMDESC *elemdesc = &pFInfo->funcdesc.lprgelemdescParam[j];
-            if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
-                VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
-            TLB_FreeCustData(&pFInfo->pParamDesc[j].custdata_list);
-        }
-        heap_free(pFInfo->funcdesc.lprgelemdescParam);
-        heap_free(pFInfo->pParamDesc);
-        TLB_FreeCustData(&pFInfo->custdata_list);
+        typeinfo_release_funcdesc(&This->funcdescs[i]);
     }
-    heap_free(This->funcdescs);
+    free(This->funcdescs);
 
     for(i = 0; i < This->typeattr.cVars; ++i)
     {
@@ -5716,53 +5611,45 @@ static void ITypeInfoImpl_Destroy(ITypeInfoImpl *This)
         if (pVInfo->vardesc_create) {
             TLB_FreeVarDesc(pVInfo->vardesc_create);
         } else if (pVInfo->vardesc.varkind == VAR_CONST) {
-            VariantClear(pVInfo->vardesc.u.lpvarValue);
-            heap_free(pVInfo->vardesc.u.lpvarValue);
+            VariantClear(pVInfo->vardesc.lpvarValue);
+            free(pVInfo->vardesc.lpvarValue);
         }
         TLB_FreeCustData(&pVInfo->custdata_list);
     }
-    heap_free(This->vardescs);
+    free(This->vardescs);
 
     if(This->impltypes){
         for (i = 0; i < This->typeattr.cImplTypes; ++i){
             TLBImplType *pImpl = &This->impltypes[i];
             TLB_FreeCustData(&pImpl->custdata_list);
         }
-        heap_free(This->impltypes);
+        free(This->impltypes);
     }
 
     TLB_FreeCustData(&This->custdata_list);
 
-    heap_free(This);
+    free(This);
 }
 
-/* ITypeInfo::Release
- */
 static ULONG WINAPI ITypeInfo_fnRelease(ITypeInfo2 *iface)
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
     ULONG ref = InterlockedDecrement(&This->ref);
 
-    TRACE("(%p)->(%u)\n",This, ref);
+    TRACE("%p, refcount %lu.\n", iface, ref);
 
     if (!ref)
     {
         BOOL not_attached_to_typelib = This->not_attached_to_typelib;
         ITypeLib2_Release(&This->pTypeLib->ITypeLib2_iface);
         if (not_attached_to_typelib)
-            heap_free(This);
+            free(This);
         /* otherwise This will be freed when typelib is freed */
     }
 
     return ref;
 }
 
-/* ITypeInfo::GetTypeAttr
- *
- * Retrieves a TYPEATTR structure that contains the attributes of the type
- * description.
- *
- */
 static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( ITypeInfo2 *iface,
         LPTYPEATTR  *ppTypeAttr)
 {
@@ -5775,7 +5662,7 @@ static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( ITypeInfo2 *iface,
     if (This->typeattr.typekind == TKIND_ALIAS && This->tdescAlias)
         size += TLB_SizeTypeDesc(This->tdescAlias, FALSE);
 
-    *ppTypeAttr = heap_alloc(size);
+    *ppTypeAttr = malloc(size);
     if (!*ppTypeAttr)
         return E_OUTOFMEMORY;
 
@@ -5816,8 +5703,8 @@ static HRESULT WINAPI ITypeInfo_fnGetTypeComp( ITypeInfo2 *iface,
 static SIZE_T TLB_SizeElemDesc( const ELEMDESC *elemdesc )
 {
     SIZE_T size = TLB_SizeTypeDesc(&elemdesc->tdesc, FALSE);
-    if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
-        size += sizeof(*elemdesc->u.paramdesc.pparamdescex);
+    if (elemdesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
+        size += sizeof(*elemdesc->paramdesc.pparamdescex);
     return size;
 }
 
@@ -5825,10 +5712,10 @@ static HRESULT TLB_CopyElemDesc( const ELEMDESC *src, ELEMDESC *dest, char **buf
 {
     *dest = *src;
     *buffer = TLB_CopyTypeDesc(&dest->tdesc, &src->tdesc, *buffer);
-    if (src->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
+    if (src->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
     {
-        const PARAMDESCEX *pparamdescex_src = src->u.paramdesc.pparamdescex;
-        PARAMDESCEX *pparamdescex_dest = dest->u.paramdesc.pparamdescex = (PARAMDESCEX *)*buffer;
+        const PARAMDESCEX *pparamdescex_src = src->paramdesc.pparamdescex;
+        PARAMDESCEX *pparamdescex_dest = dest->paramdesc.pparamdescex = (PARAMDESCEX *)*buffer;
         *buffer += sizeof(PARAMDESCEX);
         *pparamdescex_dest = *pparamdescex_src;
         pparamdescex_dest->cBytes = sizeof(PARAMDESCEX);
@@ -5837,16 +5724,7 @@ static HRESULT TLB_CopyElemDesc( const ELEMDESC *src, ELEMDESC *dest, char **buf
                            (VARIANTARG *)&pparamdescex_src->varDefaultValue);
     }
     else
-        dest->u.paramdesc.pparamdescex = NULL;
-    return S_OK;
-}
-
-static HRESULT TLB_SanitizeBSTR(BSTR str)
-{
-    UINT len = SysStringLen(str), i;
-    for (i = 0; i < len; ++i)
-        if (str[i] > 0x7f)
-            str[i] = '?';
+        dest->paramdesc.pparamdescex = NULL;
     return S_OK;
 }
 
@@ -5856,16 +5734,14 @@ static HRESULT TLB_SanitizeVariant(VARIANT *var)
         return VariantChangeType(var, var, 0, VT_I4);
     else if (V_VT(var) == VT_UINT)
         return VariantChangeType(var, var, 0, VT_UI4);
-    else if (V_VT(var) == VT_BSTR)
-        return TLB_SanitizeBSTR(V_BSTR(var));
 
     return S_OK;
 }
 
 static void TLB_FreeElemDesc( ELEMDESC *elemdesc )
 {
-    if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
-        VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
+    if (elemdesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
+        VariantClear(&elemdesc->paramdesc.pparamdescex->varDefaultValue);
 }
 
 static HRESULT TLB_AllocAndInitFuncDesc( const FUNCDESC *src, FUNCDESC **dest_ptr, BOOL dispinterface )
@@ -5929,13 +5805,15 @@ static HRESULT TLB_AllocAndInitFuncDesc( const FUNCDESC *src, FUNCDESC **dest_pt
     } else
         dest->lprgelemdescParam = NULL;
 
-    /* special treatment for dispinterfaces: this makes functions appear
-     * to return their [retval] value when it is really returning an
-     * HRESULT */
-    if (dispinterface && dest->elemdescFunc.tdesc.vt == VT_HRESULT)
+    /* special treatment for dispinterface FUNCDESC based on an interface FUNCDESC.
+     * This accounts for several arguments that are separate in the signature of
+     * IDispatch::Invoke, rather than passed in DISPPARAMS::rgvarg[] */
+    if (dispinterface && (src->funckind != FUNC_DISPATCH))
     {
+        /* functions that have a [retval] parameter return this value into pVarResult.
+         * [retval] is always the last parameter (if present) */
         if (dest->cParams &&
-            (dest->lprgelemdescParam[dest->cParams - 1].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
+            (dest->lprgelemdescParam[dest->cParams - 1].paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
         {
             ELEMDESC *elemdesc = &dest->lprgelemdescParam[dest->cParams - 1];
             if (elemdesc->tdesc.vt != VT_PTR)
@@ -5946,19 +5824,23 @@ static HRESULT TLB_AllocAndInitFuncDesc( const FUNCDESC *src, FUNCDESC **dest_pt
                 return E_UNEXPECTED;
             }
 
-            /* copy last parameter to the return value. we are using a flat
-             * buffer so there is no danger of leaking memory in
-             * elemdescFunc */
-            dest->elemdescFunc.tdesc = *elemdesc->tdesc.u.lptdesc;
+            /* the type pointed to by this [retval] becomes elemdescFunc,
+             * i.e. the function signature's return type.
+             * We are using a flat buffer so there is no danger of leaking memory */
+            dest->elemdescFunc.tdesc = *elemdesc->tdesc.lptdesc;
 
             /* remove the last parameter */
             dest->cParams--;
         }
-        else
-            /* otherwise this function is made to appear to have no return
-             * value */
+        else if (dest->elemdescFunc.tdesc.vt == VT_HRESULT)
+            /* Even if not otherwise replaced HRESULT is returned in pExcepInfo->scode,
+             * not pVarResult.  So the function signature should show no return value. */
             dest->elemdescFunc.tdesc.vt = VT_VOID;
 
+        /* The now-last (except [retval], removed above) parameter might be labeled [lcid].
+         * If so it will be supplied from Invoke(lcid), so also not via DISPPARAMS::rgvarg */
+        if (dest->cParams && (dest->lprgelemdescParam[dest->cParams - 1].paramdesc.wParamFlags & PARAMFLAG_FLCID))
+            dest->cParams--;
     }
 
     *dest_ptr = dest;
@@ -5969,25 +5851,14 @@ static void TLB_FreeVarDesc(VARDESC *var_desc)
 {
     TLB_FreeElemDesc(&var_desc->elemdescVar);
     if (var_desc->varkind == VAR_CONST)
-        VariantClear(var_desc->u.lpvarValue);
+        VariantClear(var_desc->lpvarValue);
     SysFreeString((BSTR)var_desc);
 }
 
-HRESULT ITypeInfoImpl_GetInternalFuncDesc( ITypeInfo *iface, UINT index, const FUNCDESC **ppFuncDesc )
-{
-    ITypeInfoImpl *This = impl_from_ITypeInfo(iface);
-
-    if (index >= This->typeattr.cFuncs)
-        return TYPE_E_ELEMENTNOTFOUND;
-
-    *ppFuncDesc = &This->funcdescs[index].funcdesc;
-    return S_OK;
-}
-
 /* internal function to make the inherited interfaces' methods appear
  * part of the interface */
 static HRESULT ITypeInfoImpl_GetInternalDispatchFuncDesc( ITypeInfo *iface,
-    UINT index, const FUNCDESC **ppFuncDesc, UINT *funcs, UINT *hrefoffset)
+    UINT index, const TLBFuncDesc **ppFuncDesc, UINT *funcs, UINT *hrefoffset)
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo(iface);
     HRESULT hr;
@@ -6025,8 +5896,27 @@ static HRESULT ITypeInfoImpl_GetInternalDispatchFuncDesc( ITypeInfo *iface,
     
     if (index < implemented_funcs)
         return E_INVALIDARG;
-    return ITypeInfoImpl_GetInternalFuncDesc(iface, index - implemented_funcs,
-                                             ppFuncDesc);
+    index -= implemented_funcs;
+
+    if (index >= This->typeattr.cFuncs)
+        return TYPE_E_ELEMENTNOTFOUND;
+
+    *ppFuncDesc = &This->funcdescs[index];
+    return S_OK;
+}
+
+static HRESULT ITypeInfoImpl_GetInternalFuncDesc( ITypeInfo *iface, UINT index, const TLBFuncDesc **func_desc, UINT *hrefoffset )
+{
+    ITypeInfoImpl *This = impl_from_ITypeInfo(iface);
+
+    if (This->typeattr.typekind == TKIND_DISPATCH)
+        return ITypeInfoImpl_GetInternalDispatchFuncDesc(iface, index, func_desc, NULL, hrefoffset);
+
+    if (index >= This->typeattr.cFuncs)
+        return TYPE_E_ELEMENTNOTFOUND;
+
+    *func_desc = &This->funcdescs[index];
+    return S_OK;
 }
 
 static inline void ITypeInfoImpl_ElemDescAddHrefOffset( LPELEMDESC pElemDesc, UINT hrefoffset)
@@ -6037,14 +5927,14 @@ static inline void ITypeInfoImpl_ElemDescAddHrefOffset( LPELEMDESC pElemDesc, UI
         switch (pTypeDesc->vt)
         {
         case VT_USERDEFINED:
-            pTypeDesc->u.hreftype += hrefoffset;
+            pTypeDesc->hreftype += hrefoffset;
             return;
         case VT_PTR:
         case VT_SAFEARRAY:
-            pTypeDesc = pTypeDesc->u.lptdesc;
+            pTypeDesc = pTypeDesc->lptdesc;
             break;
         case VT_CARRAY:
-            pTypeDesc = &pTypeDesc->u.lpadesc->tdescElem;
+            pTypeDesc = &pTypeDesc->lpadesc->tdescElem;
             break;
         default:
             return;
@@ -6070,7 +5960,7 @@ static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( ITypeInfo2 *iface, UINT index,
         LPFUNCDESC  *ppFuncDesc)
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
-    const FUNCDESC *internal_funcdesc;
+    const TLBFuncDesc *internal_funcdesc;
     HRESULT hr;
     UINT hrefoffset = 0;
 
@@ -6082,13 +5972,8 @@ static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( ITypeInfo2 *iface, UINT index,
     if (This->needs_layout)
         ICreateTypeInfo2_LayOut(&This->ICreateTypeInfo2_iface);
 
-    if (This->typeattr.typekind == TKIND_DISPATCH)
-        hr = ITypeInfoImpl_GetInternalDispatchFuncDesc((ITypeInfo *)iface, index,
-                                                       &internal_funcdesc, NULL,
-                                                       &hrefoffset);
-    else
-        hr = ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo *)iface, index,
-                                               &internal_funcdesc);
+    hr = ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo *)iface, index,
+                                           &internal_funcdesc, &hrefoffset);
     if (FAILED(hr))
     {
         WARN("description for function %d not found\n", index);
@@ -6096,14 +5981,14 @@ static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( ITypeInfo2 *iface, UINT index,
     }
 
     hr = TLB_AllocAndInitFuncDesc(
-        internal_funcdesc,
+        &internal_funcdesc->funcdesc,
         ppFuncDesc,
         This->typeattr.typekind == TKIND_DISPATCH);
 
     if ((This->typeattr.typekind == TKIND_DISPATCH) && hrefoffset)
         ITypeInfoImpl_FuncDescAddHrefOffset(*ppFuncDesc, hrefoffset);
 
-    TRACE("-- 0x%08x\n", hr);
+    TRACE("-- %#lx.\n", hr);
     return hr;
 }
 
@@ -6137,11 +6022,11 @@ static HRESULT TLB_AllocAndInitVarDesc( const VARDESC *src, VARDESC **dest_ptr )
     {
         HRESULT hr;
 
-        dest->u.lpvarValue = (VARIANT *)buffer;
-        *dest->u.lpvarValue = *src->u.lpvarValue;
+        dest->lpvarValue = (VARIANT *)buffer;
+        *dest->lpvarValue = *src->lpvarValue;
         buffer += sizeof(VARIANT);
-        VariantInit(dest->u.lpvarValue);
-        hr = VariantCopy(dest->u.lpvarValue, src->u.lpvarValue);
+        VariantInit(dest->lpvarValue);
+        hr = VariantCopy(dest->lpvarValue, src->lpvarValue);
         if (FAILED(hr))
         {
             SysFreeString((BSTR)dest);
@@ -6152,7 +6037,7 @@ static HRESULT TLB_AllocAndInitVarDesc( const VARDESC *src, VARDESC **dest_ptr )
     if (FAILED(hr))
     {
         if (src->varkind == VAR_CONST)
-            VariantClear(dest->u.lpvarValue);
+            VariantClear(dest->lpvarValue);
         SysFreeString((BSTR)dest);
         return hr;
     }
@@ -6182,6 +6067,80 @@ static HRESULT WINAPI ITypeInfo_fnGetVarDesc( ITypeInfo2 *iface, UINT index,
     return TLB_AllocAndInitVarDesc(&pVDesc->vardesc, ppVarDesc);
 }
 
+/* internal function to make the inherited interfaces' methods appear
+ * part of the interface, remembering if the top-level was dispinterface */
+static HRESULT typeinfo_getnames( ITypeInfo *iface, MEMBERID memid, BSTR *names,
+                                  UINT max_names, UINT *num_names, BOOL dispinterface)
+{
+    ITypeInfoImpl *This = impl_from_ITypeInfo(iface);
+    const TLBFuncDesc *func_desc;
+    const TLBVarDesc *var_desc;
+    int i;
+
+    *num_names = 0;
+
+    func_desc = TLB_get_funcdesc_by_memberid(This, memid);
+    if (func_desc)
+    {
+        UINT params = func_desc->funcdesc.cParams;
+        if (!max_names || !func_desc->Name)
+            return S_OK;
+
+        *names = SysAllocString(TLB_get_bstr(func_desc->Name));
+        ++(*num_names);
+
+        if (dispinterface && (func_desc->funcdesc.funckind != FUNC_DISPATCH))
+        {
+            /* match the rewriting of special trailing parameters in TLB_AllocAndInitFuncDesc */
+            if ((params > 0) && (func_desc->funcdesc.lprgelemdescParam[params - 1].paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
+                --params; /* Invoke(pVarResult) supplies the [retval] parameter, so it's hidden from DISPPARAMS */
+            if ((params > 0) && (func_desc->funcdesc.lprgelemdescParam[params - 1].paramdesc.wParamFlags & PARAMFLAG_FLCID))
+                --params; /* Invoke(lcid) supplies the [lcid] parameter, so it's hidden from DISPPARAMS */
+        }
+
+        for (i = 0; i < params; i++)
+        {
+            if (*num_names >= max_names || !func_desc->pParamDesc[i].Name)
+                return S_OK;
+            names[*num_names] = SysAllocString(TLB_get_bstr(func_desc->pParamDesc[i].Name));
+            ++(*num_names);
+        }
+        return S_OK;
+    }
+
+    var_desc = TLB_get_vardesc_by_memberid(This, memid);
+    if (var_desc)
+    {
+        *names = SysAllocString(TLB_get_bstr(var_desc->Name));
+        *num_names = 1;
+    }
+    else
+    {
+        if (This->impltypes &&
+            (This->typeattr.typekind == TKIND_INTERFACE || This->typeattr.typekind == TKIND_DISPATCH))
+        {
+            /* recursive search */
+            ITypeInfo *parent;
+            HRESULT result;
+            result = ITypeInfo_GetRefTypeInfo(iface, This->impltypes[0].hRef, &parent);
+            if (SUCCEEDED(result))
+            {
+                result = typeinfo_getnames(parent, memid, names, max_names, num_names, dispinterface);
+                ITypeInfo_Release(parent);
+                return result;
+            }
+            WARN("Could not search inherited interface!\n");
+        }
+        else
+	{
+            WARN("no names found\n");
+	}
+        *num_names = 0;
+        return TYPE_E_ELEMENTNOTFOUND;
+    }
+    return S_OK;
+}
+
 /* ITypeInfo_GetNames
  *
  * Retrieves the variable with the specified member ID (or the name of the
@@ -6189,70 +6148,18 @@ static HRESULT WINAPI ITypeInfo_fnGetVarDesc( ITypeInfo2 *iface, UINT index,
  * function ID.
  */
 static HRESULT WINAPI ITypeInfo_fnGetNames( ITypeInfo2 *iface, MEMBERID memid,
-        BSTR  *rgBstrNames, UINT cMaxNames, UINT  *pcNames)
+                                            BSTR *names, UINT max_names, UINT *num_names)
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
-    const TLBFuncDesc *pFDesc;
-    const TLBVarDesc *pVDesc;
-    int i;
-    TRACE("(%p) memid=0x%08x Maxname=%d\n", This, memid, cMaxNames);
 
-    if(!rgBstrNames)
-        return E_INVALIDARG;
+    TRACE("%p, %#lx, %p, %d, %p\n", iface, memid, names, max_names, num_names);
 
-    *pcNames = 0;
+    if (!names) return E_INVALIDARG;
 
-    pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->typeattr.cFuncs, memid);
-    if(pFDesc)
-    {
-        if(!cMaxNames || !pFDesc->Name)
-            return S_OK;
-
-        *rgBstrNames = SysAllocString(TLB_get_bstr(pFDesc->Name));
-        ++(*pcNames);
-
-        for(i = 0; i < pFDesc->funcdesc.cParams; ++i){
-            if(*pcNames >= cMaxNames || !pFDesc->pParamDesc[i].Name)
-                return S_OK;
-            rgBstrNames[*pcNames] = SysAllocString(TLB_get_bstr(pFDesc->pParamDesc[i].Name));
-            ++(*pcNames);
-        }
-        return S_OK;
-    }
-
-    pVDesc = TLB_get_vardesc_by_memberid(This->vardescs, This->typeattr.cVars, memid);
-    if(pVDesc)
-    {
-      *rgBstrNames=SysAllocString(TLB_get_bstr(pVDesc->Name));
-      *pcNames=1;
-    }
-    else
-    {
-        if(This->impltypes &&
-	   (This->typeattr.typekind == TKIND_INTERFACE || This->typeattr.typekind == TKIND_DISPATCH)) {
-          /* recursive search */
-          ITypeInfo *pTInfo;
-          HRESULT result;
-          result = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
-          if(SUCCEEDED(result))
-	  {
-            result=ITypeInfo_GetNames(pTInfo, memid, rgBstrNames, cMaxNames, pcNames);
-            ITypeInfo_Release(pTInfo);
-            return result;
-          }
-          WARN("Could not search inherited interface!\n");
-        }
-        else
-	{
-          WARN("no names found\n");
-	}
-        *pcNames=0;
-        return TYPE_E_ELEMENTNOTFOUND;
-    }
-    return S_OK;
+    return typeinfo_getnames((ITypeInfo *)iface, memid, names, max_names, num_names,
+                             This->typeattr.typekind == TKIND_DISPATCH);
 }
 
-
 /* ITypeInfo::GetRefTypeOfImplType
  *
  * If a type description describes a COM class, it retrieves the type
@@ -6306,9 +6213,9 @@ static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType(
     if(TRACE_ON(ole))
     {
         if(SUCCEEDED(hr))
-            TRACE("SUCCESS -- hRef = 0x%08x\n", *pRefType );
+            TRACE("SUCCESS -- hRef %#lx.\n", *pRefType );
         else
-            TRACE("FAILURE -- hresult = 0x%08x\n", hr);
+            TRACE("FAILURE -- hresult %#lx.\n", hr);
     }
 
     return hr;
@@ -6354,8 +6261,7 @@ static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( ITypeInfo2 *iface,
     HRESULT ret=S_OK;
     UINT i, fdc;
 
-    TRACE("(%p) Name %s cNames %d\n", This, debugstr_w(*rgszNames),
-            cNames);
+    TRACE("%p, %s, %d.\n", iface, debugstr_w(*rgszNames), cNames);
 
     /* init out parameters in case of failure */
     for (i = 0; i < cNames; i++)
@@ -6375,11 +6281,11 @@ static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( ITypeInfo2 *iface,
                 else
                    ret=DISP_E_UNKNOWNNAME;
             };
-            TRACE("-- 0x%08x\n", ret);
+            TRACE("-- %#lx.\n", ret);
             return ret;
         }
     }
-    pVDesc = TLB_get_vardesc_by_name(This->vardescs, This->typeattr.cVars, *rgszNames);
+    pVDesc = TLB_get_vardesc_by_name(This, *rgszNames);
     if(pVDesc){
         if(cNames)
             *pMemId = pVDesc->vardesc.memid;
@@ -6406,42 +6312,6 @@ static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( ITypeInfo2 *iface,
 
 extern LONGLONG call_method( void *func, int nb_args, const DWORD *args, int *stack_offset );
 extern double call_double_method( void *func, int nb_args, const DWORD *args, int *stack_offset );
-__ASM_GLOBAL_FUNC( call_method,
-                   "pushl %ebp\n\t"
-                   __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
-                   __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
-                   "movl %esp,%ebp\n\t"
-                   __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
-                   "pushl %esi\n\t"
-                  __ASM_CFI(".cfi_rel_offset %esi,-4\n\t")
-                   "pushl %edi\n\t"
-                  __ASM_CFI(".cfi_rel_offset %edi,-8\n\t")
-                   "movl 12(%ebp),%edx\n\t"
-                   "movl %esp,%edi\n\t"
-                   "shll $2,%edx\n\t"
-                   "jz 1f\n\t"
-                   "subl %edx,%edi\n\t"
-                   "andl $~15,%edi\n\t"
-                   "movl %edi,%esp\n\t"
-                   "movl 12(%ebp),%ecx\n\t"
-                   "movl 16(%ebp),%esi\n\t"
-                   "cld\n\t"
-                   "rep; movsl\n"
-                   "1:\tcall *8(%ebp)\n\t"
-                   "subl %esp,%edi\n\t"
-                   "movl 20(%ebp),%ecx\n\t"
-                   "movl %edi,(%ecx)\n\t"
-                   "leal -8(%ebp),%esp\n\t"
-                   "popl %edi\n\t"
-                   __ASM_CFI(".cfi_same_value %edi\n\t")
-                   "popl %esi\n\t"
-                   __ASM_CFI(".cfi_same_value %esi\n\t")
-                   "popl %ebp\n\t"
-                   __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
-                   __ASM_CFI(".cfi_same_value %ebp\n\t")
-                   "ret" )
-__ASM_GLOBAL_FUNC( call_double_method,
-                   "jmp " __ASM_NAME("call_method") )
 
 HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn,
                              UINT cActuals, VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult )
@@ -6451,7 +6321,7 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
     UINT i;
     DWORD *args;
 
-    TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
+    TRACE("(%p, %Id, %d, %d, %d, %p, %p, %p (vt=%d))\n",
         pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg,
         pvargResult, V_VT(pvargResult));
 
@@ -6462,7 +6332,7 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
     }
 
     /* maximum size for an argument is sizeof(VARIANT) */
-    args = heap_alloc(sizeof(VARIANT) * cActuals + sizeof(DWORD) * 2 );
+    args = malloc( sizeof(VARIANT) * cActuals + sizeof(DWORD) * 2 );
 
     if (pvInstance)
     {
@@ -6480,7 +6350,7 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
         break;
     case VT_HRESULT:
         WARN("invalid return type %u\n", vtReturn);
-        heap_free( args );
+        free( args );
         return E_INVALIDARG;
     default:
         break;
@@ -6540,7 +6410,7 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
         V_UI4(pvargResult) = call_method( func, argspos, args, &stack_offset );
         break;
     }
-    heap_free( args );
+    free( args );
     if (stack_offset && cc == CC_STDCALL)
     {
         WARN( "stack pointer off by %d\n", stack_offset );
@@ -6555,52 +6425,6 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
 
 extern DWORD_PTR CDECL call_method( void *func, int nb_args, const DWORD_PTR *args );
 extern double CDECL call_double_method( void *func, int nb_args, const DWORD_PTR *args );
-__ASM_GLOBAL_FUNC( call_method,
-                   "pushq %rbp\n\t"
-                   __ASM_SEH(".seh_pushreg %rbp\n\t")
-                   __ASM_CFI(".cfi_adjust_cfa_offset 8\n\t")
-                   __ASM_CFI(".cfi_rel_offset %rbp,0\n\t")
-                   "movq %rsp,%rbp\n\t"
-                   __ASM_SEH(".seh_setframe %rbp,0\n\t")
-                   __ASM_CFI(".cfi_def_cfa_register %rbp\n\t")
-                   "pushq %rsi\n\t"
-                   __ASM_SEH(".seh_pushreg %rsi\n\t")
-                   __ASM_CFI(".cfi_rel_offset %rsi,-8\n\t")
-                   "pushq %rdi\n\t"
-                   __ASM_SEH(".seh_pushreg %rdi\n\t")
-                   __ASM_CFI(".cfi_rel_offset %rdi,-16\n\t")
-                   __ASM_SEH(".seh_endprologue\n\t")
-                   "movq %rcx,%rax\n\t"
-                   "movq $4,%rcx\n\t"
-                   "cmp %rcx,%rdx\n\t"
-                   "cmovgq %rdx,%rcx\n\t"
-                   "leaq 0(,%rcx,8),%rdx\n\t"
-                   "subq %rdx,%rsp\n\t"
-                   "andq $~15,%rsp\n\t"
-                   "movq %rsp,%rdi\n\t"
-                   "movq %r8,%rsi\n\t"
-                   "rep; movsq\n\t"
-                   "movq 0(%rsp),%rcx\n\t"
-                   "movq 8(%rsp),%rdx\n\t"
-                   "movq 16(%rsp),%r8\n\t"
-                   "movq 24(%rsp),%r9\n\t"
-                   "movq 0(%rsp),%xmm0\n\t"
-                   "movq 8(%rsp),%xmm1\n\t"
-                   "movq 16(%rsp),%xmm2\n\t"
-                   "movq 24(%rsp),%xmm3\n\t"
-                   "callq *%rax\n\t"
-                   "leaq -16(%rbp),%rsp\n\t"
-                   "popq %rdi\n\t"
-                   __ASM_CFI(".cfi_same_value %rdi\n\t")
-                   "popq %rsi\n\t"
-                   __ASM_CFI(".cfi_same_value %rsi\n\t")
-                   __ASM_CFI(".cfi_def_cfa_register %rsp\n\t")
-                   "popq %rbp\n\t"
-                   __ASM_CFI(".cfi_adjust_cfa_offset -8\n\t")
-                   __ASM_CFI(".cfi_same_value %rbp\n\t")
-                   "ret")
-__ASM_GLOBAL_FUNC( call_double_method,
-                   "jmp " __ASM_NAME("call_method") )
 
 HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn,
                              UINT cActuals, VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult )
@@ -6610,7 +6434,7 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
     DWORD_PTR *args;
     void *func;
 
-    TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
+    TRACE("%p, %Id, %d, %d, %d, %p, %p, %p (vt=%d).\n",
           pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg,
           pvargResult, V_VT(pvargResult));
 
@@ -6621,7 +6445,7 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
     }
 
     /* maximum size for an argument is sizeof(DWORD_PTR) */
-    args = heap_alloc( sizeof(DWORD_PTR) * (cActuals + 2) );
+    args = malloc( sizeof(DWORD_PTR) * (cActuals + 2) );
 
     if (pvInstance)
     {
@@ -6639,7 +6463,7 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
         break;
     case VT_HRESULT:
         WARN("invalid return type %u\n", vtReturn);
-        heap_free( args );
+        free( args );
         return E_INVALIDARG;
     default:
         break;
@@ -6682,7 +6506,7 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
         V_UI8(pvargResult) = call_method( func, argspos, args );
         break;
     }
-    heap_free( args );
+    free( args );
     if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn;
     TRACE("retval: %s\n", debugstr_variant(pvargResult));
     return S_OK;
@@ -6693,40 +6517,6 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
 extern LONGLONG CDECL call_method( void *func, int nb_stk_args, const DWORD *stk_args, const DWORD *reg_args );
 extern float CDECL call_float_method( void *func, int nb_stk_args, const DWORD *stk_args, const DWORD *reg_args );
 extern double CDECL call_double_method( void *func, int nb_stk_args, const DWORD *stk_args, const DWORD *reg_args );
-__ASM_GLOBAL_FUNC( call_method,
-                    /* r0 = *func
-                     * r1 = nb_stk_args
-                     * r2 = *stk_args (pointer to 'nb_stk_args' DWORD values to push on stack)
-                     * r3 = *reg_args (pointer to 8, 64-bit d0-d7 (double) values OR as 16, 32-bit s0-s15 (float) values, followed by 4, 32-bit (DWORD) r0-r3 values)
-                     */
-
-                    "push {fp, lr}\n\t"             /* Save frame pointer and return address (stack still aligned to 8 bytes) */
-                    "mov fp, sp\n\t"                /* Save stack pointer as our frame for cleaning the stack on return */
-
-                    "lsls r1, r1, #2\n\t"           /* r1 = nb_stk_args * sizeof(DWORD) */
-                    "beq 1f\n\t"                    /* Skip allocation if no stack args */
-                    "add r2, r2, r1\n"              /* Calculate ending address of incoming stack data */
-                    "2:\tldr ip, [r2, #-4]!\n\t"    /* Get next value */
-                    "str ip, [sp, #-4]!\n\t"        /* Push it on the stack */
-                    "subs r1, r1, #4\n\t"           /* Decrement count */
-                    "bgt 2b\n\t"                    /* Loop till done */
-
-                    "1:\n\t"
-#ifndef __SOFTFP__
-                    "vldm r3!, {s0-s15}\n\t"        /* Load the s0-s15/d0-d7 arguments */
-#endif
-                    "mov ip, r0\n\t"                /* Save the function call address to ip before we nuke r0 with arguments to pass */
-                    "ldm r3, {r0-r3}\n\t"           /* Load the r0-r3 arguments */
-
-                    "blx ip\n\t"                    /* Call the target function */
-
-                    "mov sp, fp\n\t"                /* Clean the stack using fp */
-                    "pop {fp, pc}\n\t"              /* Restore fp and return */
-                )
-__ASM_GLOBAL_FUNC( call_float_method,
-                   "b " __ASM_NAME("call_method") )
-__ASM_GLOBAL_FUNC( call_double_method,
-                   "b " __ASM_NAME("call_method") )
 
 HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn,
                              UINT cActuals, VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult )
@@ -6736,21 +6526,17 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
     UINT i;
     DWORD *args;
     struct {
-#ifndef __SOFTFP__
         union {
             float s[16];
             double d[8];
         } sd;
-#endif
         DWORD r[4];
     } regs;
     int rcount;     /* 32-bit register index count */
-#ifndef __SOFTFP__
     int scount = 0; /* single-precision float register index count */
     int dcount = 0; /* double-precision float register index count */
-#endif
 
-    TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
+    TRACE("(%p, %Id, %d, %d, %d, %p, %p, %p (vt=%d))\n",
         pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult));
 
     if (cc != CC_STDCALL && cc != CC_CDECL)
@@ -6786,7 +6572,7 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
     }
 
     /* maximum size for an argument is sizeof(VARIANT).  Also allow for return pointer and stack alignment. */
-    args = heap_alloc( sizeof(VARIANT) * cActuals + sizeof(DWORD) * 4 );
+    args = malloc( sizeof(VARIANT) * cActuals + sizeof(DWORD) * 4 );
 
     for (i = 0; i < cActuals; i++)
     {
@@ -6796,11 +6582,8 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
 
         switch (prgvt[i])
         {
-        case VT_EMPTY:
-            break;
         case VT_R8:             /* these must be 8-byte aligned, and put in 'd' regs or stack, as they are double-floats */
         case VT_DATE:
-#ifndef __SOFTFP__
             dcount = max( (scount + 1) / 2, dcount );
             if (dcount < 8)
             {
@@ -6813,7 +6596,6 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
                 argspos += sizeof(V_R8(arg)) / sizeof(DWORD);
             }
             break;
-#endif
         case VT_I8:             /* these must be 8-byte aligned, and put in 'r' regs or stack, as they are long-longs */
         case VT_UI8:
         case VT_CY:
@@ -6851,26 +6633,37 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
                 --ntemp;
             }
             break;
-        case VT_BOOL:  /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */
-            if (rcount < 4)
-                regs.r[rcount++] = V_BOOL(arg);
-            else
-                args[argspos++] = V_BOOL(arg);
-            break;
         case VT_R4:             /* these must be 4-byte aligned, and put in 's' regs or stack, as they are single-floats */
-#ifndef __SOFTFP__
             if (!(scount % 2)) scount = max( scount, dcount * 2 );
             if (scount < 16)
                 regs.sd.s[scount++] = V_R4(arg);
             else
                 args[argspos++] = V_UI4(arg);
             break;
-#endif
+        /* extend parameters to 32 bits */
+        case VT_I1:
+            if (rcount < 4) regs.r[rcount++] = V_I1(arg);
+            else args[argspos++] = V_I1(arg);
+            break;
+        case VT_UI1:
+            if (rcount < 4) regs.r[rcount++] = V_UI1(arg);
+            else args[argspos++] = V_UI1(arg);
+            break;
+        case VT_I2:
+            if (rcount < 4) regs.r[rcount++] = V_I2(arg);
+            else args[argspos++] = V_I2(arg);
+            break;
+        case VT_UI2:
+            if (rcount < 4) regs.r[rcount++] = V_UI2(arg);
+            else args[argspos++] = V_UI2(arg);
+            break;
+        case VT_BOOL:
+            if (rcount < 4) regs.r[rcount++] = V_BOOL(arg);
+            else args[argspos++] = V_BOOL(arg);
+            break;
         default:
-            if (rcount < 4)
-                regs.r[rcount++] = V_UI4(arg);
-            else
-                args[argspos++] = V_UI4(arg);
+            if (rcount < 4) regs.r[rcount++] = V_UI4(arg);
+            else args[argspos++] = V_UI4(arg);
             break;
         }
         TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg));
@@ -6880,7 +6673,6 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
 
     switch (vtReturn)
     {
-    case VT_EMPTY:      /* EMPTY = no return value */
     case VT_DECIMAL:    /* DECIMAL and VARIANT already have a pointer argument passed (see above) */
     case VT_VARIANT:
         call_method( func, argspos, args, (DWORD*)&regs );
@@ -6901,7 +6693,7 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
         V_UI4(pvargResult) = call_method( func, argspos, args, (DWORD*)&regs );
         break;
     }
-    heap_free( args );
+    free( args );
     if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn;
     TRACE("retval: %s\n", debugstr_variant(pvargResult));
     return S_OK;
@@ -6912,34 +6704,6 @@ HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VART
 extern DWORD_PTR CDECL call_method( void *func, int nb_stk_args, const DWORD_PTR *stk_args, const DWORD_PTR *reg_args );
 extern float CDECL call_float_method( void *func, int nb_stk_args, const DWORD_PTR *stk_args, const DWORD_PTR *reg_args );
 extern double CDECL call_double_method( void *func, int nb_stk_args, const DWORD_PTR *stk_args, const DWORD_PTR *reg_args );
-__ASM_GLOBAL_FUNC( call_method,
-                   "stp x29, x30, [sp, #-16]!\n\t"
-                   "mov x29, sp\n\t"
-                   "sub sp, sp, x1, lsl #3\n\t"
-                   "cbz x1, 2f\n"
-                   "1:\tsub x1, x1, #1\n\t"
-                   "ldr x4, [x2, x1, lsl #3]\n\t"
-                   "str x4, [sp, x1, lsl #3]\n\t"
-                   "cbnz x1, 1b\n"
-                   "2:\tmov x16, x0\n\t"
-                   "mov x9, x3\n\t"
-                   "ldp d0, d1, [x9]\n\t"
-                   "ldp d2, d3, [x9, #0x10]\n\t"
-                   "ldp d4, d5, [x9, #0x20]\n\t"
-                   "ldp d6, d7, [x9, #0x30]\n\t"
-                   "ldp x0, x1, [x9, #0x40]\n\t"
-                   "ldp x2, x3, [x9, #0x50]\n\t"
-                   "ldp x4, x5, [x9, #0x60]\n\t"
-                   "ldp x6, x7, [x9, #0x70]\n\t"
-                   "ldr x8, [x9, #0x80]\n\t"
-                   "blr x16\n\t"
-                   "mov sp, x29\n\t"
-                   "ldp x29, x30, [sp], #16\n\t"
-                   "ret" )
-__ASM_GLOBAL_FUNC( call_float_method,
-                   "b " __ASM_NAME("call_method") )
-__ASM_GLOBAL_FUNC( call_double_method,
-                   "b " __ASM_NAME("call_method") )
 
 HRESULT WINAPI DispCallFunc( void *instance, ULONG_PTR offset, CALLCONV cc, VARTYPE ret_type, UINT count,
                              VARTYPE *types, VARIANTARG **vargs, VARIANT *result )
@@ -6960,7 +6724,7 @@ HRESULT WINAPI DispCallFunc( void *instance, ULONG_PTR offset, CALLCONV cc, VART
     int rcount;      /* 64-bit register index count */
     int fpcount = 0; /* float register index count */
 
-    TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
+    TRACE("(%p, %Id, %d, %d, %d, %p, %p, %p (vt=%d))\n",
           instance, offset, cc, ret_type, count, types, vargs, result, V_VT(result));
 
     if (cc != CC_STDCALL && cc != CC_CDECL)
@@ -6980,23 +6744,8 @@ HRESULT WINAPI DispCallFunc( void *instance, ULONG_PTR offset, CALLCONV cc, VART
     }
     else func = (void *)offset;
 
-    /* Determine if we need to pass a pointer for the return value as arg 0.  If so, do that */
-    /*  first as it will need to be in the 'x' registers:                                    */
-    switch (ret_type)
-    {
-    case VT_DECIMAL:
-    case VT_VARIANT:
-        regs.x[8] = (DWORD_PTR)result;  /* x8 is a pointer to the result */
-        break;
-    case VT_HRESULT:
-        WARN("invalid return type %u\n", ret_type);
-        return E_INVALIDARG;
-    default:
-        break;
-    }
-
-    /* maximum size for an argument is sizeof(VARIANT).  Also allow for return pointer and stack alignment. */
-    args = heap_alloc( sizeof(VARIANT) * count + sizeof(DWORD_PTR) * 4 );
+    /* maximum size for an argument is 16 */
+    args = malloc( 16 * count );
 
     for (i = 0; i < count; i++)
     {
@@ -7004,8 +6753,6 @@ HRESULT WINAPI DispCallFunc( void *instance, ULONG_PTR offset, CALLCONV cc, VART
 
         switch (types[i])
         {
-        case VT_EMPTY:
-            break;
         case VT_R4:
             if (fpcount < 8) regs.fp[fpcount++].f = V_R4(arg);
             else *(float *)&args[argspos++] = V_R4(arg);
@@ -7016,7 +6763,6 @@ HRESULT WINAPI DispCallFunc( void *instance, ULONG_PTR offset, CALLCONV cc, VART
             else *(double *)&args[argspos++] = V_R8(arg);
             break;
         case VT_DECIMAL:
-        case VT_VARIANT:
             if (rcount < 7)
             {
                 memcpy( &regs.x[rcount], arg, sizeof(*arg) );
@@ -7028,6 +6774,10 @@ HRESULT WINAPI DispCallFunc( void *instance, ULONG_PTR offset, CALLCONV cc, VART
                 argspos += 2;
             }
             break;
+        case VT_VARIANT:
+            if (rcount < 8) regs.x[rcount++] = (DWORD_PTR)arg;
+            else args[argspos++] = (DWORD_PTR)arg;
+            break;
         case VT_BOOL:  /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */
             if (rcount < 8) regs.x[rcount++] = V_BOOL(arg);
             else args[argspos++] = V_BOOL(arg);
@@ -7044,9 +6794,12 @@ HRESULT WINAPI DispCallFunc( void *instance, ULONG_PTR offset, CALLCONV cc, VART
 
     switch (ret_type)
     {
-    case VT_EMPTY:      /* EMPTY = no return value */
-    case VT_DECIMAL:    /* DECIMAL and VARIANT already have a pointer argument passed (see above) */
+    case VT_HRESULT:
+        free( args );
+        return E_INVALIDARG;
+    case VT_DECIMAL:
     case VT_VARIANT:
+        regs.x[8] = (DWORD_PTR)result;  /* x8 is a pointer to the result */
         call_method( func, argspos, args, (DWORD_PTR *)&regs );
         break;
     case VT_R4:
@@ -7060,7 +6813,7 @@ HRESULT WINAPI DispCallFunc( void *instance, ULONG_PTR offset, CALLCONV cc, VART
         V_UI8(result) = call_method( func, argspos, args, (DWORD_PTR *)&regs );
         break;
     }
-    heap_free( args );
+    free( args );
     if (ret_type != VT_VARIANT) V_VT(result) = ret_type;
     TRACE("retval: %s\n", debugstr_variant(result));
     return S_OK;
@@ -7084,18 +6837,16 @@ static HRESULT userdefined_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc,
     ITypeInfo *tinfo2 = NULL;
     TYPEATTR *tattr = NULL;
 
-    hr = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2);
+    hr = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->hreftype, &tinfo2);
     if (hr)
     {
-        ERR("Could not get typeinfo of hreftype %x for VT_USERDEFINED, "
-            "hr = 0x%08x\n",
-              tdesc->u.hreftype, hr);
+        ERR("Could not get typeinfo of hreftype %lx for VT_USERDEFINED, hr %#lx.\n", tdesc->hreftype, hr);
         return hr;
     }
     hr = ITypeInfo_GetTypeAttr(tinfo2, &tattr);
     if (hr)
     {
-        ERR("ITypeInfo_GetTypeAttr failed, hr = 0x%08x\n", hr);
+        ERR("ITypeInfo_GetTypeAttr failed, hr %#lx.\n", hr);
         ITypeInfo_Release(tinfo2);
         return hr;
     }
@@ -7152,20 +6903,20 @@ static HRESULT typedescvt_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc,
     /* enforce only one level of pointer indirection */
     if (!(*vt & VT_BYREF) && !(*vt & VT_ARRAY) && (tdesc->vt == VT_PTR))
     {
-        tdesc = tdesc->u.lptdesc;
+        tdesc = tdesc->lptdesc;
 
         /* munch VT_PTR -> VT_USERDEFINED(interface) into VT_UNKNOWN or
          * VT_DISPATCH and VT_PTR -> VT_PTR -> VT_USERDEFINED(interface) into 
          * VT_BYREF|VT_DISPATCH or VT_BYREF|VT_UNKNOWN */
         if ((tdesc->vt == VT_USERDEFINED) ||
-            ((tdesc->vt == VT_PTR) && (tdesc->u.lptdesc->vt == VT_USERDEFINED)))
+            ((tdesc->vt == VT_PTR) && (tdesc->lptdesc->vt == VT_USERDEFINED)))
         {
             VARTYPE vt_userdefined = 0;
             const TYPEDESC *tdesc_userdefined = tdesc;
             if (tdesc->vt == VT_PTR)
             {
                 vt_userdefined = VT_BYREF;
-                tdesc_userdefined = tdesc->u.lptdesc;
+                tdesc_userdefined = tdesc->lptdesc;
             }
             hr = userdefined_to_variantvt(tinfo, tdesc_userdefined, &vt_userdefined);
             if ((hr == S_OK) && 
@@ -7197,7 +6948,7 @@ static HRESULT typedescvt_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc,
         break;
     case VT_SAFEARRAY:
         *vt |= VT_ARRAY;
-        hr = typedescvt_to_variantvt(tinfo, tdesc->u.lptdesc, vt);
+        hr = typedescvt_to_variantvt(tinfo, tdesc->lptdesc, vt);
         break;
     case VT_INT:
         *vt |= VT_I4;
@@ -7231,7 +6982,7 @@ static HRESULT get_iface_guid(ITypeInfo *tinfo, HREFTYPE href, GUID *guid)
 
     switch(tattr->typekind) {
     case TKIND_ALIAS:
-        hres = get_iface_guid(tinfo2, tattr->tdescAlias.u.hreftype, guid);
+        hres = get_iface_guid(tinfo2, tattr->tdescAlias.hreftype, guid);
         break;
 
     case TKIND_INTERFACE:
@@ -7291,16 +7042,15 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
     UINT  *pArgErr)
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
-    int i;
+    int i, j;
     unsigned int var_index;
     TYPEKIND type_kind;
     HRESULT hres;
     const TLBFuncDesc *pFuncInfo;
     UINT fdc;
 
-    TRACE("(%p)(%p,id=%d,flags=0x%08x,%p,%p,%p,%p)\n",
-      This,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr
-    );
+    TRACE("%p, %p, %ld, %#x, %p, %p, %p, %p.\n", iface, pIUnk, memid, wFlags, pDispParams,
+            pVarResult, pExcepInfo, pArgErr);
 
     if( This->typeattr.wTypeFlags & TYPEFLAG_FRESTRICTED )
         return DISP_E_MEMBERNOTFOUND;
@@ -7342,15 +7092,17 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
 	switch (func_desc->funckind) {
 	case FUNC_PUREVIRTUAL:
 	case FUNC_VIRTUAL: {
-            void *buffer = heap_alloc_zero(INVBUF_ELEMENT_SIZE * func_desc->cParams);
+            void *buffer = calloc(func_desc->cParams, INVBUF_ELEMENT_SIZE);
             VARIANT varresult;
-            VARIANT retval; /* pointer for storing byref retvals in */
+            VARIANT retval = {{{0}}}; /* pointer for storing byref retvals in */
             VARIANTARG **prgpvarg = INVBUF_GET_ARG_PTR_ARRAY(buffer, func_desc->cParams);
             VARIANTARG *rgvarg = INVBUF_GET_ARG_ARRAY(buffer, func_desc->cParams);
             VARTYPE *rgvt = INVBUF_GET_ARG_TYPE_ARRAY(buffer, func_desc->cParams);
+            VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
             UINT cNamedArgs = pDispParams->cNamedArgs;
             DISPID *rgdispidNamedArgs = pDispParams->rgdispidNamedArgs;
             UINT vargs_converted=0;
+            SAFEARRAY *a;
 
             hres = S_OK;
 
@@ -7382,30 +7134,27 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
             TRACE("changing args\n");
             for (i = 0; i < func_desc->cParams; i++)
             {
-                USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
+                USHORT wParamFlags = func_desc->lprgelemdescParam[i].paramdesc.wParamFlags;
                 TYPEDESC *tdesc = &func_desc->lprgelemdescParam[i].tdesc;
                 VARIANTARG *src_arg;
 
                 if (wParamFlags & PARAMFLAG_FLCID)
                 {
-                    VARIANTARG *arg;
-                    arg = prgpvarg[i] = &rgvarg[i];
-                    V_VT(arg) = VT_I4;
-                    V_I4(arg) = This->pTypeLib->lcid;
+                    prgpvarg[i] = &rgvarg[i];
+                    V_VT(prgpvarg[i]) = VT_I4;
+                    V_I4(prgpvarg[i]) = This->pTypeLib->lcid;
                     continue;
                 }
 
                 src_arg = NULL;
 
-                if (cNamedArgs)
+                for (j = 0; j < cNamedArgs; j++)
                 {
-                    USHORT j;
-                    for (j = 0; j < cNamedArgs; j++)
-                        if (rgdispidNamedArgs[j] == i || (i == func_desc->cParams-1 && rgdispidNamedArgs[j] == DISPID_PROPERTYPUT))
-                        {
-                            src_arg = &pDispParams->rgvarg[j];
-                            break;
-                        }
+                    if (rgdispidNamedArgs[j] == i || (i == func_desc->cParams-1 && rgdispidNamedArgs[j] == DISPID_PROPERTYPUT))
+                    {
+                        src_arg = &pDispParams->rgvarg[j];
+                        break;
+                    }
                 }
 
                 if (!src_arg && vargs_converted + cNamedArgs < pDispParams->cArgs)
@@ -7434,12 +7183,9 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
                      * native does */
                     if (i == func_desc->cParams - 1)
                     {
-                        VARIANTARG *arg;
-                        arg = prgpvarg[i] = &rgvarg[i];
-                        memset(arg, 0, sizeof(*arg));
-                        V_VT(arg) = rgvt[i];
-                        memset(&retval, 0, sizeof(retval));
-                        V_BYREF(arg) = &retval;
+                        prgpvarg[i] = &rgvarg[i];
+                        V_BYREF(prgpvarg[i]) = &retval;
+                        V_VT(prgpvarg[i]) = rgvt[i];
                     }
                     else
                     {
@@ -7463,7 +7209,6 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
                                 V_VARIANTREF(&rgvarg[i]) = V_VARIANTREF(src_arg);
                             else
                             {
-                                VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
                                 if (wParamFlags & PARAMFLAG_FIN)
                                     hres = VariantCopy(&missing_arg[i], src_arg);
                                 V_VARIANTREF(&rgvarg[i]) = &missing_arg[i];
@@ -7472,10 +7217,9 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
                         }
                         else if ((rgvt[i] == (VT_VARIANT | VT_ARRAY) || rgvt[i] == (VT_VARIANT | VT_ARRAY | VT_BYREF)) && func_desc->cParamsOpt < 0)
                         {
-                            SAFEARRAY *a;
                             SAFEARRAYBOUND bound;
                             VARIANT *v;
-                            LONG j;
+
                             bound.lLbound = 0;
                             bound.cElements = pDispParams->cArgs-i;
                             if (!(a = SafeArrayCreate(VT_VARIANT, 1, &bound)))
@@ -7486,7 +7230,7 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
                             hres = SafeArrayAccessData(a, (LPVOID)&v);
                             if (hres != S_OK)
                             {
-                                ERR("SafeArrayAccessData failed with %x\n", hres);
+                                ERR("SafeArrayAccessData failed with %#lx.\n", hres);
                                 SafeArrayDestroy(a);
                                 break;
                             }
@@ -7495,7 +7239,7 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
                             hres = SafeArrayUnaccessData(a);
                             if (hres != S_OK)
                             {
-                                ERR("SafeArrayUnaccessData failed with %x\n", hres);
+                                ERR("SafeArrayUnaccessData failed with %#lx.\n", hres);
                                 SafeArrayDestroy(a);
                                 break;
                             }
@@ -7507,7 +7251,6 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
                         }
                         else if ((rgvt[i] & VT_BYREF) && !V_ISBYREF(src_arg))
                         {
-                            VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
                             if (wParamFlags & PARAMFLAG_FIN)
                                 hres = VariantChangeType(&missing_arg[i], src_arg, 0, rgvt[i] & ~VT_BYREF);
                             else
@@ -7542,16 +7285,16 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
                         prgpvarg[i] = src_arg;
                     }
 
-                    if((tdesc->vt == VT_USERDEFINED || (tdesc->vt == VT_PTR && tdesc->u.lptdesc->vt == VT_USERDEFINED))
+                    if((tdesc->vt == VT_USERDEFINED || (tdesc->vt == VT_PTR && tdesc->lptdesc->vt == VT_USERDEFINED))
                        && (V_VT(prgpvarg[i]) == VT_DISPATCH || V_VT(prgpvarg[i]) == VT_UNKNOWN)
                        && V_UNKNOWN(prgpvarg[i])) {
                         IUnknown *userdefined_iface;
                         GUID guid;
 
                         if (tdesc->vt == VT_PTR)
-                            tdesc = tdesc->u.lptdesc;
+                            tdesc = tdesc->lptdesc;
 
-                        hres = get_iface_guid((ITypeInfo*)iface, tdesc->u.hreftype, &guid);
+                        hres = get_iface_guid((ITypeInfo*)iface, tdesc->hreftype, &guid);
                         if(FAILED(hres))
                             break;
 
@@ -7571,28 +7314,41 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
                     arg = prgpvarg[i] = &rgvarg[i];
                     if (wParamFlags & PARAMFLAG_FHASDEFAULT)
                     {
-                        hres = VariantCopy(arg, &func_desc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
+                        hres = VariantCopy(arg, &func_desc->lprgelemdescParam[i].paramdesc.pparamdescex->varDefaultValue);
                         if (FAILED(hres))
                             break;
                     }
                     else
                     {
-                        VARIANTARG *missing_arg;
                         /* if the function wants a pointer to a variant then
                          * set that up, otherwise just pass the VT_ERROR in
                          * the argument by value */
                         if (rgvt[i] & VT_BYREF)
                         {
-                            missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams) + i;
+                            V_VT(&missing_arg[i]) = VT_ERROR;
+                            V_ERROR(&missing_arg[i]) = DISP_E_PARAMNOTFOUND;
+
                             V_VT(arg) = VT_VARIANT | VT_BYREF;
-                            V_VARIANTREF(arg) = missing_arg;
+                            V_VARIANTREF(arg) = &missing_arg[i];
                         }
                         else
-                            missing_arg = arg;
-                        V_VT(missing_arg) = VT_ERROR;
-                        V_ERROR(missing_arg) = DISP_E_PARAMNOTFOUND;
+                        {
+                            V_VT(arg) = VT_ERROR;
+                            V_ERROR(arg) = DISP_E_PARAMNOTFOUND;
+                        }
                     }
                 }
+                else if (func_desc->cParamsOpt < 0 && ((rgvt[i] & ~VT_BYREF) == (VT_VARIANT | VT_ARRAY)))
+                {
+                    hres = SafeArrayAllocDescriptorEx( VT_EMPTY, 1, &a );
+                    if (FAILED(hres)) break;
+                    if (rgvt[i] & VT_BYREF)
+                        V_BYREF(&rgvarg[i]) = &a;
+                    else
+                        V_ARRAY(&rgvarg[i]) = a;
+                    V_VT(&rgvarg[i]) = rgvt[i];
+                    prgpvarg[i] = &rgvarg[i];
+                }
                 else
                 {
                     hres = DISP_E_BADPARAMCOUNT;
@@ -7620,8 +7376,7 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
 
             for (i = 0; i < func_desc->cParams; i++)
             {
-                USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
-                VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
+                USHORT wParamFlags = func_desc->lprgelemdescParam[i].paramdesc.wParamFlags;
 
                 if (wParamFlags & PARAMFLAG_FLCID)
                     continue;
@@ -7660,18 +7415,18 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
                              i == func_desc->cParams-1)
                     {
                         SAFEARRAY *a = V_ARRAY(prgpvarg[i]);
-                        LONG j, ubound;
+                        LONG ubound;
                         VARIANT *v;
                         hres = SafeArrayGetUBound(a, 1, &ubound);
                         if (hres != S_OK)
                         {
-                            ERR("SafeArrayGetUBound failed with %x\n", hres);
+                            ERR("SafeArrayGetUBound failed with %#lx.\n", hres);
                             break;
                         }
                         hres = SafeArrayAccessData(a, (LPVOID)&v);
                         if (hres != S_OK)
                         {
-                            ERR("SafeArrayAccessData failed with %x\n", hres);
+                            ERR("SafeArrayAccessData failed with %#lx.\n", hres);
                             break;
                         }
                         for (j = 0; j <= ubound; j++)
@@ -7679,7 +7434,7 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
                         hres = SafeArrayUnaccessData(a);
                         if (hres != S_OK)
                         {
-                            ERR("SafeArrayUnaccessData failed with %x\n", hres);
+                            ERR("SafeArrayUnaccessData failed with %#lx.\n", hres);
                             break;
                         }
                     }
@@ -7697,7 +7452,7 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
 
             if ((V_VT(&varresult) == VT_ERROR) && FAILED(V_ERROR(&varresult)))
             {
-                WARN("invoked function failed with error 0x%08x\n", V_ERROR(&varresult));
+                WARN("invoked function failed with error %#lx.\n", V_ERROR(&varresult));
                 hres = DISP_E_EXCEPTION;
                 if (pExcepInfo)
                 {
@@ -7729,7 +7484,7 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
 
             if (SUCCEEDED(hres) && pVarResult && (func_desc->cParams == 1) &&
                 (func_desc->invkind & INVOKE_PROPERTYGET) &&
-                (func_desc->lprgelemdescParam[0].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL) &&
+                (func_desc->lprgelemdescParam[0].paramdesc.wParamFlags & PARAMFLAG_FRETVAL) &&
                 (pDispParams->cArgs != 0))
             {
                 if (V_VT(pVarResult) == VT_DISPATCH)
@@ -7751,7 +7506,7 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
             }
 
 func_fail:
-            heap_free(buffer);
+            free(buffer);
             break;
         }
 	case FUNC_DISPATCH:  {
@@ -7765,7 +7520,7 @@ func_fail:
                                      pVarResult,pExcepInfo,pArgErr
                                      );
                if (FAILED(hres))
-                   FIXME("IDispatch::Invoke failed with %08x. (Could be not a real error?)\n", hres);
+                   FIXME("IDispatch::Invoke failed with %#lx. (Could be not a real error?)\n", hres);
                IDispatch_Release(disp);
            } else
 	       FIXME("FUNC_DISPATCH used on object without IDispatch iface?\n");
@@ -7777,7 +7532,7 @@ func_fail:
             break;
         }
 
-        TRACE("-- 0x%08x\n", hres);
+        TRACE("-- %#lx\n", hres);
         return hres;
 
     } else if(SUCCEEDED(hres = ITypeInfo2_GetVarIndexOfMemId(iface, memid, &var_index))) {
@@ -7792,6 +7547,28 @@ func_fail:
         return E_NOTIMPL;
     }
 
+    /* not found, check for special error cases */
+    for (fdc = 0; fdc < This->typeattr.cFuncs; ++fdc)
+    {
+        const FUNCDESC *func_desc = &This->funcdescs[fdc].funcdesc;
+        if (memid == func_desc->memid)
+        {
+            if ((wFlags & INVOKE_PROPERTYPUT) && (func_desc->invkind & INVOKE_PROPERTYGET))
+            {
+                int count_inputs = 0;
+                for (i = 0; i < func_desc->cParams; i++)
+                {
+                    USHORT wParamFlags = func_desc->lprgelemdescParam[i].paramdesc.wParamFlags;
+                    if (!(wParamFlags & PARAMFLAG_FRETVAL))
+                        count_inputs++;
+                }
+
+                if (count_inputs == 0 || pDispParams->cArgs == count_inputs + 1)
+                    return DISP_E_BADPARAMCOUNT;
+            }
+        }
+    }
+
     /* not found, look for it in inherited interfaces */
     ITypeInfo2_GetTypeKind(iface, &type_kind);
     if(type_kind == TKIND_INTERFACE || type_kind == TKIND_DISPATCH) {
@@ -7807,7 +7584,7 @@ func_fail:
             WARN("Could not search inherited interface!\n");
         }
     }
-    WARN("did not find member id %d, flags 0x%x!\n", memid, wFlags);
+    WARN("did not find member id %ld, flags 0x%x!\n", memid, wFlags);
     return DISP_E_MEMBERNOTFOUND;
 }
 
@@ -7825,9 +7602,8 @@ static HRESULT WINAPI ITypeInfo_fnGetDocumentation( ITypeInfo2 *iface,
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
     const TLBFuncDesc *pFDesc;
     const TLBVarDesc *pVDesc;
-    TRACE("(%p) memid %d Name(%p) DocString(%p)"
-          " HelpContext(%p) HelpFile(%p)\n",
-        This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
+    TRACE("%p, %ld, %p, %p, %p, %p.\n",
+        iface, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
     if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
         if(pBstrName)
             *pBstrName=SysAllocString(TLB_get_bstr(This->Name));
@@ -7839,7 +7615,7 @@ static HRESULT WINAPI ITypeInfo_fnGetDocumentation( ITypeInfo2 *iface,
             *pBstrHelpFile=SysAllocString(TLB_get_bstr(This->pTypeLib->HelpFile));
         return S_OK;
     }else {/* for a member */
-        pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->typeattr.cFuncs, memid);
+        pFDesc = TLB_get_funcdesc_by_memberid(This, memid);
         if(pFDesc){
             if(pBstrName)
               *pBstrName = SysAllocString(TLB_get_bstr(pFDesc->Name));
@@ -7851,7 +7627,7 @@ static HRESULT WINAPI ITypeInfo_fnGetDocumentation( ITypeInfo2 *iface,
               *pBstrHelpFile = SysAllocString(TLB_get_bstr(This->pTypeLib->HelpFile));
             return S_OK;
         }
-        pVDesc = TLB_get_vardesc_by_memberid(This->vardescs, This->typeattr.cVars, memid);
+        pVDesc = TLB_get_vardesc_by_memberid(This, memid);
         if(pVDesc){
             if(pBstrName)
               *pBstrName = SysAllocString(TLB_get_bstr(pVDesc->Name));
@@ -7880,7 +7656,7 @@ static HRESULT WINAPI ITypeInfo_fnGetDocumentation( ITypeInfo2 *iface,
         WARN("Could not search inherited interface!\n");
     }
 
-    WARN("member %d not found\n", memid);
+    WARN("member %ld not found\n", memid);
     return TYPE_E_ELEMENTNOTFOUND;
 }
 
@@ -7896,7 +7672,7 @@ static HRESULT WINAPI ITypeInfo_fnGetDllEntry( ITypeInfo2 *iface, MEMBERID memid
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
     const TLBFuncDesc *pFDesc;
 
-    TRACE("(%p)->(memid %x, %d, %p, %p, %p)\n", This, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
+    TRACE("%p, %#lx, %d, %p, %p, %p.\n", iface, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
 
     if (pBstrDllName) *pBstrDllName = NULL;
     if (pBstrName) *pBstrName = NULL;
@@ -7905,29 +7681,25 @@ static HRESULT WINAPI ITypeInfo_fnGetDllEntry( ITypeInfo2 *iface, MEMBERID memid
     if (This->typeattr.typekind != TKIND_MODULE)
         return TYPE_E_BADMODULEKIND;
 
-    pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->typeattr.cFuncs, memid);
-    if(pFDesc){
-	    dump_TypeInfo(This);
-	    if (TRACE_ON(ole))
-		dump_TLBFuncDescOne(pFDesc);
+    pFDesc = TLB_get_funcdesc_by_memberid_invkind(This, memid, invKind);
+    if (!pFDesc) return TYPE_E_ELEMENTNOTFOUND;
 
-	    if (pBstrDllName)
-		*pBstrDllName = SysAllocString(TLB_get_bstr(This->DllName));
+    dump_TypeInfo(This);
+    if (TRACE_ON(ole)) dump_TLBFuncDescOne(pFDesc);
 
-            if (!IS_INTRESOURCE(pFDesc->Entry) && (pFDesc->Entry != (void*)-1)) {
-		if (pBstrName)
-		    *pBstrName = SysAllocString(TLB_get_bstr(pFDesc->Entry));
-		if (pwOrdinal)
-		    *pwOrdinal = -1;
-		return S_OK;
-	    }
-	    if (pBstrName)
-		*pBstrName = NULL;
-	    if (pwOrdinal)
-		*pwOrdinal = LOWORD(pFDesc->Entry);
-	    return S_OK;
-        }
-    return TYPE_E_ELEMENTNOTFOUND;
+    if (pBstrDllName) *pBstrDllName = SysAllocString(TLB_get_bstr(This->DllName));
+
+    if (!IS_INTRESOURCE(pFDesc->Entry) && (pFDesc->Entry != (void*)-1))
+    {
+        if (pBstrName) *pBstrName = SysAllocString(TLB_get_bstr(pFDesc->Entry));
+        if (pwOrdinal) *pwOrdinal = -1;
+    }
+    else
+    {
+        if (pBstrName) *pBstrName = NULL;
+        if (pwOrdinal) *pwOrdinal = LOWORD(pFDesc->Entry);
+    }
+    return S_OK;
 }
 
 /* internal function to make the inherited interfaces' methods appear
@@ -7938,7 +7710,7 @@ static HRESULT ITypeInfoImpl_GetDispatchRefTypeInfo( ITypeInfo *iface,
     ITypeInfoImpl *This = impl_from_ITypeInfo(iface);
     HRESULT hr;
 
-    TRACE("%p, 0x%x\n", iface, *hRefType);
+    TRACE("%p, %#lx.\n", iface, *hRefType);
 
     if (This->impltypes && (*hRefType & DISPATCH_HREF_MASK))
     {
@@ -7962,45 +7734,6 @@ static HRESULT ITypeInfoImpl_GetDispatchRefTypeInfo( ITypeInfo *iface,
         return E_FAIL;
 }
 
-struct search_res_tlb_params
-{
-    const GUID *guid;
-    ITypeLib *pTLib;
-};
-
-static BOOL CALLBACK search_res_tlb(HMODULE hModule, LPCWSTR lpszType, LPWSTR lpszName, LONG_PTR lParam)
-{
-    struct search_res_tlb_params *params = (LPVOID)lParam;
-    static const WCHAR formatW[] = {'\\','%','d',0};
-    WCHAR szPath[MAX_PATH+1];
-    ITypeLib *pTLib = NULL;
-    HRESULT ret;
-    DWORD len;
-
-    if (IS_INTRESOURCE(lpszName) == FALSE)
-        return TRUE;
-
-    if (!(len = GetModuleFileNameW(hModule, szPath, MAX_PATH)))
-        return TRUE;
-
-    if (swprintf(szPath + len, formatW, LOWORD(lpszName)) < 0)
-        return TRUE;
-
-    ret = LoadTypeLibEx(szPath, REGKIND_NONE, &pTLib);
-    if (SUCCEEDED(ret))
-    {
-        ITypeLibImpl *impl = impl_from_ITypeLib(pTLib);
-        if (IsEqualGUID(params->guid, impl->guid))
-        {
-            params->pTLib = pTLib;
-            return FALSE; /* stop enumeration */
-        }
-        ITypeLib_Release(pTLib);
-    }
-
-    return TRUE;
-}
-
 /* ITypeInfo::GetRefTypeInfo
  *
  * If a type description references other type descriptions, it retrieves
@@ -8012,7 +7745,10 @@ static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
 	ITypeInfo  **ppTInfo)
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
+    ITypeInfo *type_info = NULL;
     HRESULT result = E_FAIL;
+    TLBRefType *ref_type;
+    UINT i;
 
     if(!ppTInfo)
         return E_INVALIDARG;
@@ -8045,32 +7781,32 @@ static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
          * refcount goes to zero, but we need to signal to the new instance to
          * not free its data structures when it is destroyed */
         pTypeInfoImpl->not_attached_to_typelib = TRUE;
-
         ITypeInfo_AddRef(*ppTInfo);
 
-        result = S_OK;
-    } else if ((hRefType & DISPATCH_HREF_MASK) &&
-        (This->typeattr.typekind == TKIND_DISPATCH))
-    {
-        HREFTYPE href_dispatch = hRefType;
-        result = ITypeInfoImpl_GetDispatchRefTypeInfo((ITypeInfo *)iface, &href_dispatch, ppTInfo);
-    } else {
-        TLBRefType *ref_type;
-        ITypeLib *pTLib = NULL;
-        UINT i;
+        TRACE("got dual interface %p\n", *ppTInfo);
+        return S_OK;
+    }
 
-        if(!(hRefType & 0x1)){
-            for(i = 0; i < This->pTypeLib->TypeInfoCount; ++i)
+    if ((hRefType & DISPATCH_HREF_MASK) && (This->typeattr.typekind == TKIND_DISPATCH))
+        return ITypeInfoImpl_GetDispatchRefTypeInfo((ITypeInfo *)iface, &hRefType, ppTInfo);
+
+    if(!(hRefType & 0x1))
+    {
+        for(i = 0; i < This->pTypeLib->TypeInfoCount; ++i)
+        {
+            if (This->pTypeLib->typeinfos[i]->hreftype == (hRefType&(~0x3)))
             {
-                if (This->pTypeLib->typeinfos[i]->hreftype == (hRefType&(~0x3)))
-                {
-                    result = S_OK;
-                    *ppTInfo = (ITypeInfo*)&This->pTypeLib->typeinfos[i]->ITypeInfo2_iface;
-                    ITypeInfo_AddRef(*ppTInfo);
-                    goto end;
-                }
+                result = S_OK;
+                type_info = (ITypeInfo*)&This->pTypeLib->typeinfos[i]->ITypeInfo2_iface;
+                ITypeInfo_AddRef(type_info);
+                break;
             }
         }
+    }
+
+    if (!type_info)
+    {
+        ITypeLib *pTLib = NULL;
 
         LIST_FOR_EACH_ENTRY(ref_type, &This->pTypeLib->ref_list, TLBRefType, entry)
         {
@@ -8079,8 +7815,8 @@ static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
         }
         if(&ref_type->entry == &This->pTypeLib->ref_list)
         {
-            FIXME("Can't find pRefType for ref %x\n", hRefType);
-            goto end;
+            FIXME("Can't find pRefType for ref %lx\n", hRefType);
+            return E_FAIL;
         }
 
         if(ref_type->pImpTLInfo == TLB_REF_INTERNAL) {
@@ -8094,21 +7830,31 @@ static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
                 ITypeLib_AddRef(pTLib);
                 result = S_OK;
             } else {
-                static const WCHAR TYPELIBW[] = {'T','Y','P','E','L','I','B',0};
-                struct search_res_tlb_params params;
-                BSTR libnam;
+                /* Search in cached typelibs */
+                ITypeLibImpl *entry;
 
-                TRACE("typeinfo in imported typelib that isn't already loaded\n");
-
-                /* Search in resource table */
-                params.guid  = TLB_get_guid_null(ref_type->pImpTLInfo->guid);
-                params.pTLib = NULL;
-                EnumResourceNamesW(NULL, TYPELIBW, search_res_tlb, (LONG_PTR)&params);
-                pTLib  = params.pTLib;
-                result = S_OK;
+                EnterCriticalSection(&cache_section);
+                LIST_FOR_EACH_ENTRY(entry, &tlb_cache, ITypeLibImpl, entry)
+                {
+                    if (entry->guid
+                        && IsEqualIID(&entry->guid->guid, TLB_get_guid_null(ref_type->pImpTLInfo->guid))
+                        && entry->ver_major == ref_type->pImpTLInfo->wVersionMajor
+                        && entry->ver_minor == ref_type->pImpTLInfo->wVersionMinor
+                        && entry->set_lcid == ref_type->pImpTLInfo->lcid)
+                    {
+                        TRACE("got cached %p\n", entry);
+                        pTLib = (ITypeLib*)&entry->ITypeLib2_iface;
+                        ITypeLib_AddRef(pTLib);
+                        result = S_OK;
+                        break;
+                    }
+                }
+                LeaveCriticalSection(&cache_section);
 
                 if (!pTLib)
                 {
+                    BSTR libnam;
+
                     /* Search on disk */
                     result = query_typelib_path(TLB_get_guid_null(ref_type->pImpTLInfo->guid),
                             ref_type->pImpTLInfo->wVersionMajor,
@@ -8130,16 +7876,24 @@ static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
         }
         if(SUCCEEDED(result)) {
             if(ref_type->index == TLB_REF_USE_GUID)
-                result = ITypeLib_GetTypeInfoOfGuid(pTLib, TLB_get_guid_null(ref_type->guid), ppTInfo);
+                result = ITypeLib_GetTypeInfoOfGuid(pTLib, TLB_get_guid_null(ref_type->guid), &type_info);
             else
-                result = ITypeLib_GetTypeInfo(pTLib, ref_type->index, ppTInfo);
+                result = ITypeLib_GetTypeInfo(pTLib, ref_type->index, &type_info);
         }
         if (pTLib != NULL)
             ITypeLib_Release(pTLib);
+        if (FAILED(result))
+        {
+            WARN("(%p) failed hreftype %#lx.\n", iface, hRefType);
+            return result;
+        }
     }
 
-end:
-    TRACE("(%p) hreftype 0x%04x loaded %s (%p)\n", This, hRefType,
+    if ((hRefType & 0x2) && SUCCEEDED(ITypeInfo_GetRefTypeInfo(type_info, -2, ppTInfo)))
+        ITypeInfo_Release(type_info);
+    else *ppTInfo = type_info;
+
+    TRACE("%p, hreftype %#lx, loaded %s (%p)\n", iface, hRefType,
           SUCCEEDED(result)? "SUCCESS":"FAILURE", *ppTInfo);
     return result;
 }
@@ -8152,13 +7906,12 @@ end:
 static HRESULT WINAPI ITypeInfo_fnAddressOfMember( ITypeInfo2 *iface,
         MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
 {
-    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
     HRESULT hr;
     BSTR dll, entry;
     WORD ordinal;
     HMODULE module;
 
-    TRACE("(%p)->(0x%x, 0x%x, %p)\n", This, memid, invKind, ppv);
+    TRACE("%p, %lx, %#x, %p.\n", iface, memid, invKind, ppv);
 
     hr = ITypeInfo2_GetDllEntry(iface, memid, invKind, &dll, &entry, &ordinal);
     if (FAILED(hr))
@@ -8178,14 +7931,14 @@ static HRESULT WINAPI ITypeInfo_fnAddressOfMember( ITypeInfo2 *iface,
     {
         LPSTR entryA;
         INT len = WideCharToMultiByte(CP_ACP, 0, entry, -1, NULL, 0, NULL, NULL);
-        entryA = heap_alloc(len);
+        entryA = malloc(len);
         WideCharToMultiByte(CP_ACP, 0, entry, -1, entryA, len, NULL, NULL);
 
         *ppv = GetProcAddress(module, entryA);
         if (!*ppv)
             ERR("function not found %s\n", debugstr_a(entryA));
 
-        heap_free(entryA);
+        free(entryA);
     }
     else
     {
@@ -8240,7 +7993,7 @@ static HRESULT WINAPI ITypeInfo_fnCreateInstance( ITypeInfo2 *iface,
     {
         IUnknown *pUnk;
         hr = GetActiveObject(&pTA->guid, NULL, &pUnk);
-        TRACE("GetActiveObject rets %08x\n", hr);
+        TRACE("GetActiveObject rets %#lx.\n", hr);
         if(hr == S_OK)
         {
             hr = IUnknown_QueryInterface(pUnk, riid, ppvObj);
@@ -8262,11 +8015,9 @@ end:
  *
  * Retrieves marshalling information.
  */
-static HRESULT WINAPI ITypeInfo_fnGetMops( ITypeInfo2 *iface, MEMBERID memid,
-				BSTR  *pBstrMops)
+static HRESULT WINAPI ITypeInfo_fnGetMops( ITypeInfo2 *iface, MEMBERID memid, BSTR *pBstrMops)
 {
-    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
-    FIXME("(%p %d) stub!\n", This, memid);
+    FIXME("%p, %ld stub!\n", iface, memid);
     *pBstrMops = NULL;
     return S_OK;
 }
@@ -8306,7 +8057,7 @@ static void WINAPI ITypeInfo_fnReleaseTypeAttr( ITypeInfo2 *iface,
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
     TRACE("(%p)->(%p)\n", This, pTypeAttr);
-    heap_free(pTypeAttr);
+    free(pTypeAttr);
 }
 
 /* ITypeInfo::ReleaseFuncDesc
@@ -8366,8 +8117,8 @@ static HRESULT WINAPI ITypeInfo2_fnGetTypeKind( ITypeInfo2 * iface,
 static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags( ITypeInfo2 *iface, ULONG *pTypeFlags)
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
+    TRACE("%p, %p.\n", iface, pTypeFlags);
     *pTypeFlags=This->typeattr.wTypeFlags;
-    TRACE("(%p) flags 0x%x\n", This,*pTypeFlags);
     return S_OK;
 }
 
@@ -8394,8 +8145,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId( ITypeInfo2 * iface,
     } else
         result = TYPE_E_ELEMENTNOTFOUND;
 
-    TRACE("(%p) memid 0x%08x invKind 0x%04x -> %s\n", This,
-          memid, invKind, SUCCEEDED(result) ? "SUCCESS" : "FAILED");
+    TRACE("%p, %#lx, %#x, hr %#lx.\n", iface, memid, invKind, result);
     return result;
 }
 
@@ -8411,9 +8161,9 @@ static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId( ITypeInfo2 * iface,
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
     TLBVarDesc *pVarInfo;
 
-    TRACE("%p %d %p\n", iface, memid, pVarIndex);
+    TRACE("%p, %ld, %p.\n", iface, memid, pVarIndex);
 
-    pVarInfo = TLB_get_vardesc_by_memberid(This->vardescs, This->typeattr.cVars, memid);
+    pVarInfo = TLB_get_vardesc_by_memberid(This, memid);
     if(!pVarInfo)
         return TYPE_E_ELEMENTNOTFOUND;
 
@@ -8460,22 +8210,23 @@ static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
 	VARIANT *pVarVal)
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
-    TLBCustData *pCData;
-    TLBFuncDesc *pFDesc = &This->funcdescs[index];
+    const TLBFuncDesc *desc;
+    TLBCustData *data;
+    UINT hrefoffset;
+    HRESULT hr;
 
     TRACE("%p %u %s %p\n", This, index, debugstr_guid(guid), pVarVal);
 
-    if(index >= This->typeattr.cFuncs)
-        return TYPE_E_ELEMENTNOTFOUND;
-
-    pCData = TLB_get_custdata_by_guid(&pFDesc->custdata_list, guid);
-    if(!pCData)
-        return TYPE_E_ELEMENTNOTFOUND;
+    hr = ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo *)iface, index, &desc, &hrefoffset);
+    if (FAILED(hr))
+    {
+        WARN("description for function %d not found\n", index);
+        return hr;
+    }
 
     VariantInit(pVarVal);
-    VariantCopy(pVarVal, &pCData->data);
-
-    return S_OK;
+    data = TLB_get_custdata_by_guid(&desc->custdata_list, guid);
+    return data ? VariantCopy(pVarVal, &data->data) : S_OK;
 }
 
 /* ITypeInfo2::GetParamCustData
@@ -8490,14 +8241,17 @@ static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
 	VARIANT *pVarVal)
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
+    const TLBFuncDesc *pFDesc;
     TLBCustData *pCData;
-    TLBFuncDesc *pFDesc = &This->funcdescs[indexFunc];
+    UINT hrefoffset;
+    HRESULT hr;
 
     TRACE("%p %u %u %s %p\n", This, indexFunc, indexParam,
             debugstr_guid(guid), pVarVal);
 
-    if(indexFunc >= This->typeattr.cFuncs)
-        return TYPE_E_ELEMENTNOTFOUND;
+    hr = ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo *)iface, indexFunc, &pFDesc, &hrefoffset);
+    if (FAILED(hr))
+        return hr;
 
     if(indexParam >= pFDesc->funcdesc.cParams)
         return TYPE_E_ELEMENTNOTFOUND;
@@ -8588,9 +8342,8 @@ static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
     const TLBFuncDesc *pFDesc;
     const TLBVarDesc *pVDesc;
-    TRACE("(%p) memid %d lcid(0x%x)  HelpString(%p) "
-          "HelpStringContext(%p) HelpStringDll(%p)\n",
-          This, memid, lcid, pbstrHelpString, pdwHelpStringContext,
+    TRACE("%p, %ld, %#lx, %p, %p, %p.\n",
+          iface, memid, lcid, pbstrHelpString, pdwHelpStringContext,
           pbstrHelpStringDll );
     /* the help string should be obtained from the helpstringdll,
      * using the _DLLGetDocumentation function, based on the supplied
@@ -8606,7 +8359,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
                 SysAllocString(TLB_get_bstr(This->pTypeLib->HelpStringDll));/* FIXME */
         return S_OK;
     }else {/* for a member */
-        pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->typeattr.cFuncs, memid);
+        pFDesc = TLB_get_funcdesc_by_memberid(This, memid);
         if(pFDesc){
             if(pbstrHelpString)
                 *pbstrHelpString=SysAllocString(TLB_get_bstr(pFDesc->HelpString));
@@ -8617,7 +8370,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
                     SysAllocString(TLB_get_bstr(This->pTypeLib->HelpStringDll));/* FIXME */
             return S_OK;
         }
-        pVDesc = TLB_get_vardesc_by_memberid(This->vardescs, This->typeattr.cVars, memid);
+        pVDesc = TLB_get_vardesc_by_memberid(This, memid);
         if(pVDesc){
             if(pbstrHelpString)
                 *pbstrHelpString=SysAllocString(TLB_get_bstr(pVDesc->HelpString));
@@ -8659,12 +8412,15 @@ static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
 	CUSTDATA *pCustData)
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
-    TLBFuncDesc *pFDesc = &This->funcdescs[index];
+    const TLBFuncDesc *pFDesc;
+    UINT hrefoffset;
+    HRESULT hr;
 
     TRACE("%p %u %p\n", This, index, pCustData);
 
-    if(index >= This->typeattr.cFuncs)
-        return TYPE_E_ELEMENTNOTFOUND;
+    hr = ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo *)iface, index, &pFDesc, &hrefoffset);
+    if (FAILED(hr))
+        return hr;
 
     return TLB_copy_all_custdata(&pFDesc->custdata_list, pCustData);
 }
@@ -8678,12 +8434,15 @@ static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData( ITypeInfo2 * iface,
     UINT indexFunc, UINT indexParam, CUSTDATA *pCustData)
 {
     ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
-    TLBFuncDesc *pFDesc = &This->funcdescs[indexFunc];
+    const TLBFuncDesc *pFDesc;
+    UINT hrefoffset;
+    HRESULT hr;
 
     TRACE("%p %u %u %p\n", This, indexFunc, indexParam, pCustData);
 
-    if(indexFunc >= This->typeattr.cFuncs)
-        return TYPE_E_ELEMENTNOTFOUND;
+    hr = ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo *)iface, indexFunc, &pFDesc, &hrefoffset);
+    if (FAILED(hr))
+        return hr;
 
     if(indexParam >= pFDesc->funcdesc.cParams)
         return TYPE_E_ELEMENTNOTFOUND;
@@ -8805,7 +8564,7 @@ HRESULT WINAPI CreateDispTypeInfo(
     if (!pTypeLibImpl) return E_FAIL;
 
     pTypeLibImpl->TypeInfoCount = 2;
-    pTypeLibImpl->typeinfos = heap_alloc_zero(pTypeLibImpl->TypeInfoCount * sizeof(ITypeInfoImpl*));
+    pTypeLibImpl->typeinfos = calloc(pTypeLibImpl->TypeInfoCount, sizeof(ITypeInfoImpl*));
 
     pTIIface = pTypeLibImpl->typeinfos[0] = ITypeInfoImpl_Constructor();
     pTIIface->pTypeLib = pTypeLibImpl;
@@ -8842,10 +8601,9 @@ HRESULT WINAPI CreateDispTypeInfo(
         pFuncDesc->funcdesc.cScodes = 0;
         pFuncDesc->funcdesc.wFuncFlags = 0;
         pFuncDesc->funcdesc.elemdescFunc.tdesc.vt = md->vtReturn;
-        pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.wParamFlags = PARAMFLAG_NONE;
-        pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.pparamdescex = NULL;
-        pFuncDesc->funcdesc.lprgelemdescParam = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
-                                                              md->cArgs * sizeof(ELEMDESC));
+        pFuncDesc->funcdesc.elemdescFunc.paramdesc.wParamFlags = PARAMFLAG_NONE;
+        pFuncDesc->funcdesc.elemdescFunc.paramdesc.pparamdescex = NULL;
+        pFuncDesc->funcdesc.lprgelemdescParam = calloc(md->cArgs, sizeof(ELEMDESC));
         pFuncDesc->pParamDesc = TLBParDesc_Constructor(md->cArgs);
         for(param = 0; param < md->cArgs; param++) {
             pFuncDesc->funcdesc.lprgelemdescParam[param].tdesc.vt = md->ppdata[param].vt;
@@ -8883,7 +8641,7 @@ HRESULT WINAPI CreateDispTypeInfo(
 
     pTIClass->impltypes = TLBImplType_Alloc(1);
 
-    ref = heap_alloc_zero(sizeof(*ref));
+    ref = calloc(1, sizeof(*ref));
     ref->pImpTLInfo = TLB_REF_INTERNAL;
     list_add_head(&pTypeLibImpl->ref_list, &ref->entry);
 
@@ -8934,7 +8692,7 @@ static HRESULT WINAPI ITypeComp_fnBind(
     HRESULT hr = DISP_E_MEMBERNOTFOUND;
     UINT fdc;
 
-    TRACE("(%p)->(%s, %x, 0x%x, %p, %p, %p)\n", This, debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
+    TRACE("%p, %s, %#lx, 0x%x, %p, %p, %p.\n", iface, debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
 
     *pDescKind = DESCKIND_NONE;
     pBindPtr->lpfuncdesc = NULL;
@@ -8964,7 +8722,7 @@ static HRESULT WINAPI ITypeComp_fnBind(
         ITypeInfo_AddRef(*ppTInfo);
         return S_OK;
     } else {
-        pVDesc = TLB_get_vardesc_by_name(This->vardescs, This->typeattr.cVars, szName);
+        pVDesc = TLB_get_vardesc_by_name(This, szName);
         if(pVDesc){
             HRESULT hr = TLB_AllocAndInitVarDesc(&pVDesc->vardesc, &pBindPtr->lpvardesc);
             if (FAILED(hr))
@@ -9015,7 +8773,7 @@ static HRESULT WINAPI ITypeComp_fnBindType(
     ITypeInfo ** ppTInfo,
     ITypeComp ** ppTComp)
 {
-    TRACE("(%s, %x, %p, %p)\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
+    TRACE("%s, %#lx, %p, %p.\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
 
     /* strange behaviour (does nothing) but like the
      * original */
@@ -9058,12 +8816,11 @@ HRESULT WINAPI CreateTypeLib2(SYSKIND syskind, LPCOLESTR szFile,
     This->syskind = syskind;
     This->ptr_size = get_ptr_size(syskind);
 
-    This->path = heap_alloc((lstrlenW(szFile) + 1) * sizeof(WCHAR));
+    This->path = wcsdup(szFile);
     if (!This->path) {
         ITypeLib2_Release(&This->ITypeLib2_iface);
         return E_OUTOFMEMORY;
     }
-    lstrcpyW(This->path, szFile);
 
     hres = ITypeLib2_QueryInterface(&This->ITypeLib2_iface, &IID_ICreateTypeLib2, (LPVOID*)ppctlib);
     ITypeLib2_Release(&This->ITypeLib2_iface);
@@ -9104,15 +8861,11 @@ static HRESULT WINAPI ICreateTypeLib2_fnCreateTypeInfo(ICreateTypeLib2 *iface,
     if (!ctinfo || !name)
         return E_INVALIDARG;
 
-    info = TLB_get_typeinfo_by_name(This->typeinfos, This->TypeInfoCount, name);
+    info = TLB_get_typeinfo_by_name(This, name);
     if (info)
         return TYPE_E_NAMECONFLICT;
 
-    if (This->typeinfos)
-        This->typeinfos = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->typeinfos,
-                sizeof(ITypeInfoImpl*) * (This->TypeInfoCount + 1));
-    else
-        This->typeinfos = heap_alloc_zero(sizeof(ITypeInfoImpl*));
+    This->typeinfos = realloc(This->typeinfos, sizeof(ITypeInfoImpl*) * (This->TypeInfoCount + 1));
 
     info = This->typeinfos[This->TypeInfoCount] = ITypeInfoImpl_Constructor();
 
@@ -9234,7 +8987,7 @@ static HRESULT WINAPI ICreateTypeLib2_fnSetHelpContext(ICreateTypeLib2 *iface,
 {
     ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
-    TRACE("%p %d\n", This, helpContext);
+    TRACE("%p, %ld.\n", iface, helpContext);
 
     This->dwHelpContext = helpContext;
 
@@ -9246,7 +8999,7 @@ static HRESULT WINAPI ICreateTypeLib2_fnSetLcid(ICreateTypeLib2 *iface,
 {
     ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
-    TRACE("%p %x\n", This, lcid);
+    TRACE("%p, %#lx.\n", iface, lcid);
 
     This->set_lcid = lcid;
 
@@ -9317,7 +9070,7 @@ static HRESULT WMSFT_compile_strings(ITypeLibImpl *This,
         str->offset = size;
     }
 
-    file->string_seg.data = data = heap_alloc(file->string_seg.len);
+    file->string_seg.data = data = malloc(file->string_seg.len);
 
     last_offs = 0;
     LIST_FOR_EACH_ENTRY(str, &This->string_list, TLBString, entry) {
@@ -9326,7 +9079,8 @@ static HRESULT WMSFT_compile_strings(ITypeLibImpl *This,
         size = WideCharToMultiByte(CP_ACP, 0, str->str, lstrlenW(str->str),
                 data + sizeof(INT16), file->string_seg.len - last_offs - sizeof(INT16), NULL, NULL);
         if (size == 0) {
-            heap_free(file->string_seg.data);
+            free(file->string_seg.data);
+            file->string_seg.data = NULL;
             return E_UNEXPECTED;
         }
 
@@ -9380,7 +9134,7 @@ static HRESULT WMSFT_compile_names(ITypeLibImpl *This,
     }
 
     /* Allocate bigger buffer so we can temporarily NULL terminate the name */
-    file->name_seg.data = data = heap_alloc(file->name_seg.len+1);
+    file->name_seg.data = data = malloc(file->name_seg.len + 1);
 
     last_offs = 0;
     LIST_FOR_EACH_ENTRY(str, &This->name_list, TLBString, entry) {
@@ -9391,7 +9145,7 @@ static HRESULT WMSFT_compile_names(ITypeLibImpl *This,
                 data + sizeof(MSFT_NameIntro),
                 file->name_seg.len - last_offs - sizeof(MSFT_NameIntro), NULL, NULL);
         if (size == 0) {
-            heap_free(file->name_seg.data);
+            free(file->name_seg.data);
             return E_UNEXPECTED;
         }
         data[sizeof(MSFT_NameIntro) + size] = '\0';
@@ -9441,7 +9195,7 @@ static HRESULT WMSFT_compile_guids(ITypeLibImpl *This, WMSFT_TLBFile *file)
     int hash_key, *guidhashtab;
 
     file->guid_seg.len = sizeof(MSFT_GuidEntry) * list_count(&This->guid_list);
-    file->guid_seg.data = heap_alloc(file->guid_seg.len);
+    file->guid_seg.data = malloc(file->guid_seg.len);
 
     entry = file->guid_seg.data;
     offs = 0;
@@ -9479,7 +9233,7 @@ static DWORD WMSFT_encode_variant(VARIANT *value, WMSFT_TLBFile *file)
     if(V_VT(value) != arg_type) {
         hres = VariantChangeType(&v, value, 0, arg_type);
         if(FAILED(hres)){
-            ERR("VariantChangeType failed: %08x\n", hres);
+            ERR("VariantChangeType failed: %#lx.\n", hres);
             return -1;
         }
     }
@@ -9518,12 +9272,12 @@ static DWORD WMSFT_encode_variant(VARIANT *value, WMSFT_TLBFile *file)
         int *data;
 
         if(file->custdata_seg.data){
-            file->custdata_seg.data = heap_realloc(file->custdata_seg.data, file->custdata_seg.len + sizeof(int) * 2);
+            file->custdata_seg.data = realloc(file->custdata_seg.data, file->custdata_seg.len + sizeof(int) * 2);
             data = (int *)(((char *)file->custdata_seg.data) + file->custdata_seg.len);
             file->custdata_seg.len += sizeof(int) * 2;
         }else{
             file->custdata_seg.len = sizeof(int) * 2;
-            data = file->custdata_seg.data = heap_alloc(file->custdata_seg.len);
+            data = file->custdata_seg.data = malloc(file->custdata_seg.len);
         }
 
         data[0] = V_VT(value) + (V_UI4(&v) << 16);
@@ -9535,28 +9289,23 @@ static DWORD WMSFT_encode_variant(VARIANT *value, WMSFT_TLBFile *file)
     }
 
     case VT_BSTR: {
-        int i, len = (6+SysStringLen(V_BSTR(&v))+3) & ~0x3;
+        int mb_len = WideCharToMultiByte(CP_ACP, 0, V_BSTR(&v), SysStringLen(V_BSTR(&v)), NULL, 0, NULL, NULL );
+        int i, len = (6 + mb_len + 3) & ~0x3;
         char *data;
 
         if(file->custdata_seg.data){
-            file->custdata_seg.data = heap_realloc(file->custdata_seg.data, file->custdata_seg.len + len);
+            file->custdata_seg.data = realloc(file->custdata_seg.data, file->custdata_seg.len + len);
             data = ((char *)file->custdata_seg.data) + file->custdata_seg.len;
             file->custdata_seg.len += len;
         }else{
             file->custdata_seg.len = len;
-            data = file->custdata_seg.data = heap_alloc(file->custdata_seg.len);
+            data = file->custdata_seg.data = malloc(file->custdata_seg.len);
         }
 
         *((unsigned short *)data) = V_VT(value);
-        *((unsigned int *)(data+2)) = SysStringLen(V_BSTR(&v));
-        for(i=0; i<SysStringLen(V_BSTR(&v)); i++) {
-            if(V_BSTR(&v)[i] <= 0x7f)
-                data[i+6] = V_BSTR(&v)[i];
-            else
-                data[i+6] = '?';
-        }
-        WideCharToMultiByte(CP_ACP, 0, V_BSTR(&v), SysStringLen(V_BSTR(&v)), &data[6], len-6, NULL, NULL);
-        for(i=6+SysStringLen(V_BSTR(&v)); i<len; i++)
+        *((unsigned int *)(data+2)) = mb_len;
+        WideCharToMultiByte(CP_ACP, 0, V_BSTR(&v), SysStringLen(V_BSTR(&v)), &data[6], mb_len, NULL, NULL);
+        for (i = 6 + mb_len; i < len; i++)
             data[i] = 0x57;
 
         /* TODO: Check if the encoded data is already present in custdata_seg */
@@ -9582,10 +9331,7 @@ static DWORD WMSFT_append_arraydesc(ARRAYDESC *desc, WMSFT_TLBFile *file)
      * at the library-level) */
 
     file->arraydesc_seg.len += (2 + desc->cDims * 2) * sizeof(DWORD);
-    if(!file->arraydesc_seg.data)
-        file->arraydesc_seg.data = heap_alloc(file->arraydesc_seg.len);
-    else
-        file->arraydesc_seg.data = heap_realloc(file->arraydesc_seg.data, file->arraydesc_seg.len);
+    file->arraydesc_seg.data = realloc(file->arraydesc_seg.data, file->arraydesc_seg.len);
     encoded = (DWORD*)((char *)file->arraydesc_seg.data + offs);
 
     encoded[0] = WMSFT_append_typedesc(&desc->tdescElem, file, NULL, NULL);
@@ -9619,17 +9365,17 @@ static DWORD WMSFT_append_typedesc(TYPEDESC *desc, WMSFT_TLBFile *file, DWORD *o
 
     if(vt == VT_PTR || vt == VT_SAFEARRAY){
         DWORD mix;
-        encoded[1] = WMSFT_append_typedesc(desc->u.lptdesc, file, &mix, out_size);
+        encoded[1] = WMSFT_append_typedesc(desc->lptdesc, file, &mix, out_size);
         encoded[0] = desc->vt | ((mix | VT_BYREF) << 16);
         *out_mix = 0x7FFF;
         *out_size += 2 * sizeof(DWORD);
     }else if(vt == VT_CARRAY){
         encoded[0] = desc->vt | (0x7FFE << 16);
-        encoded[1] = WMSFT_append_arraydesc(desc->u.lpadesc, file);
+        encoded[1] = WMSFT_append_arraydesc(desc->lpadesc, file);
         *out_mix = 0x7FFE;
     }else if(vt == VT_USERDEFINED){
         encoded[0] = desc->vt | (0x7FFF << 16);
-        encoded[1] = desc->u.hreftype;
+        encoded[1] = desc->hreftype;
         *out_mix = 0x7FFF; /* FIXME: Should get TYPEKIND of the hreftype, e.g. TKIND_ENUM => VT_I4 */
     }else{
         TRACE("Mixing in-place, VT: 0x%x\n", desc->vt);
@@ -9661,10 +9407,7 @@ static DWORD WMSFT_append_typedesc(TYPEDESC *desc, WMSFT_TLBFile *file, DWORD *o
     }
 
     file->typdesc_seg.len += sizeof(encoded);
-    if(!file->typdesc_seg.data)
-        data = file->typdesc_seg.data = heap_alloc(file->typdesc_seg.len);
-    else
-        data = file->typdesc_seg.data = heap_realloc(file->typdesc_seg.data, file->typdesc_seg.len);
+    data = file->typdesc_seg.data = realloc(file->typdesc_seg.data, file->typdesc_seg.len);
 
     memcpy(&data[offs], encoded, sizeof(encoded));
 
@@ -9682,12 +9425,8 @@ static DWORD WMSFT_compile_custdata(struct list *custdata_list, WMSFT_TLBFile *f
         return -1;
 
     cdguids_seg->len += sizeof(MSFT_CDGuid) * list_count(custdata_list);
-    if(!cdguids_seg->data){
-        cdguid = cdguids_seg->data = heap_alloc(cdguids_seg->len);
-    }else {
-        cdguids_seg->data = heap_realloc(cdguids_seg->data, cdguids_seg->len);
-        cdguid = (MSFT_CDGuid*)((char*)cdguids_seg->data + ret);
-    }
+    cdguids_seg->data = realloc(cdguids_seg->data, cdguids_seg->len);
+    cdguid = (MSFT_CDGuid*)((char*)cdguids_seg->data + ret);
 
     offs = ret + sizeof(MSFT_CDGuid);
     LIST_FOR_EACH_ENTRY(cd, custdata_list, TLBCustData, entry){
@@ -9736,7 +9475,7 @@ static DWORD WMSFT_compile_typeinfo_aux(ITypeInfoImpl *info,
         recorded_size += desc->funcdesc.cParams * sizeof(MSFT_ParameterInfo);
 
         for(j = 0; j < desc->funcdesc.cParams; ++j){
-            if(desc->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT){
+            if(desc->funcdesc.lprgelemdescParam[j].paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT){
                 recorded_size += desc->funcdesc.cParams * sizeof(INT);
                 break;
             }
@@ -9773,10 +9512,7 @@ static DWORD WMSFT_compile_typeinfo_aux(ITypeInfoImpl *info,
 
     aux_seg->len += sizeof(INT) * (info->typeattr.cVars + info->typeattr.cFuncs); /* offsets at the end */
 
-    if(aux_seg->data)
-        aux_seg->data = heap_realloc(aux_seg->data, aux_seg->len);
-    else
-        aux_seg->data = heap_alloc(aux_seg->len);
+    aux_seg->data = realloc(aux_seg->data, aux_seg->len);
 
     *((DWORD*)((char *)aux_seg->data + ret)) = recorded_size;
 
@@ -9812,7 +9548,7 @@ static DWORD WMSFT_compile_typeinfo_aux(ITypeInfoImpl *info,
             funcrecord->FKCCIC |= 0x2000;
 
         for(j = 0; j < desc->funcdesc.cParams; ++j){
-            if(desc->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT){
+            if(desc->funcdesc.lprgelemdescParam[j].paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT){
                 paramdefault_size = sizeof(INT) * desc->funcdesc.cParams;
                 funcrecord->funcdescsize += sizeof(PARAMDESCEX);
             }
@@ -9891,11 +9627,11 @@ static DWORD WMSFT_compile_typeinfo_aux(ITypeInfoImpl *info,
                 info->oName = desc->pParamDesc[j].Name->offset;
             else
                 info->oName = -1;
-            info->Flags = desc->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags;
+            info->Flags = desc->funcdesc.lprgelemdescParam[j].paramdesc.wParamFlags;
 
             if(paramdefault_size){
-                if(desc->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
-                    *paramdefault = WMSFT_encode_variant(&desc->funcdesc.lprgelemdescParam[j].u.paramdesc.pparamdescex->varDefaultValue, file);
+                if(desc->funcdesc.lprgelemdescParam[j].paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
+                    *paramdefault = WMSFT_encode_variant(&desc->funcdesc.lprgelemdescParam[j].paramdesc.pparamdescex->varDefaultValue, file);
                 else if(paramdefault_size)
                     *paramdefault = -1;
                 ++paramdefault;
@@ -9925,9 +9661,9 @@ static DWORD WMSFT_compile_typeinfo_aux(ITypeInfoImpl *info,
 
         if(desc->vardesc.varkind == VAR_CONST){
             varrecord->vardescsize += sizeof(VARIANT);
-            varrecord->OffsValue = WMSFT_encode_variant(desc->vardesc.u.lpvarValue, file);
+            varrecord->OffsValue = WMSFT_encode_variant(desc->vardesc.lpvarValue, file);
         }else
-            varrecord->OffsValue = desc->vardesc.u.oInst;
+            varrecord->OffsValue = desc->vardesc.oInst;
 
         /* res9? */
         if(desc->HelpStringContext != 0){
@@ -9982,7 +9718,7 @@ static DWORD WMSFT_compile_typeinfo_aux(ITypeInfoImpl *info,
         ++memid;
     }
 
-    name = (UINT*)memid;
+    name = (DWORD*)memid;
     for(i = 0; i < info->typeattr.cFuncs; ++i){
         TLBFuncDesc *desc = &info->funcdescs[i];
         if(desc->Name)
@@ -10016,10 +9752,7 @@ static DWORD WMSFT_compile_typeinfo_ref(ITypeInfoImpl *info, WMSFT_TLBFile *file
     WMSFT_RefChunk *chunk;
 
     file->ref_seg.len += info->typeattr.cImplTypes * sizeof(WMSFT_RefChunk);
-    if(!file->ref_seg.data)
-        file->ref_seg.data = heap_alloc(file->ref_seg.len);
-    else
-        file->ref_seg.data = heap_realloc(file->ref_seg.data, file->ref_seg.len);
+    file->ref_seg.data = realloc(file->ref_seg.data, file->ref_seg.len);
 
     chunk = (WMSFT_RefChunk*)((char*)file->ref_seg.data + offs);
 
@@ -10120,7 +9853,7 @@ static void WMSFT_compile_typeinfo_seg(ITypeLibImpl *This, WMSFT_TLBFile *file,
         file->typeinfo_seg.len += WMSFT_compile_typeinfo(info, i, NULL, NULL);
     }
 
-    file->typeinfo_seg.data = heap_alloc(file->typeinfo_seg.len);
+    file->typeinfo_seg.data = malloc(file->typeinfo_seg.len);
     memset(file->typeinfo_seg.data, 0x96, file->typeinfo_seg.len);
 
     file->aux_seg.len = 0;
@@ -10171,7 +9904,7 @@ static void WMSFT_compile_impfile(ITypeLibImpl *This, WMSFT_TLBFile *file)
         file->impfile_seg.len += sizeof(WMSFT_ImpFile) + size;
     }
 
-    data = file->impfile_seg.data = heap_alloc(file->impfile_seg.len);
+    data = file->impfile_seg.data = malloc(file->impfile_seg.len);
 
     LIST_FOR_EACH_ENTRY(implib, &This->implib_list, TLBImpLib, entry){
         int strlen = 0, size;
@@ -10219,7 +9952,7 @@ static void WMSFT_compile_impinfo(ITypeLibImpl *This, WMSFT_TLBFile *file)
     WMSFT_compile_impfile(This, file);
 
     file->impinfo_seg.len = sizeof(MSFT_ImpInfo) * list_count(&This->ref_list);
-    info = file->impinfo_seg.data = heap_alloc(file->impinfo_seg.len);
+    info = file->impinfo_seg.data = malloc(file->impinfo_seg.len);
 
     LIST_FOR_EACH_ENTRY(ref_type, &This->ref_list, TLBRefType, entry){
         info->flags = i | ((ref_type->tkind & 0xFF) << 24);
@@ -10237,14 +9970,14 @@ static void WMSFT_compile_impinfo(ITypeLibImpl *This, WMSFT_TLBFile *file)
 static void WMSFT_compile_guidhash(ITypeLibImpl *This, WMSFT_TLBFile *file)
 {
     file->guidhash_seg.len = 0x80;
-    file->guidhash_seg.data = heap_alloc(file->guidhash_seg.len);
+    file->guidhash_seg.data = malloc(file->guidhash_seg.len);
     memset(file->guidhash_seg.data, 0xFF, file->guidhash_seg.len);
 }
 
 static void WMSFT_compile_namehash(ITypeLibImpl *This, WMSFT_TLBFile *file)
 {
     file->namehash_seg.len = 0x200;
-    file->namehash_seg.data = heap_alloc(file->namehash_seg.len);
+    file->namehash_seg.data = malloc(file->namehash_seg.len);
     memset(file->namehash_seg.data, 0xFF, file->namehash_seg.len);
 }
 
@@ -10287,20 +10020,20 @@ static HRESULT WMSFT_fixup_typeinfos(ITypeLibImpl *This, WMSFT_TLBFile *file,
 
 static void WMSFT_free_file(WMSFT_TLBFile *file)
 {
-    HeapFree(GetProcessHeap(), 0, file->typeinfo_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->guidhash_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->guid_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->ref_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->impinfo_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->impfile_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->namehash_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->name_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->string_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->typdesc_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->arraydesc_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->custdata_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->cdguids_seg.data);
-    HeapFree(GetProcessHeap(), 0, file->aux_seg.data);
+    free(file->typeinfo_seg.data);
+    free(file->guidhash_seg.data);
+    free(file->guid_seg.data);
+    free(file->ref_seg.data);
+    free(file->impinfo_seg.data);
+    free(file->impfile_seg.data);
+    free(file->namehash_seg.data);
+    free(file->name_seg.data);
+    free(file->string_seg.data);
+    free(file->typdesc_seg.data);
+    free(file->arraydesc_seg.data);
+    free(file->custdata_seg.data);
+    free(file->cdguids_seg.data);
+    free(file->aux_seg.data);
 }
 
 static HRESULT WINAPI ICreateTypeLib2_fnSaveAllChanges(ICreateTypeLib2 *iface)
@@ -10390,7 +10123,7 @@ static HRESULT WINAPI ICreateTypeLib2_fnSaveAllChanges(ICreateTypeLib2 *iface)
     if(file.header.varflags & HELPDLLFLAG)
         junk_size += sizeof(DWORD);
     if(junk_size){
-        junk = heap_alloc_zero(junk_size);
+        junk = calloc(1, junk_size);
         if(file.header.varflags & HELPDLLFLAG){
             *junk = This->HelpStringDll->offset;
             junk_offs = 1;
@@ -10406,61 +10139,61 @@ static HRESULT WINAPI ICreateTypeLib2_fnSaveAllChanges(ICreateTypeLib2 *iface)
 
     running_offset = 0;
 
-    TRACE("header at: 0x%x\n", running_offset);
+    TRACE("header at: 0x%lx\n", running_offset);
     running_offset += sizeof(file.header);
 
-    TRACE("junk at: 0x%x\n", running_offset);
+    TRACE("junk at: 0x%lx\n", running_offset);
     running_offset += junk_size;
 
-    TRACE("segdir at: 0x%x\n", running_offset);
+    TRACE("segdir at: 0x%lx\n", running_offset);
     running_offset += sizeof(file.segdir);
 
-    TRACE("typeinfo at: 0x%x\n", running_offset);
+    TRACE("typeinfo at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pTypeInfoTab, &file.typeinfo_seg, &running_offset);
 
-    TRACE("guidhashtab at: 0x%x\n", running_offset);
+    TRACE("guidhashtab at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pGuidHashTab, &file.guidhash_seg, &running_offset);
 
-    TRACE("guidtab at: 0x%x\n", running_offset);
+    TRACE("guidtab at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pGuidTab, &file.guid_seg, &running_offset);
 
-    TRACE("reftab at: 0x%x\n", running_offset);
+    TRACE("reftab at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pRefTab, &file.ref_seg, &running_offset);
 
-    TRACE("impinfo at: 0x%x\n", running_offset);
+    TRACE("impinfo at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pImpInfo, &file.impinfo_seg, &running_offset);
 
-    TRACE("impfiles at: 0x%x\n", running_offset);
+    TRACE("impfiles at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pImpFiles, &file.impfile_seg, &running_offset);
 
-    TRACE("namehashtab at: 0x%x\n", running_offset);
+    TRACE("namehashtab at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pNameHashTab, &file.namehash_seg, &running_offset);
 
-    TRACE("nametab at: 0x%x\n", running_offset);
+    TRACE("nametab at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pNametab, &file.name_seg, &running_offset);
 
-    TRACE("stringtab at: 0x%x\n", running_offset);
+    TRACE("stringtab at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pStringtab, &file.string_seg, &running_offset);
 
-    TRACE("typdesc at: 0x%x\n", running_offset);
+    TRACE("typdesc at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pTypdescTab, &file.typdesc_seg, &running_offset);
 
-    TRACE("arraydescriptions at: 0x%x\n", running_offset);
+    TRACE("arraydescriptions at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pArrayDescriptions, &file.arraydesc_seg, &running_offset);
 
-    TRACE("custdata at: 0x%x\n", running_offset);
+    TRACE("custdata at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pCustData, &file.custdata_seg, &running_offset);
 
-    TRACE("cdguids at: 0x%x\n", running_offset);
+    TRACE("cdguids at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.pCDGuids, &file.cdguids_seg, &running_offset);
 
-    TRACE("res0e at: 0x%x\n", running_offset);
+    TRACE("res0e at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.res0e, NULL, &running_offset);
 
-    TRACE("res0f at: 0x%x\n", running_offset);
+    TRACE("res0f at: 0x%lx\n", running_offset);
     tmp_fill_segdir_seg(&file.segdir.res0f, NULL, &running_offset);
 
-    TRACE("aux_seg at: 0x%x\n", running_offset);
+    TRACE("aux_seg at: 0x%lx\n", running_offset);
 
     WMSFT_fixup_typeinfos(This, &file, running_offset);
 
@@ -10468,7 +10201,7 @@ static HRESULT WINAPI ICreateTypeLib2_fnSaveAllChanges(ICreateTypeLib2 *iface)
             FILE_ATTRIBUTE_NORMAL, 0);
     if (outfile == INVALID_HANDLE_VALUE){
         WMSFT_free_file(&file);
-        heap_free(junk);
+        free(junk);
         return TYPE_E_IOERROR;
     }
 
@@ -10476,12 +10209,12 @@ static HRESULT WINAPI ICreateTypeLib2_fnSaveAllChanges(ICreateTypeLib2 *iface)
     if (!br) {
         WMSFT_free_file(&file);
         CloseHandle(outfile);
-        heap_free(junk);
+        free(junk);
         return TYPE_E_IOERROR;
     }
 
     br = WriteFile(outfile, junk, junk_size, &written, NULL);
-    heap_free(junk);
+    free(junk);
     if (!br) {
         WMSFT_free_file(&file);
         CloseHandle(outfile);
@@ -10544,8 +10277,7 @@ static HRESULT WINAPI ICreateTypeLib2_fnSetCustData(ICreateTypeLib2 *iface,
 static HRESULT WINAPI ICreateTypeLib2_fnSetHelpStringContext(ICreateTypeLib2 *iface,
         ULONG helpStringContext)
 {
-    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
-    FIXME("%p %u - stub\n", This, helpStringContext);
+    FIXME("%p, %lu - stub\n", iface, helpStringContext);
     return E_NOTIMPL;
 }
 
@@ -10627,13 +10359,12 @@ static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeFlags(ICreateTypeInfo2 *iface,
     TRACE("%p %x\n", This, typeFlags);
 
     if (typeFlags & TYPEFLAG_FDUAL) {
-        static const WCHAR stdole2tlb[] = { 's','t','d','o','l','e','2','.','t','l','b',0 };
         ITypeLib *stdole;
         ITypeInfo *dispatch;
         HREFTYPE hreftype;
         HRESULT hres;
 
-        hres = LoadTypeLib(stdole2tlb, &stdole);
+        hres = LoadTypeLib(L"stdole2.tlb", &stdole);
         if(FAILED(hres))
             return hres;
 
@@ -10680,7 +10411,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnSetHelpContext(ICreateTypeInfo2 *iface,
 {
     ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
-    TRACE("%p %d\n", This, helpContext);
+    TRACE("%p, %ld.\n", iface, helpContext);
 
     This->dwHelpContext = helpContext;
 
@@ -10746,7 +10477,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddRefTypeInfo(ICreateTypeInfo2 *iface,
     }
 
     if(&implib->entry == &This->pTypeLib->implib_list){
-        implib = heap_alloc_zero(sizeof(TLBImpLib));
+        implib = calloc(1, sizeof(TLBImpLib));
 
         if((ITypeLib2Vtbl*)container->lpVtbl == &tlbvt){
             const ITypeLibImpl *our_container = impl_from_ITypeLib2((ITypeLib2*)container);
@@ -10756,7 +10487,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddRefTypeInfo(ICreateTypeInfo2 *iface,
                     libattr->wMinorVerNum, libattr->lcid, &implib->name);
             if(FAILED(hres)){
                 implib->name = NULL;
-                TRACE("QueryPathOfRegTypeLib failed, no name stored: %08x\n", hres);
+                TRACE("QueryPathOfRegTypeLib failed, no name stored: %#lx.\n", hres);
             }
         }
 
@@ -10785,7 +10516,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddRefTypeInfo(ICreateTypeInfo2 *iface,
     }
 
     if(&ref_type->entry == &This->pTypeLib->ref_list){
-        ref_type = heap_alloc_zero(sizeof(TLBRefType));
+        ref_type = calloc(1, sizeof(TLBRefType));
 
         ref_type->tkind = typeattr->typekind;
         ref_type->pImpTLInfo = implib;
@@ -10843,11 +10574,9 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddFuncDesc(ICreateTypeInfo2 *iface,
             !funcDesc->cParams)
         return TYPE_E_INCONSISTENTPROPFUNCS;
 
-#ifdef _WIN64
     if(This->pTypeLib->syskind == SYS_WIN64 &&
             funcDesc->oVft % 8 != 0)
         return E_INVALIDARG;
-#endif
 
     memset(&tmp_func_desc, 0, sizeof(tmp_func_desc));
     TLBFuncDesc_Constructor(&tmp_func_desc);
@@ -10858,7 +10587,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddFuncDesc(ICreateTypeInfo2 *iface,
         tmp_func_desc.funcdesc.oVft |= 1;
 
     if (funcDesc->cScodes && funcDesc->lprgscode) {
-        tmp_func_desc.funcdesc.lprgscode = heap_alloc(sizeof(SCODE) * funcDesc->cScodes);
+        tmp_func_desc.funcdesc.lprgscode = malloc(sizeof(SCODE) * funcDesc->cScodes);
         memcpy(tmp_func_desc.funcdesc.lprgscode, funcDesc->lprgscode, sizeof(SCODE) * funcDesc->cScodes);
     } else {
         tmp_func_desc.funcdesc.lprgscode = NULL;
@@ -10870,13 +10599,13 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddFuncDesc(ICreateTypeInfo2 *iface,
         buf_size += sizeof(ELEMDESC);
         buf_size += TLB_SizeElemDesc(funcDesc->lprgelemdescParam + i);
     }
-    tmp_func_desc.funcdesc.lprgelemdescParam = heap_alloc(buf_size);
+    tmp_func_desc.funcdesc.lprgelemdescParam = malloc(buf_size);
     buffer = (char*)(tmp_func_desc.funcdesc.lprgelemdescParam + funcDesc->cParams);
 
     hres = TLB_CopyElemDesc(&funcDesc->elemdescFunc, &tmp_func_desc.funcdesc.elemdescFunc, &buffer);
     if (FAILED(hres)) {
-        heap_free(tmp_func_desc.funcdesc.lprgelemdescParam);
-        heap_free(tmp_func_desc.funcdesc.lprgscode);
+        free(tmp_func_desc.funcdesc.lprgelemdescParam);
+        free(tmp_func_desc.funcdesc.lprgscode);
         return hres;
     }
 
@@ -10884,17 +10613,17 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddFuncDesc(ICreateTypeInfo2 *iface,
         hres = TLB_CopyElemDesc(funcDesc->lprgelemdescParam + i,
                 tmp_func_desc.funcdesc.lprgelemdescParam + i, &buffer);
         if (FAILED(hres)) {
-            heap_free(tmp_func_desc.funcdesc.lprgelemdescParam);
-            heap_free(tmp_func_desc.funcdesc.lprgscode);
+            free(tmp_func_desc.funcdesc.lprgelemdescParam);
+            free(tmp_func_desc.funcdesc.lprgscode);
             return hres;
         }
-        if (tmp_func_desc.funcdesc.lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT &&
+        if (tmp_func_desc.funcdesc.lprgelemdescParam[i].paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT &&
                 tmp_func_desc.funcdesc.lprgelemdescParam[i].tdesc.vt != VT_VARIANT &&
                 tmp_func_desc.funcdesc.lprgelemdescParam[i].tdesc.vt != VT_USERDEFINED){
-            hres = TLB_SanitizeVariant(&tmp_func_desc.funcdesc.lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
+            hres = TLB_SanitizeVariant(&tmp_func_desc.funcdesc.lprgelemdescParam[i].paramdesc.pparamdescex->varDefaultValue);
             if (FAILED(hres)) {
-                heap_free(tmp_func_desc.funcdesc.lprgelemdescParam);
-                heap_free(tmp_func_desc.funcdesc.lprgscode);
+                free(tmp_func_desc.funcdesc.lprgelemdescParam);
+                free(tmp_func_desc.funcdesc.lprgscode);
                 return hres;
             }
         }
@@ -10903,8 +10632,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddFuncDesc(ICreateTypeInfo2 *iface,
     tmp_func_desc.pParamDesc = TLBParDesc_Constructor(funcDesc->cParams);
 
     if (This->funcdescs) {
-        This->funcdescs = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->funcdescs,
-                sizeof(TLBFuncDesc) * (This->typeattr.cFuncs + 1));
+        This->funcdescs = realloc(This->funcdescs, sizeof(TLBFuncDesc) * (This->typeattr.cFuncs + 1));
 
         if (index < This->typeattr.cFuncs) {
             memmove(This->funcdescs + index + 1, This->funcdescs + index,
@@ -10915,18 +10643,11 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddFuncDesc(ICreateTypeInfo2 *iface,
 
         /* move custdata lists to the new memory location */
         for(i = 0; i < This->typeattr.cFuncs + 1; ++i){
-            if(index != i){
-                TLBFuncDesc *fd = &This->funcdescs[i];
-                if(fd->custdata_list.prev == fd->custdata_list.next)
-                    list_init(&fd->custdata_list);
-                else{
-                    fd->custdata_list.prev->next = &fd->custdata_list;
-                    fd->custdata_list.next->prev = &fd->custdata_list;
-                }
-            }
+            if(index != i)
+                TLB_relink_custdata(&This->funcdescs[i].custdata_list);
         }
     } else
-        func_desc = This->funcdescs = heap_alloc(sizeof(TLBFuncDesc));
+        func_desc = This->funcdescs = malloc(sizeof(TLBFuncDesc));
 
     memcpy(func_desc, &tmp_func_desc, sizeof(tmp_func_desc));
     list_init(&func_desc->custdata_list);
@@ -10945,7 +10666,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddImplType(ICreateTypeInfo2 *iface,
     TLBImplType *impl_type;
     HRESULT hres;
 
-    TRACE("%p %u %d\n", This, index, refType);
+    TRACE("%p, %u, %ld.\n", iface, index, refType);
 
     switch(This->typeattr.typekind){
         case TKIND_COCLASS: {
@@ -10972,8 +10693,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddImplType(ICreateTypeInfo2 *iface,
     if (This->impltypes){
         UINT i;
 
-        This->impltypes = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->impltypes,
-                sizeof(TLBImplType) * (This->typeattr.cImplTypes + 1));
+        This->impltypes = realloc(This->impltypes, sizeof(TLBImplType) * (This->typeattr.cImplTypes + 1));
 
         if (index < This->typeattr.cImplTypes) {
             memmove(This->impltypes + index + 1, This->impltypes + index,
@@ -10984,18 +10704,11 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddImplType(ICreateTypeInfo2 *iface,
 
         /* move custdata lists to the new memory location */
         for(i = 0; i < This->typeattr.cImplTypes + 1; ++i){
-            if(index != i){
-                TLBImplType *it = &This->impltypes[i];
-                if(it->custdata_list.prev == it->custdata_list.next)
-                    list_init(&it->custdata_list);
-                else{
-                    it->custdata_list.prev->next = &it->custdata_list;
-                    it->custdata_list.next->prev = &it->custdata_list;
-                }
-            }
+            if(index != i)
+                TLB_relink_custdata(&This->impltypes[i].custdata_list);
         }
     } else
-        impl_type = This->impltypes = heap_alloc(sizeof(TLBImplType));
+        impl_type = This->impltypes = malloc(sizeof(TLBImplType));
 
     memset(impl_type, 0, sizeof(TLBImplType));
     TLBImplType_Constructor(impl_type);
@@ -11066,39 +10779,36 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddVarDesc(ICreateTypeInfo2 *iface,
 {
     ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
     TLBVarDesc *var_desc;
+    HRESULT hr;
 
     TRACE("%p %u %p\n", This, index, varDesc);
 
     if (This->vardescs){
         UINT i;
 
-        This->vardescs = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->vardescs,
-                sizeof(TLBVarDesc) * (This->typeattr.cVars + 1));
+        This->vardescs = realloc(This->vardescs, sizeof(TLBVarDesc) * (This->typeattr.cVars + 1));
 
         if (index < This->typeattr.cVars) {
             memmove(This->vardescs + index + 1, This->vardescs + index,
                     (This->typeattr.cVars - index) * sizeof(TLBVarDesc));
             var_desc = This->vardescs + index;
-        } else
+        } else {
             var_desc = This->vardescs + This->typeattr.cVars;
+            memset(var_desc, 0, sizeof(TLBVarDesc));
+        }
 
         /* move custdata lists to the new memory location */
         for(i = 0; i < This->typeattr.cVars + 1; ++i){
-            if(index != i){
-                TLBVarDesc *var = &This->vardescs[i];
-                if(var->custdata_list.prev == var->custdata_list.next)
-                    list_init(&var->custdata_list);
-                else{
-                    var->custdata_list.prev->next = &var->custdata_list;
-                    var->custdata_list.next->prev = &var->custdata_list;
-                }
-            }
+            if(index != i)
+                TLB_relink_custdata(&This->vardescs[i].custdata_list);
         }
     } else
-        var_desc = This->vardescs = heap_alloc_zero(sizeof(TLBVarDesc));
+        var_desc = This->vardescs = calloc(1, sizeof(TLBVarDesc));
 
     TLBVarDesc_Constructor(var_desc);
-    TLB_AllocAndInitVarDesc(varDesc, &var_desc->vardesc_create);
+    hr = TLB_AllocAndInitVarDesc(varDesc, &var_desc->vardesc_create);
+    if (FAILED(hr))
+        return hr;
     var_desc->vardesc = *var_desc->vardesc_create;
 
     ++This->typeattr.cVars;
@@ -11186,8 +10896,8 @@ static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeDescAlias(ICreateTypeInfo2 *ifac
     if(FAILED(hr))
         return hr;
 
-    heap_free(This->tdescAlias);
-    This->tdescAlias = heap_alloc(TLB_SizeTypeDesc(tdescAlias, TRUE));
+    free(This->tdescAlias);
+    This->tdescAlias = malloc(TLB_SizeTypeDesc(tdescAlias, TRUE));
     TLB_CopyTypeDesc(NULL, tdescAlias, This->tdescAlias);
 
     return S_OK;
@@ -11245,7 +10955,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncHelpContext(ICreateTypeInfo2 *if
     ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
     TLBFuncDesc *func_desc = &This->funcdescs[index];
 
-    TRACE("%p %u %d\n", This, index, helpContext);
+    TRACE("%p, %u, %ld.\n", iface, index, helpContext);
 
     if(index >= This->typeattr.cFuncs)
         return TYPE_E_ELEMENTNOTFOUND;
@@ -11261,7 +10971,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnSetVarHelpContext(ICreateTypeInfo2 *ifa
     ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
     TLBVarDesc *var_desc = &This->vardescs[index];
 
-    TRACE("%p %u %d\n", This, index, helpContext);
+    TRACE("%p, %u, %ld.\n", iface, index, helpContext);
 
     if(index >= This->typeattr.cVars)
         return TYPE_E_ELEMENTNOTFOUND;
@@ -11298,7 +11008,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeIdldesc(ICreateTypeInfo2 *iface,
 static HRESULT WINAPI ICreateTypeInfo2_fnLayOut(ICreateTypeInfo2 *iface)
 {
     ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
-    ITypeInfo *tinfo;
+    ITypeInfo2 *tinfo = &This->ITypeInfo2_iface;
     TLBFuncDesc *func_desc;
     UINT user_vft = 0, i, depth = 0;
     HRESULT hres = S_OK;
@@ -11307,25 +11017,20 @@ static HRESULT WINAPI ICreateTypeInfo2_fnLayOut(ICreateTypeInfo2 *iface)
 
     This->needs_layout = FALSE;
 
-    hres = ICreateTypeInfo2_QueryInterface(iface, &IID_ITypeInfo, (LPVOID*)&tinfo);
-    if (FAILED(hres))
-        return hres;
-
     if (This->typeattr.typekind == TKIND_INTERFACE) {
         ITypeInfo *inh;
         TYPEATTR *attr;
         HREFTYPE inh_href;
 
-        hres = ITypeInfo_GetRefTypeOfImplType(tinfo, 0, &inh_href);
+        hres = ITypeInfo2_GetRefTypeOfImplType(tinfo, 0, &inh_href);
 
         if (SUCCEEDED(hres)) {
-            hres = ITypeInfo_GetRefTypeInfo(tinfo, inh_href, &inh);
+            hres = ITypeInfo2_GetRefTypeInfo(tinfo, inh_href, &inh);
 
             if (SUCCEEDED(hres)) {
                 hres = ITypeInfo_GetTypeAttr(inh, &attr);
                 if (FAILED(hres)) {
                     ITypeInfo_Release(inh);
-                    ITypeInfo_Release(tinfo);
                     return hres;
                 }
                 This->typeattr.cbSizeVft = attr->cbSizeVft;
@@ -11349,17 +11054,13 @@ static HRESULT WINAPI ICreateTypeInfo2_fnLayOut(ICreateTypeInfo2 *iface)
             } else if (hres == TYPE_E_ELEMENTNOTFOUND) {
                 This->typeattr.cbSizeVft = 0;
                 hres = S_OK;
-            } else {
-                ITypeInfo_Release(tinfo);
+            } else
                 return hres;
-            }
         } else if (hres == TYPE_E_ELEMENTNOTFOUND) {
             This->typeattr.cbSizeVft = 0;
             hres = S_OK;
-        } else {
-            ITypeInfo_Release(tinfo);
+        } else
             return hres;
-        }
     } else if (This->typeattr.typekind == TKIND_DISPATCH)
         This->typeattr.cbSizeVft = 7 * This->pTypeLib->ptr_size;
     else
@@ -11434,7 +11135,6 @@ static HRESULT WINAPI ICreateTypeInfo2_fnLayOut(ICreateTypeInfo2 *iface)
         }
     }
 
-    ITypeInfo_Release(tinfo);
     return hres;
 }
 
@@ -11442,31 +11142,47 @@ static HRESULT WINAPI ICreateTypeInfo2_fnDeleteFuncDesc(ICreateTypeInfo2 *iface,
         UINT index)
 {
     ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
-    FIXME("%p %u - stub\n", This, index);
-    return E_NOTIMPL;
+    unsigned int i;
+
+    TRACE("%p %u\n", This, index);
+
+    if (index >= This->typeattr.cFuncs)
+        return TYPE_E_ELEMENTNOTFOUND;
+
+    typeinfo_release_funcdesc(&This->funcdescs[index]);
+
+    --This->typeattr.cFuncs;
+    if (index != This->typeattr.cFuncs)
+    {
+        memmove(This->funcdescs + index, This->funcdescs + index + 1,
+                sizeof(*This->funcdescs) * (This->typeattr.cFuncs - index));
+        for (i = index; i < This->typeattr.cFuncs; ++i)
+            TLB_relink_custdata(&This->funcdescs[i].custdata_list);
+    }
+
+    This->needs_layout = TRUE;
+
+    return S_OK;
 }
 
 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteFuncDescByMemId(ICreateTypeInfo2 *iface,
         MEMBERID memid, INVOKEKIND invKind)
 {
-    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
-    FIXME("%p %x %d - stub\n", This, memid, invKind);
+    FIXME("%p, %#lx, %d - stub\n", iface, memid, invKind);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteVarDesc(ICreateTypeInfo2 *iface,
         UINT index)
 {
-    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
-    FIXME("%p %u - stub\n", This, index);
+    FIXME("%p, %u - stub\n", iface, index);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteVarDescByMemId(ICreateTypeInfo2 *iface,
         MEMBERID memid)
 {
-    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
-    FIXME("%p %x - stub\n", This, memid);
+    FIXME("%p, %#lx - stub\n", iface, memid);
     return E_NOTIMPL;
 }
 
@@ -11474,8 +11190,25 @@ static HRESULT WINAPI ICreateTypeInfo2_fnDeleteImplType(ICreateTypeInfo2 *iface,
         UINT index)
 {
     ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
-    FIXME("%p %u - stub\n", This, index);
-    return E_NOTIMPL;
+    int i;
+
+    TRACE("%p %u\n", This, index);
+
+    if (index >= This->typeattr.cImplTypes)
+        return TYPE_E_ELEMENTNOTFOUND;
+
+    TLB_FreeCustData(&This->impltypes[index].custdata_list);
+    --This->typeattr.cImplTypes;
+
+    if (index < This->typeattr.cImplTypes)
+    {
+        memmove(This->impltypes + index, This->impltypes + index + 1, (This->typeattr.cImplTypes - index) *
+                sizeof(*This->impltypes));
+        for (i = index; i < This->typeattr.cImplTypes; ++i)
+            TLB_relink_custdata(&This->impltypes[i].custdata_list);
+    }
+
+    return S_OK;
 }
 
 static HRESULT WINAPI ICreateTypeInfo2_fnSetCustData(ICreateTypeInfo2 *iface,
@@ -11532,7 +11265,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnSetHelpStringContext(ICreateTypeInfo2 *
 {
     ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
-    TRACE("%p %u\n", This, helpStringContext);
+    TRACE("%p, %lu.\n", iface, helpStringContext);
 
     This->dwHelpStringContext = helpStringContext;
 
@@ -11542,23 +11275,20 @@ static HRESULT WINAPI ICreateTypeInfo2_fnSetHelpStringContext(ICreateTypeInfo2 *
 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncHelpStringContext(ICreateTypeInfo2 *iface,
         UINT index, ULONG helpStringContext)
 {
-    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
-    FIXME("%p %u %u - stub\n", This, index, helpStringContext);
+    FIXME("%p, %u, %lu - stub\n", iface, index, helpStringContext);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarHelpStringContext(ICreateTypeInfo2 *iface,
         UINT index, ULONG helpStringContext)
 {
-    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
-    FIXME("%p %u %u - stub\n", This, index, helpStringContext);
+    FIXME("%p, %u, %lu - stub\n", iface, index, helpStringContext);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI ICreateTypeInfo2_fnInvalidate(ICreateTypeInfo2 *iface)
 {
-    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
-    FIXME("%p - stub\n", This);
+    FIXME("%p - stub\n", iface);
     return E_NOTIMPL;
 }
 
diff --git a/dll/win32/oleaut32/typelib.h b/dll/win32/oleaut32/typelib.h
index 4ab8055bd2a..515d4b557e6 100644
--- a/dll/win32/oleaut32/typelib.h
+++ b/dll/win32/oleaut32/typelib.h
@@ -309,10 +309,7 @@ typedef struct {
 /*08*/  WORD res08;             /* some kind of len/offset ?? */
 /*0a*/	WORD first_blk;		/* 1 based index into blk entries that
 				   corresponds to first block in file */
-/*0c*/	DWORD res0c;		/* always 0x000204ff */
-/*10*/  DWORD res10;		/* always 0x00000000 */
-/*14*/	DWORD res14;		/* always 0x000000c0 */
-/*18*/	DWORD res18;		/* always 0x46000000 */
+/*0c*/	GUID guid;		/* always 000204ff-0000-0000-c000-000000000046 */
 /*1c*/	DWORD res1c;		/* always 0x00000044 */
 /*20*/	DWORD res20;		/* always 0xffff0000 */
 } SLTG_Header;
@@ -325,16 +322,15 @@ typedef struct {
 } SLTG_BlkEntry;
 
 /* The order of the blocks in the file is given by starting at Block
-   entry firt_blk and stepping through using the next pointer */
+   entry first_blk and stepping through using the next pointer */
 
 /* These then get followed by this magic */
 typedef struct {
-/*00*/ BYTE res00;		/* always 0x01 */
-/*01*/ CHAR CompObj_magic[8];	/* always "CompObj" */
+/*00*/ CHAR CompObj_magic[9];	/* always "\1CompObj" */
 /*09*/ CHAR dir_magic[4];	/* always "dir" */
 } SLTG_Magic;
 
-#define SLTG_COMPOBJ_MAGIC "CompObj"
+#define SLTG_COMPOBJ_MAGIC "\1CompObj"
 #define SLTG_DIR_MAGIC "dir"
 
 /* Next we have SLTG_Header.nrOfFileBlks - 2 of Index strings.  These
@@ -386,18 +382,18 @@ typedef struct {
 /* we then get 0x40 bytes worth of 0xffff or small numbers followed by
    nrOfFileBlks - 2 of these */
 typedef struct {
+	WORD small_no;
 	SLTG_Name index_name; /* This refers to a name in the directory */
 	SLTG_Name other_name; /* Another one of these weird names */
 	WORD res1a;	      /* 0xffff */
 	WORD name_offs;	      /* offset to name in name table */
-	WORD hlpstr_len;      /* if this is non-zero we get this many
+	WORD more_bytes;      /* if this is non-zero we get this many
 				 bytes before the next element, which seem
 				 to reference the docstring of the type ? */
 	WORD res20;	      /* 0xffff */
 	DWORD helpcontext;
 	WORD res26;	      /* 0xffff */
         GUID uuid;
-        WORD typekind;
 } SLTG_OtherTypeInfo;
 
 /* Next we get WORD 0x0003 followed by a DWORD which if we add to
diff --git a/dll/win32/oleaut32/usrmarshal.c b/dll/win32/oleaut32/usrmarshal.c
index 43c30088cfd..619b5955815 100644
--- a/dll/win32/oleaut32/usrmarshal.c
+++ b/dll/win32/oleaut32/usrmarshal.c
@@ -23,8 +23,6 @@
 #include <string.h>
 
 #define COBJMACROS
-#define NONAMELESSUNION
-
 #include "windef.h"
 #include "winbase.h"
 #include "wingdi.h"
@@ -102,7 +100,7 @@ unsigned char * WINAPI CLEANLOCALSTORAGE_UserMarshal(ULONG *pFlags, unsigned cha
         break;
 
     default:
-        ERR("Unknown type %x\n", pstg->flags);
+        ERR("Unknown type %lx\n", pstg->flags);
     }
 
     *(VOID**)pstg->pStorage = NULL;
@@ -135,11 +133,11 @@ typedef struct
 
 ULONG WINAPI BSTR_UserSize(ULONG *pFlags, ULONG Start, BSTR *pstr)
 {
-    TRACE("(%x,%d,%p) => %p\n", *pFlags, Start, pstr, *pstr);
+    TRACE("%#lx, %lu, %p => %p\n", *pFlags, Start, pstr, *pstr);
     if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
     ALIGN_LENGTH(Start, 3);
     Start += sizeof(bstr_wire_t) + ((SysStringByteLen(*pstr) + 1) & ~1);
-    TRACE("returning %d\n", Start);
+    TRACE("returning %ld\n", Start);
     return Start;
 }
 
@@ -148,7 +146,7 @@ unsigned char * WINAPI BSTR_UserMarshal(ULONG *pFlags, unsigned char *Buffer, BS
     bstr_wire_t *header;
     DWORD len = SysStringByteLen(*pstr);
 
-    TRACE("(%x,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
+    TRACE("%#lx, %p, %p => %p\n", *pFlags, Buffer, pstr, *pstr);
     if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
 
     ALIGN_POINTER(Buffer, 3);
@@ -168,12 +166,12 @@ unsigned char * WINAPI BSTR_UserMarshal(ULONG *pFlags, unsigned char *Buffer, BS
 unsigned char * WINAPI BSTR_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
 {
     bstr_wire_t *header;
-    TRACE("(%x,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
+    TRACE("%#lx, %p, %p => %p\n", *pFlags, Buffer, pstr, *pstr);
 
     ALIGN_POINTER(Buffer, 3);
     header = (bstr_wire_t*)Buffer;
     if(header->len != header->len2)
-        FIXME("len %08x != len2 %08x\n", header->len, header->len2);
+        FIXME("len %#lx != len2 %#lx\n", header->len, header->len2);
 
     if (header->byte_len == 0xffffffff)
     {
@@ -188,7 +186,7 @@ unsigned char * WINAPI BSTR_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer,
 
 void WINAPI BSTR_UserFree(ULONG *pFlags, BSTR *pstr)
 {
-    TRACE("(%x,%p) => %p\n", *pFlags, pstr, *pstr);
+    TRACE("%#lx, %p => %p\n", *pFlags, pstr, *pstr);
     SysFreeString(*pstr);
     *pstr = NULL;
 }
@@ -268,11 +266,7 @@ static unsigned int get_type_alignment(ULONG *pFlags, VARTYPE vt)
 }
 
 /* WdtpInterfacePointer_UserSize takes care of 2 additional DWORDs to store marshalling buffer size */
-#ifdef __REACTOS__
 static unsigned interface_user_size(ULONG *pFlags, ULONG Start, REFIID riid, IUnknown *punk)
-#else
-static unsigned interface_variant_size(ULONG *pFlags, REFIID riid, IUnknown *punk)
-#endif
 {
     ULONG size = 0;
 
@@ -286,12 +280,8 @@ static unsigned interface_variant_size(ULONG *pFlags, REFIID riid, IUnknown *pun
         }
     }
     size += sizeof(ULONG);
-    TRACE("wire-size extra of interface variant is %d\n", size);
-#ifdef __REACTOS__
+    TRACE("wire-size extra of interface variant is %ld.\n", size);
     return Start + size;
-#else
-    return size;
-#endif
 }
 
 static ULONG wire_extra_user_size(ULONG *pFlags, ULONG Start, VARIANT *pvar)
@@ -312,29 +302,13 @@ static ULONG wire_extra_user_size(ULONG *pFlags, ULONG Start, VARIANT *pvar)
   case VT_VARIANT | VT_BYREF:
     return VARIANT_UserSize(pFlags, Start, V_VARIANTREF(pvar));
   case VT_UNKNOWN:
-#ifdef __REACTOS__
     return interface_user_size(pFlags, Start, &IID_IUnknown, V_UNKNOWN(pvar));
-#else
-    return Start + interface_variant_size(pFlags, &IID_IUnknown, V_UNKNOWN(pvar));
-#endif
   case VT_UNKNOWN | VT_BYREF:
-#ifdef __REACTOS__
     return interface_user_size(pFlags, Start, &IID_IUnknown, *V_UNKNOWNREF(pvar));
-#else
-    return Start + interface_variant_size(pFlags, &IID_IUnknown, *V_UNKNOWNREF(pvar));
-#endif
   case VT_DISPATCH:
-#ifdef __REACTOS__
     return interface_user_size(pFlags, Start, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
-#else
-    return Start + interface_variant_size(pFlags, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
-#endif
   case VT_DISPATCH | VT_BYREF:
-#ifdef __REACTOS__
     return interface_user_size(pFlags, Start, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
-#else
-    return Start + interface_variant_size(pFlags, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
-#endif
   case VT_RECORD:
     FIXME("wire-size record\n");
     return Start;
@@ -348,14 +322,10 @@ static ULONG wire_extra_user_size(ULONG *pFlags, ULONG Start, VARIANT *pvar)
 }
 
 /* helper: called for VT_DISPATCH variants to marshal the IDispatch* into the buffer */
-#ifdef __REACTOS__
 static unsigned char* interface_user_marshal(ULONG *pFlags, unsigned char *Buffer,
-#else
-static unsigned char* interface_variant_marshal(ULONG *pFlags, unsigned char *Buffer,
-#endif
                                                 REFIID riid, IUnknown *punk)
 {
-  TRACE("pFlags=%d, Buffer=%p, pUnk=%p\n", *pFlags, Buffer, punk);
+  TRACE("%#lx, %p, %p.\n", *pFlags, Buffer, punk);
 
   /* first DWORD is used to store pointer itself, truncated on win64 */
   if(!punk)
@@ -373,16 +343,12 @@ static unsigned char* interface_variant_marshal(ULONG *pFlags, unsigned char *Bu
 }
 
 /* helper: called for VT_DISPATCH / VT_UNKNOWN variants to unmarshal the buffer */
-#ifdef __REACTOS__
 static unsigned char *interface_user_unmarshal(ULONG *pFlags, unsigned char *Buffer,
-#else
-static unsigned char *interface_variant_unmarshal(ULONG *pFlags, unsigned char *Buffer,
-#endif
                                                   REFIID riid, IUnknown **ppunk)
 {
   DWORD ptr;
   
-  TRACE("pFlags=%d, Buffer=%p, ppUnk=%p\n", *pFlags, Buffer, ppunk);
+  TRACE("%#lx, %p, %p.\n", *pFlags, Buffer, ppunk);
 
   /* skip pointer part itself */
   ptr = *(DWORD*)Buffer;
@@ -397,7 +363,7 @@ static unsigned char *interface_variant_unmarshal(ULONG *pFlags, unsigned char *
 ULONG WINAPI VARIANT_UserSize(ULONG *pFlags, ULONG Start, VARIANT *pvar)
 {
     int align;
-    TRACE("(%x,%d,%p)\n", *pFlags, Start, pvar);
+    TRACE("%#lx, %lu, %p.\n", *pFlags, Start, pvar);
     TRACE("vt=%04x\n", V_VT(pvar));
 
     ALIGN_LENGTH(Start, 7);
@@ -413,7 +379,7 @@ ULONG WINAPI VARIANT_UserSize(ULONG *pFlags, ULONG Start, VARIANT *pvar)
         Start += get_type_size(pFlags, V_VT(pvar));
     Start = wire_extra_user_size(pFlags, Start, pvar);
 
-    TRACE("returning %d\n", Start);
+    TRACE("returning %ld\n", Start);
     return Start;
 }
 
@@ -424,7 +390,7 @@ unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer,
     int align;
     unsigned char *Pos;
 
-    TRACE("(%x,%p,%p)\n", *pFlags, Buffer, pvar);
+    TRACE("%#lx, %p, %p.\n", *pFlags, Buffer, pvar);
     TRACE("vt=%04x\n", V_VT(pvar));
 
     ALIGN_POINTER(Buffer, 7);
@@ -433,11 +399,17 @@ unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer,
 
     header->clSize = 0; /* fixed up at the end */
     header->rpcReserved = 0;
-    header->vt = pvar->n1.n2.vt;
+    header->vt = V_VT(pvar);
+#ifdef __REACTOS__
     header->wReserved1 = pvar->n1.n2.wReserved1;
     header->wReserved2 = pvar->n1.n2.wReserved2;
     header->wReserved3 = pvar->n1.n2.wReserved3;
-    header->switch_is = pvar->n1.n2.vt;
+#else
+    header->wReserved1 = pvar->wReserved1;
+    header->wReserved2 = pvar->wReserved2;
+    header->wReserved3 = pvar->wReserved3;
+#endif
+    header->switch_is = V_VT(pvar);
     if(header->switch_is & VT_ARRAY)
         header->switch_is &= ~VT_TYPEMASK;
 
@@ -452,7 +424,7 @@ unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer,
         Pos += 4;
         if((header->vt & VT_TYPEMASK) != VT_VARIANT)
         {
-            memcpy(Pos, pvar->n1.n2.n3.byref, type_size);
+            memcpy(Pos, V_BYREF(pvar), type_size);
             Pos += type_size;
         }
         else
@@ -466,7 +438,7 @@ unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer,
         if((header->vt & VT_TYPEMASK) == VT_DECIMAL)
             memcpy(Pos, pvar, type_size);
         else
-            memcpy(Pos, &pvar->n1.n2.n3, type_size);
+            memcpy(Pos, &V_UI8(pvar), type_size);
         Pos += type_size;
     }
 
@@ -491,32 +463,16 @@ unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer,
             Pos = VARIANT_UserMarshal(pFlags, Pos, V_VARIANTREF(pvar));
             break;
         case VT_UNKNOWN:
-#ifdef __REACTOS__
             Pos = interface_user_marshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWN(pvar));
-#else
-            Pos = interface_variant_marshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWN(pvar));
-#endif
             break;
         case VT_UNKNOWN | VT_BYREF:
-#ifdef __REACTOS__
             Pos = interface_user_marshal(pFlags, Pos, &IID_IUnknown, *V_UNKNOWNREF(pvar));
-#else
-            Pos = interface_variant_marshal(pFlags, Pos, &IID_IUnknown, *V_UNKNOWNREF(pvar));
-#endif
             break;
         case VT_DISPATCH:
-#ifdef __REACTOS__
             Pos = interface_user_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
-#else
-            Pos = interface_variant_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
-#endif
             break;
         case VT_DISPATCH | VT_BYREF:
-#ifdef __REACTOS__
             Pos = interface_user_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
-#else
-            Pos = interface_variant_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
-#endif
             break;
         case VT_RECORD:
             FIXME("handle BRECORD by val\n");
@@ -527,7 +483,7 @@ unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer,
         }
     }
     header->clSize = ((Pos - Buffer) + 7) >> 3;
-    TRACE("marshalled size=%d\n", header->clSize);
+    TRACE("marshalled size %ld\n", header->clSize);
     return Pos;
 }
 
@@ -538,7 +494,7 @@ unsigned char * WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffe
     int align;
     unsigned char *Pos;
 
-    TRACE("(%x,%p,%p)\n", *pFlags, Buffer, pvar);
+    TRACE("%#lx, %p, %p.\n", *pFlags, Buffer, pvar);
 
     ALIGN_POINTER(Buffer, 7);
 
@@ -554,7 +510,10 @@ unsigned char * WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffe
         ULONG mem_size;
         Pos += 4;
 
-        switch (header->vt & ~VT_BYREF)
+        /* byref array needs to allocate a SAFEARRAY pointer */
+        if (header->vt & VT_ARRAY)
+            mem_size = sizeof(void *);
+        else switch (header->vt & ~VT_BYREF)
         {
         /* these types have a different memory size compared to wire size */
         case VT_UNKNOWN:
@@ -608,14 +567,20 @@ unsigned char * WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffe
         else if((header->vt & VT_TYPEMASK) == VT_DECIMAL)
             memcpy(pvar, Pos, type_size);
         else
-            memcpy(&pvar->n1.n2.n3, Pos, type_size);
+            memcpy(&V_UI8(pvar), Pos, type_size);
         Pos += type_size;
     }
 
-    pvar->n1.n2.vt = header->vt;
+    V_VT(pvar) = header->vt;
+#ifdef __REACTOS__
     pvar->n1.n2.wReserved1 = header->wReserved1;
     pvar->n1.n2.wReserved2 = header->wReserved2;
     pvar->n1.n2.wReserved3 = header->wReserved3;
+#else
+    pvar->wReserved1 = header->wReserved1;
+    pvar->wReserved2 = header->wReserved2;
+    pvar->wReserved3 = header->wReserved3;
+#endif
 
     if(header->vt & VT_ARRAY)
     {
@@ -638,32 +603,16 @@ unsigned char * WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffe
             Pos = VARIANT_UserUnmarshal(pFlags, Pos, V_VARIANTREF(pvar));
             break;
         case VT_UNKNOWN:
-#ifdef __REACTOS__
             Pos = interface_user_unmarshal(pFlags, Pos, &IID_IUnknown, &V_UNKNOWN(pvar));
-#else
-            Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IUnknown, &V_UNKNOWN(pvar));
-#endif
             break;
         case VT_UNKNOWN | VT_BYREF:
-#ifdef __REACTOS__
             Pos = interface_user_unmarshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWNREF(pvar));
-#else
-            Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWNREF(pvar));
-#endif
             break;
         case VT_DISPATCH:
-#ifdef __REACTOS__
             Pos = interface_user_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)&V_DISPATCH(pvar));
-#else
-            Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)&V_DISPATCH(pvar));
-#endif
             break;
         case VT_DISPATCH | VT_BYREF:
-#ifdef __REACTOS__
             Pos = interface_user_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)V_DISPATCHREF(pvar));
-#else
-            Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)V_DISPATCHREF(pvar));
-#endif
             break;
         case VT_RECORD:
             FIXME("handle BRECORD by val\n");
@@ -681,10 +630,10 @@ void WINAPI VARIANT_UserFree(ULONG *pFlags, VARIANT *pvar)
   VARTYPE vt = V_VT(pvar);
   PVOID ref = NULL;
 
-  TRACE("(%x,%p)\n", *pFlags, pvar);
+  TRACE("%#lx, %p.\n", *pFlags, pvar);
   TRACE("vt=%04x\n", V_VT(pvar));
 
-  if (vt & VT_BYREF) ref = pvar->n1.n2.n3.byref;
+  if (vt & VT_BYREF) ref = V_BYREF(pvar);
 
   VariantClear(pvar);
   if (!ref) return;
@@ -797,39 +746,24 @@ static inline SF_TYPE SAFEARRAY_GetUnionType(SAFEARRAY *psa)
 
 static DWORD elem_wire_size(LPSAFEARRAY lpsa, SF_TYPE sftype)
 {
-#ifdef __REACTOS__
     switch (sftype)
     {
     case SF_BSTR:
     case SF_HAVEIID:
     case SF_UNKNOWN:
     case SF_DISPATCH:
-#else
-    if (sftype == SF_BSTR)
-#endif
         return sizeof(DWORD);
-#ifdef __REACTOS__
 
     case SF_VARIANT:
-#else
-    else if (sftype == SF_VARIANT)
-#endif
         return sizeof(variant_wire_t) - sizeof(DWORD);
-#ifdef __REACTOS__
 
     default:
-#else
-    else
-#endif
         return lpsa->cbElements;
-#ifdef __REACTOS__
     }
-#endif
 }
 
 static DWORD elem_mem_size(wireSAFEARRAY wiresa, SF_TYPE sftype)
 {
-#ifdef __REACTOS__
     switch (sftype)
     {
     case SF_HAVEIID:
@@ -838,34 +772,21 @@ static DWORD elem_mem_size(wireSAFEARRAY wiresa, SF_TYPE sftype)
         return sizeof(void *);
 
     case SF_BSTR:
-#else
-    if (sftype == SF_BSTR)
-#endif
         return sizeof(BSTR);
-#ifdef __REACTOS__
 
     case SF_VARIANT:
-#else
-    else if (sftype == SF_VARIANT)
-#endif
         return sizeof(VARIANT);
-#ifdef __REACTOS__
 
     default:
-#else
-    else
-#endif
         return wiresa->cbElements;
-#ifdef __REACTOS__
     }
-#endif
 }
 
 ULONG WINAPI LPSAFEARRAY_UserSize(ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY *ppsa)
 {
     ULONG size = StartingSize;
 
-    TRACE("("); dump_user_flags(pFlags); TRACE(", %d, %p\n", StartingSize, *ppsa);
+    TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, *ppsa);
 
     ALIGN_LENGTH(size, 3);
     size += sizeof(ULONG);
@@ -905,7 +826,6 @@ ULONG WINAPI LPSAFEARRAY_UserSize(ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY
             case SF_DISPATCH:
             case SF_UNKNOWN:
             case SF_HAVEIID:
-#ifdef __REACTOS__
             {
                 IUnknown **lpUnk;
                 GUID guid;
@@ -920,13 +840,8 @@ ULONG WINAPI LPSAFEARRAY_UserSize(ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY
                 for (lpUnk = psa->pvData; ulCellCount; ulCellCount--, lpUnk++)
                     size = interface_user_size(pFlags, size, &guid, *lpUnk);
 
-#else
-                FIXME("size interfaces\n");
-#endif
                 break;
-#ifdef __REACTOS__
             }
-#endif
             case SF_VARIANT:
             {
                 VARIANT* lpVariant;
@@ -1000,11 +915,7 @@ unsigned char * WINAPI LPSAFEARRAY_UserMarshal(ULONG *pFlags, unsigned char *Buf
         Buffer += sizeof(ULONG);
 
         hr = SafeArrayGetVartype(psa, &vt);
-#ifdef __REACTOS__
         if ((psa->fFeatures & FADF_HAVEIID) || FAILED(hr)) vt = 0;
-#else
-        if (FAILED(hr)) vt = 0;
-#endif
 
         *(ULONG *)Buffer = (USHORT)psa->cLocks | (vt << 16);
         Buffer += sizeof(ULONG);
@@ -1050,7 +961,6 @@ unsigned char * WINAPI LPSAFEARRAY_UserMarshal(ULONG *pFlags, unsigned char *Buf
                 case SF_DISPATCH:
                 case SF_UNKNOWN:
                 case SF_HAVEIID:
-#ifdef __REACTOS__
                 {
                     IUnknown **lpUnk;
                     const GUID *iid;
@@ -1065,13 +975,8 @@ unsigned char * WINAPI LPSAFEARRAY_UserMarshal(ULONG *pFlags, unsigned char *Buf
                     for (lpUnk = psa->pvData; ulCellCount; ulCellCount--, lpUnk++)
                             Buffer = interface_user_marshal(pFlags, Buffer, iid, *lpUnk);
 
-#else
-                    FIXME("marshal interfaces\n");
-#endif
                     break;
-#ifdef __REACTOS__
                 }
-#endif
                 case SF_VARIANT:
                 {
                     VARIANT* lpVariant;
@@ -1247,7 +1152,6 @@ unsigned char * WINAPI LPSAFEARRAY_UserUnmarshal(ULONG *pFlags, unsigned char *B
             case SF_DISPATCH:
             case SF_UNKNOWN:
             case SF_HAVEIID:
-#ifdef __REACTOS__
             {
                 IUnknown **lpUnk;
                 const GUID *iid;
@@ -1262,13 +1166,8 @@ unsigned char * WINAPI LPSAFEARRAY_UserUnmarshal(ULONG *pFlags, unsigned char *B
                 for (lpUnk = (*ppsa)->pvData; cell_count; cell_count--, lpUnk++)
                     Buffer = interface_user_unmarshal(pFlags, Buffer, iid, lpUnk);
 
-#else
-                FIXME("marshal interfaces\n");
-#endif
                 break;
-#ifdef __REACTOS__
             }
-#endif
             case SF_VARIANT:
             {
                 VARIANT* lpVariant;
@@ -1362,7 +1261,7 @@ HRESULT CALLBACK IDispatch_Invoke_Proxy(
   UINT uArgErr;
   EXCEPINFO ExcepInfo;
 
-  TRACE("(%p)->(%d,%s,%x,%x,%p,%p,%p,%p)\n", This,
+  TRACE("%p, %ld, %s, %#lx, %x, %p, %p, %p, %p.\n", This,
         dispIdMember, debugstr_guid(riid),
         lcid, wFlags, pDispParams, pVarResult,
         pExcepInfo, puArgErr);
@@ -1552,12 +1451,12 @@ static void free_embedded_arraydesc(ARRAYDESC *adesc)
     {
     case VT_PTR:
     case VT_SAFEARRAY:
-        free_embedded_typedesc(adesc->tdescElem.u.lptdesc);
-        CoTaskMemFree(adesc->tdescElem.u.lptdesc);
+        free_embedded_typedesc(adesc->tdescElem.lptdesc);
+        CoTaskMemFree(adesc->tdescElem.lptdesc);
         break;
     case VT_CARRAY:
-        free_embedded_arraydesc(adesc->tdescElem.u.lpadesc);
-        CoTaskMemFree(adesc->tdescElem.u.lpadesc);
+        free_embedded_arraydesc(adesc->tdescElem.lpadesc);
+        CoTaskMemFree(adesc->tdescElem.lpadesc);
         break;
     }
 }
@@ -1568,12 +1467,12 @@ static void free_embedded_typedesc(TYPEDESC *tdesc)
     {
     case VT_PTR:
     case VT_SAFEARRAY:
-        free_embedded_typedesc(tdesc->u.lptdesc);
-        CoTaskMemFree(tdesc->u.lptdesc);
+        free_embedded_typedesc(tdesc->lptdesc);
+        CoTaskMemFree(tdesc->lptdesc);
         break;
     case VT_CARRAY:
-        free_embedded_arraydesc(tdesc->u.lpadesc);
-        CoTaskMemFree(tdesc->u.lpadesc);
+        free_embedded_arraydesc(tdesc->lpadesc);
+        CoTaskMemFree(tdesc->lpadesc);
         break;
     }
 }
@@ -1581,8 +1480,8 @@ static void free_embedded_typedesc(TYPEDESC *tdesc)
 static void free_embedded_elemdesc(ELEMDESC *edesc)
 {
     free_embedded_typedesc(&edesc->tdesc);
-    if(edesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
-        CoTaskMemFree(edesc->u.paramdesc.pparamdescex);
+    if(edesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
+        CoTaskMemFree(edesc->paramdesc.pparamdescex);
 }
 
 /* ITypeComp */
@@ -1602,7 +1501,7 @@ HRESULT CALLBACK ITypeComp_Bind_Proxy(
     VARDESC *vardesc;
     HRESULT hr;
 
-    TRACE("(%p, %s, %#x, %#x, %p, %p, %p)\n", This, debugstr_w(name), lHashVal, flags, ti,
+    TRACE("%p, %s, %#lx, %#x, %p, %p, %p.\n", This, debugstr_w(name), lHashVal, flags, ti,
         desckind, bindptr);
 
     *desckind = DESCKIND_NONE;
@@ -1648,7 +1547,7 @@ HRESULT __RPC_STUB ITypeComp_Bind_Stub(
     BINDPTR bindptr;
     HRESULT hr;
 
-    TRACE("(%p, %s, %#x, %#x, %p, %p, %p, %p, %p, %p)\n", This, debugstr_w(name),
+    TRACE("%p, %s, %#lx, %#x, %p, %p, %p, %p, %p, %p.\n", This, debugstr_w(name),
         lHashVal, flags, ti, desckind, funcdesc, vardesc, typecomp, stg);
 
     memset(stg, 0, sizeof(*stg));
@@ -1700,7 +1599,7 @@ HRESULT CALLBACK ITypeComp_BindType_Proxy(
 {
     HRESULT hr;
 
-    TRACE("(%p, %s, %#x, %p, %p)\n", This, debugstr_w(name), lHashVal, ti, typecomp);
+    TRACE("%p, %s, %#lx, %p, %p.\n", This, debugstr_w(name), lHashVal, ti, typecomp);
 
     hr = ITypeComp_RemoteBindType_Proxy(This, name, lHashVal, ti);
     if (hr == S_OK)
@@ -1720,7 +1619,7 @@ HRESULT __RPC_STUB ITypeComp_BindType_Stub(
     ITypeComp *typecomp = NULL;
     HRESULT hr;
 
-    TRACE("(%p, %s, %#x, %p)\n", This, debugstr_w(name), lHashVal, ti);
+    TRACE("%p, %s, %#lx, %p.\n", This, debugstr_w(name), lHashVal, ti);
 
     hr = ITypeComp_BindType(This, name, lHashVal, ti, &typecomp);
 
@@ -1843,7 +1742,7 @@ HRESULT CALLBACK ITypeInfo_GetNames_Proxy(
     UINT cMaxNames,
     UINT* pcNames)
 {
-    TRACE("(%p, %08x, %p, %d, %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
+    TRACE("%p, %#lx, %p, %d, %p.\n", This, memid, rgBstrNames, cMaxNames, pcNames);
 
     return ITypeInfo_RemoteGetNames_Proxy(This, memid, rgBstrNames, cMaxNames, pcNames);
 }
@@ -1855,7 +1754,7 @@ HRESULT __RPC_STUB ITypeInfo_GetNames_Stub(
     UINT cMaxNames,
     UINT* pcNames)
 {
-    TRACE("(%p, %08x, %p, %d, %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
+    TRACE("%p, %#lx, %p, %d, %p.\n", This, memid, rgBstrNames, cMaxNames, pcNames);
 
     return ITypeInfo_GetNames(This, memid, rgBstrNames, cMaxNames, pcNames);
 }
@@ -1905,7 +1804,8 @@ HRESULT CALLBACK ITypeInfo_GetDocumentation_Proxy(ITypeInfo *This, MEMBERID memi
     DWORD dummy_help_context, flags = 0;
     BSTR dummy_name, dummy_doc_string, dummy_help_file;
     HRESULT hr;
-    TRACE("(%p, %08x, %p, %p, %p, %p)\n", This, memid, name, doc_string, help_context, help_file);
+
+    TRACE("%p, %#lx, %p, %p, %p, %p.\n", This, memid, name, doc_string, help_context, help_file);
 
     if(!name) name = &dummy_name;
     else flags = 1;
@@ -1930,7 +1830,7 @@ HRESULT __RPC_STUB ITypeInfo_GetDocumentation_Stub(ITypeInfo *This, MEMBERID mem
                                                    DWORD flags, BSTR *name, BSTR *doc_string,
                                                    DWORD *help_context, BSTR *help_file)
 {
-    TRACE("(%p, %08x, %08x, %p, %p, %p, %p)\n", This, memid, flags, name, doc_string, help_context, help_file);
+    TRACE("%p, %#lx, %#lx, %p, %p, %p, %p.\n", This, memid, flags, name, doc_string, help_context, help_file);
 
     *name = *doc_string = *help_file = NULL;
     *help_context = 0;
@@ -1951,7 +1851,8 @@ HRESULT CALLBACK ITypeInfo_GetDllEntry_Proxy(ITypeInfo *This, MEMBERID memid,
     BSTR dummy_dll_name, dummy_name;
     WORD dummy_ordinal;
     HRESULT hr;
-    TRACE("(%p, %08x, %x, %p, %p, %p)\n", This, memid, invkind, dll_name, name, ordinal);
+
+    TRACE("%p, %#lx, %#x, %p, %p, %p.\n", This, memid, invkind, dll_name, name, ordinal);
 
     if(!dll_name) dll_name = &dummy_dll_name;
     else flags = 1;
@@ -1974,7 +1875,7 @@ HRESULT __RPC_STUB ITypeInfo_GetDllEntry_Stub(ITypeInfo *This, MEMBERID memid,
                                               BSTR *dll_name, BSTR *name,
                                               WORD *ordinal)
 {
-    TRACE("(%p, %08x, %x, %p, %p, %p)\n", This, memid, invkind, dll_name, name, ordinal);
+    TRACE("%p, %#lx, %x, %p, %p, %p.\n", This, memid, invkind, dll_name, name, ordinal);
 
     *dll_name = *name = NULL;
     *ordinal = 0;
@@ -2108,7 +2009,7 @@ void CALLBACK ITypeInfo_ReleaseVarDesc_Proxy(
     CoTaskMemFree(pVarDesc->lpstrSchema);
 
     if(pVarDesc->varkind == VAR_CONST)
-        CoTaskMemFree(pVarDesc->u.lpvarValue);
+        CoTaskMemFree(pVarDesc->lpvarValue);
 
     free_embedded_elemdesc(&pVarDesc->elemdescVar);
     CoTaskMemFree(pVarDesc);
@@ -2131,7 +2032,8 @@ HRESULT CALLBACK ITypeInfo2_GetDocumentation2_Proxy(ITypeInfo2 *This, MEMBERID m
     DWORD dummy_help_context, flags = 0;
     BSTR dummy_help_string, dummy_help_dll;
     HRESULT hr;
-    TRACE("(%p, %08x, %08x, %p, %p, %p)\n", This, memid, lcid, help_string, help_context, help_dll);
+
+    TRACE("%p, %#lx, %#lx, %p, %p, %p.\n", This, memid, lcid, help_string, help_context, help_dll);
 
     if(!help_string) help_string = &dummy_help_string;
     else flags = 1;
@@ -2154,7 +2056,7 @@ HRESULT __RPC_STUB ITypeInfo2_GetDocumentation2_Stub(ITypeInfo2 *This, MEMBERID
                                                      BSTR *help_string, DWORD *help_context,
                                                      BSTR *help_dll)
 {
-    TRACE("(%p, %08x, %08x, %08x, %p, %p, %p)\n", This, memid, lcid, flags, help_string, help_context, help_dll);
+    TRACE("%p, %#lx, %#lx, %#lx, %p, %p, %p.\n", This, memid, lcid, flags, help_string, help_context, help_dll);
 
     *help_string = *help_dll = NULL;
     *help_context = 0;
@@ -2253,7 +2155,7 @@ HRESULT __RPC_STUB ITypeLib_GetDocumentation_Stub(ITypeLib *This, INT index, DWO
                                                   BSTR *name, BSTR *doc_string,
                                                   DWORD *help_context, BSTR *help_file)
 {
-    TRACE("(%p, %d, %08x, %p, %p, %p, %p)\n", This, index, flags, name, doc_string, help_context, help_file);
+    TRACE("%p, %d, %#lx, %p, %p, %p, %p.\n", This, index, flags, name, doc_string, help_context, help_file);
 
     *name = *doc_string = *help_file = NULL;
     *help_context = 0;
@@ -2355,7 +2257,8 @@ HRESULT CALLBACK ITypeLib2_GetDocumentation2_Proxy(ITypeLib2 *This, INT index,
     DWORD dummy_help_context, flags = 0;
     BSTR dummy_help_string, dummy_help_dll;
     HRESULT hr;
-    TRACE("(%p, %d, %08x, %p, %p, %p)\n", This, index, lcid, help_string, help_context, help_dll);
+
+    TRACE("%p, %d, %#lx, %p, %p, %p.\n", This, index, lcid, help_string, help_context, help_dll);
 
     if(!help_string) help_string = &dummy_help_string;
     else flags = 1;
@@ -2377,7 +2280,7 @@ HRESULT __RPC_STUB ITypeLib2_GetDocumentation2_Stub(ITypeLib2 *This, INT index,
                                                     DWORD flags, BSTR *help_string,
                                                     DWORD *help_context, BSTR *help_dll)
 {
-    TRACE("(%p, %d, %08x, %08x, %p, %p, %p)\n", This, index, lcid, flags, help_string, help_context, help_dll);
+    TRACE("%p, %d, %#lx, %#lx, %p, %p, %p.\n", This, index, lcid, flags, help_string, help_context, help_dll);
 
     *help_string = *help_dll = NULL;
     *help_context = 0;
@@ -2435,10 +2338,10 @@ HRESULT __RPC_STUB IPropertyBag_Read_Stub(
     DWORD varType,
     IUnknown *pUnkObj)
 {
-  static const WCHAR emptyWstr[] = {0};
   IDispatch *disp;
   HRESULT hr;
-  TRACE("(%p, %s, %p, %p, %x, %p)\n", This, debugstr_w(pszPropName), pVar,
+
+  TRACE("%p, %s, %p, %p, %lx, %p.\n", This, debugstr_w(pszPropName), pVar,
                                      pErrorLog, varType, pUnkObj);
 
   if(varType & (VT_BYREF | VT_ARRAY | VT_VECTOR))
@@ -2461,7 +2364,7 @@ HRESULT __RPC_STUB IPropertyBag_Read_Stub(
       V_UNKNOWN(pVar) = pUnkObj;
       break;
     case VT_BSTR:
-      V_BSTR(pVar) = SysAllocString(emptyWstr);
+      V_BSTR(pVar) = SysAllocString(L"");
       break;
     case VT_SAFEARRAY:
       FIXME("Safearray support not yet implemented.\n");
@@ -2517,7 +2420,7 @@ HRESULT CALLBACK IEnumConnections_Next_Proxy(
 {
     ULONG fetched;
 
-    TRACE("(%u, %p %p)\n", cConnections, rgcd, pcFetched);
+    TRACE("%lu, %p, %p.\n", cConnections, rgcd, pcFetched);
 
     if (!pcFetched)
         pcFetched = &fetched;
@@ -2533,7 +2436,7 @@ HRESULT __RPC_STUB IEnumConnections_Next_Stub(
 {
     HRESULT hr;
 
-    TRACE("(%u, %p, %p)\n", cConnections, rgcd, pcFetched);
+    TRACE("%lu, %p, %p.\n", cConnections, rgcd, pcFetched);
 
     *pcFetched = 0;
     hr = IEnumConnections_Next(This, cConnections, rgcd, pcFetched);
@@ -2551,7 +2454,7 @@ HRESULT CALLBACK IEnumConnectionPoints_Next_Proxy(
 {
     ULONG fetched;
 
-    TRACE("(%u, %p %p)\n", cConnections, ppCP, pcFetched);
+    TRACE("%lu, %p %p.\n", cConnections, ppCP, pcFetched);
 
     if (!pcFetched)
         pcFetched = &fetched;
@@ -2567,7 +2470,7 @@ HRESULT __RPC_STUB IEnumConnectionPoints_Next_Stub(
 {
     HRESULT hr;
 
-    TRACE("(%u, %p, %p)\n", cConnections, ppCP, pcFetched);
+    TRACE("%lu, %p, %p.\n", cConnections, ppCP, pcFetched);
 
     *pcFetched = 0;
     hr = IEnumConnectionPoints_Next(This, cConnections, ppCP, pcFetched);
@@ -2582,7 +2485,7 @@ HRESULT CALLBACK IPersistMemory_Load_Proxy(
     LPVOID pMem,
     ULONG cbSize)
 {
-    TRACE("(%p, %u)\n", pMem, cbSize);
+    TRACE("%p, %lu.\n", pMem, cbSize);
 
     if (!pMem)
         return E_POINTER;
@@ -2595,7 +2498,7 @@ HRESULT __RPC_STUB IPersistMemory_Load_Stub(
     BYTE *pMem,
     ULONG cbSize)
 {
-    TRACE("(%p, %u)\n", pMem, cbSize);
+    TRACE("%p, %lu.\n", pMem, cbSize);
     return IPersistMemory_Load(This, pMem, cbSize);
 }
 
@@ -2605,7 +2508,7 @@ HRESULT CALLBACK IPersistMemory_Save_Proxy(
     BOOL fClearDirty,
     ULONG cbSize)
 {
-    TRACE("(%p, %d, %u)\n", pMem, fClearDirty, cbSize);
+    TRACE("%p, %d, %lu.\n", pMem, fClearDirty, cbSize);
 
     if (!pMem)
         return E_POINTER;
@@ -2619,7 +2522,7 @@ HRESULT __RPC_STUB IPersistMemory_Save_Stub(
     BOOL fClearDirty,
     ULONG cbSize)
 {
-    TRACE("(%p, %d, %u)\n", pMem, fClearDirty, cbSize);
+    TRACE("%p, %d, %lu.\n", pMem, fClearDirty, cbSize);
     return IPersistMemory_Save(This, pMem, fClearDirty, cbSize);
 }
 
@@ -2627,7 +2530,7 @@ void CALLBACK IAdviseSinkEx_OnViewStatusChange_Proxy(
     IAdviseSinkEx* This,
     DWORD dwViewStatus)
 {
-    TRACE("(%p, 0x%08x)\n", This, dwViewStatus);
+    TRACE("%p, %#lx.\n", This, dwViewStatus);
     IAdviseSinkEx_RemoteOnViewStatusChange_Proxy(This, dwViewStatus);
 }
 
@@ -2635,7 +2538,7 @@ HRESULT __RPC_STUB IAdviseSinkEx_OnViewStatusChange_Stub(
     IAdviseSinkEx* This,
     DWORD dwViewStatus)
 {
-    TRACE("(%p, 0x%08x)\n", This, dwViewStatus);
+    TRACE("%p, %#lx.\n", This, dwViewStatus);
     IAdviseSinkEx_OnViewStatusChange(This, dwViewStatus);
     return S_OK;
 }
@@ -2648,7 +2551,7 @@ HRESULT CALLBACK IEnumOleUndoUnits_Next_Proxy(
 {
     ULONG fetched;
 
-    TRACE("(%u, %p %p)\n", cElt, rgElt, pcEltFetched);
+    TRACE("%lu, %p %p.\n", cElt, rgElt, pcEltFetched);
 
     if (!pcEltFetched)
         pcEltFetched = &fetched;
@@ -2664,7 +2567,7 @@ HRESULT __RPC_STUB IEnumOleUndoUnits_Next_Stub(
 {
     HRESULT hr;
 
-    TRACE("(%u, %p, %p)\n", cElt, rgElt, pcEltFetched);
+    TRACE("%lu, %p, %p.\n", cElt, rgElt, pcEltFetched);
 
     *pcEltFetched = 0;
     hr = IEnumOleUndoUnits_Next(This, cElt, rgElt, pcEltFetched);
diff --git a/dll/win32/oleaut32/varformat.c b/dll/win32/oleaut32/varformat.c
index 591093dbc52..3f69a45a897 100644
--- a/dll/win32/oleaut32/varformat.c
+++ b/dll/win32/oleaut32/varformat.c
@@ -44,10 +44,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(variant);
  */
 #define LCID_US MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT)
 
-static const WCHAR szPercent_d[] = { '%','d','\0' };
-static const WCHAR szPercentZeroTwo_d[] = { '%','0','2','d','\0' };
-static const WCHAR szPercentZeroStar_d[] = { '%','0','*','d','\0' };
-
 /******************************************************************************
  * Variant-Formats {OLEAUT32}
  *
@@ -272,7 +268,6 @@ typedef struct tagFMT_DATE_HEADER
 #define FMT_STR_COPY_SKIP   0x41 /* Copy len chars or skip if no char */
 
 /* Named Formats and their tokenised values */
-static const WCHAR szGeneralDate[] = { 'G','e','n','e','r','a','l',' ','D','a','t','e','\0' };
 static const BYTE fmtGeneralDate[0x0a] =
 {
   0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -280,7 +275,6 @@ static const BYTE fmtGeneralDate[0x0a] =
   FMT_DATE_GENERAL,FMT_GEN_END
 };
 
-static const WCHAR szShortDate[] = { 'S','h','o','r','t',' ','D','a','t','e','\0' };
 static const BYTE fmtShortDate[0x0a] =
 {
   0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -288,7 +282,6 @@ static const BYTE fmtShortDate[0x0a] =
   FMT_DATE_SHORT,FMT_GEN_END
 };
 
-static const WCHAR szMediumDate[] = { 'M','e','d','i','u','m',' ','D','a','t','e','\0' };
 static const BYTE fmtMediumDate[0x0a] =
 {
   0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -296,7 +289,6 @@ static const BYTE fmtMediumDate[0x0a] =
   FMT_DATE_MEDIUM,FMT_GEN_END
 };
 
-static const WCHAR szLongDate[] = { 'L','o','n','g',' ','D','a','t','e','\0' };
 static const BYTE fmtLongDate[0x0a] =
 {
   0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -304,7 +296,6 @@ static const BYTE fmtLongDate[0x0a] =
   FMT_DATE_LONG,FMT_GEN_END
 };
 
-static const WCHAR szShortTime[] = { 'S','h','o','r','t',' ','T','i','m','e','\0' };
 static const BYTE fmtShortTime[0x0c] =
 {
   0x0c,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -312,7 +303,6 @@ static const BYTE fmtShortTime[0x0c] =
   FMT_DATE_TIME_UNK2,FMT_DATE_TIME_SEP,FMT_DATE_MIN_0,FMT_GEN_END
 };
 
-static const WCHAR szMediumTime[] = { 'M','e','d','i','u','m',' ','T','i','m','e','\0' };
 static const BYTE fmtMediumTime[0x11] =
 {
   0x11,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -321,7 +311,6 @@ static const BYTE fmtMediumTime[0x11] =
   FMT_GEN_INLINE,0x01,' ','\0',FMT_DATE_AMPM_SYS1,FMT_GEN_END
 };
 
-static const WCHAR szLongTime[] = { 'L','o','n','g',' ','T','i','m','e','\0' };
 static const BYTE fmtLongTime[0x0d] =
 {
   0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -329,7 +318,6 @@ static const BYTE fmtLongTime[0x0d] =
   FMT_DATE_TIME_SYS,FMT_GEN_END
 };
 
-static const WCHAR szTrueFalse[] = { 'T','r','u','e','/','F','a','l','s','e','\0' };
 static const BYTE fmtTrueFalse[0x0d] =
 {
   0x0d,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -337,7 +325,6 @@ static const BYTE fmtTrueFalse[0x0d] =
   FMT_NUM_TRUE_FALSE,FMT_GEN_END
 };
 
-static const WCHAR szYesNo[] = { 'Y','e','s','/','N','o','\0' };
 static const BYTE fmtYesNo[0x0d] =
 {
   0x0d,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -345,7 +332,6 @@ static const BYTE fmtYesNo[0x0d] =
   FMT_NUM_YES_NO,FMT_GEN_END
 };
 
-static const WCHAR szOnOff[] = { 'O','n','/','O','f','f','\0' };
 static const BYTE fmtOnOff[0x0d] =
 {
   0x0d,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -353,13 +339,11 @@ static const BYTE fmtOnOff[0x0d] =
   FMT_NUM_ON_OFF,FMT_GEN_END
 };
 
-static const WCHAR szGeneralNumber[] = { 'G','e','n','e','r','a','l',' ','N','u','m','b','e','r','\0' };
 static const BYTE fmtGeneralNumber[sizeof(FMT_HEADER)] =
 {
   sizeof(FMT_HEADER),FMT_TYPE_GENERAL,sizeof(FMT_HEADER),0x0,0x0,0x0
 };
 
-static const WCHAR szCurrency[] = { 'C','u','r','r','e','n','c','y','\0' };
 static const BYTE fmtCurrency[0x26] =
 {
   0x26,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x12,0x0,0x0,
@@ -374,7 +358,6 @@ static const BYTE fmtCurrency[0x26] =
   FMT_GEN_END
 };
 
-static const WCHAR szFixed[] = { 'F','i','x','e','d','\0' };
 static const BYTE fmtFixed[0x11] =
 {
   0x11,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -382,7 +365,6 @@ static const BYTE fmtFixed[0x11] =
   FMT_NUM_COPY_ZERO,0x1,FMT_NUM_DECIMAL,FMT_NUM_COPY_ZERO,0x2,FMT_GEN_END
 };
 
-static const WCHAR szStandard[] = { 'S','t','a','n','d','a','r','d','\0' };
 static const BYTE fmtStandard[0x11] =
 {
   0x11,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -390,7 +372,6 @@ static const BYTE fmtStandard[0x11] =
   FMT_NUM_COPY_ZERO,0x1,FMT_NUM_DECIMAL,FMT_NUM_COPY_ZERO,0x2,FMT_GEN_END
 };
 
-static const WCHAR szPercent[] = { 'P','e','r','c','e','n','t','\0' };
 static const BYTE fmtPercent[0x15] =
 {
   0x15,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -399,7 +380,6 @@ static const BYTE fmtPercent[0x15] =
   FMT_GEN_INLINE,0x1,'%','\0',FMT_GEN_END
 };
 
-static const WCHAR szScientific[] = { 'S','c','i','e','n','t','i','f','i','c','\0' };
 static const BYTE fmtScientific[0x13] =
 {
   0x13,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -416,22 +396,22 @@ typedef struct tagNAMED_FORMAT
 /* Format name to tokenised format. Must be kept sorted by name */
 static const NAMED_FORMAT VARIANT_NamedFormats[] =
 {
-  { szCurrency, fmtCurrency },
-  { szFixed, fmtFixed },
-  { szGeneralDate, fmtGeneralDate },
-  { szGeneralNumber, fmtGeneralNumber },
-  { szLongDate, fmtLongDate },
-  { szLongTime, fmtLongTime },
-  { szMediumDate, fmtMediumDate },
-  { szMediumTime, fmtMediumTime },
-  { szOnOff, fmtOnOff },
-  { szPercent, fmtPercent },
-  { szScientific, fmtScientific },
-  { szShortDate, fmtShortDate },
-  { szShortTime, fmtShortTime },
-  { szStandard, fmtStandard },
-  { szTrueFalse, fmtTrueFalse },
-  { szYesNo, fmtYesNo }
+  { L"Currency", fmtCurrency },
+  { L"Fixed", fmtFixed },
+  { L"General Date", fmtGeneralDate },
+  { L"General Number", fmtGeneralNumber },
+  { L"Long Date", fmtLongDate },
+  { L"Long Time", fmtLongTime },
+  { L"Medium Date", fmtMediumDate },
+  { L"Medium Time", fmtMediumTime },
+  { L"On/Off", fmtOnOff },
+  { L"Percent", fmtPercent },
+  { L"Scientific", fmtScientific },
+  { L"Short Date", fmtShortDate },
+  { L"Short Time", fmtShortTime },
+  { L"Standard", fmtStandard },
+  { L"True/False", fmtTrueFalse },
+  { L"Yes/No", fmtYesNo }
 };
 typedef const NAMED_FORMAT *LPCNAMED_FORMAT;
 
@@ -512,7 +492,7 @@ HRESULT WINAPI VarTokenizeFormatString(LPOLESTR lpszFormat, LPBYTE rgbTok,
   DWORD fmt_state = 0;
   LPCWSTR pFormat = lpszFormat;
 
-  TRACE("(%s,%p,%d,%d,%d,0x%08x,%p)\n", debugstr_w(lpszFormat), rgbTok, cbTok,
+  TRACE("%s, %p, %d, %d, %d, %#lx, %p.\n", debugstr_w(lpszFormat), rgbTok, cbTok,
         nFirstDay, nFirstWeek, lcid, pcbActual);
 
   if (!rgbTok ||
@@ -760,7 +740,7 @@ HRESULT WINAPI VarTokenizeFormatString(LPOLESTR lpszFormat, LPBYTE rgbTok,
       TRACE("time sep\n");
     }
     else if ((*pFormat == 'a' || *pFormat == 'A') &&
-              !_wcsnicmp(pFormat, szAMPM, ARRAY_SIZE(szAMPM)))
+              !wcsnicmp(pFormat, szAMPM, ARRAY_SIZE(szAMPM)))
     {
       /* Date formats: System AM/PM designation
        * Other formats: Literal
@@ -983,7 +963,7 @@ HRESULT WINAPI VarTokenizeFormatString(LPOLESTR lpszFormat, LPBYTE rgbTok,
       fmt_state &= ~FMT_STATE_OPEN_COPY;
     }
     else if ((*pFormat == 't' || *pFormat == 'T') &&
-              !_wcsnicmp(pFormat, szTTTTT, ARRAY_SIZE(szTTTTT)))
+              !wcsnicmp(pFormat, szTTTTT, ARRAY_SIZE(szTTTTT)))
     {
       /* Date formats: System time specifier
        * Other formats: Literal
@@ -1182,7 +1162,7 @@ static HRESULT VARIANT_FormatNumber(LPVARIANT pVarIn, LPOLESTR lpszFormat,
   const BYTE* pToken = NULL;
   HRESULT hRes = S_OK;
 
-  TRACE("(%s,%s,%p,0x%08x,%p,0x%08x)\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
+  TRACE("%s, %s, %p, %#lx, %p, %#lx.\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
         rgbTok, dwFlags, pbstrOut, lcid);
 
   V_VT(&vString) = VT_EMPTY;
@@ -1415,13 +1395,13 @@ VARIANT_FormatNumber_Bool:
       if (exponent < 0)
       {
         *pBuff++ = '-';
-        swprintf(pBuff, szPercentZeroStar_d, pToken[1], -exponent);
+        swprintf(pBuff, ARRAY_SIZE(buff) - (pBuff - buff), L"%0*d", pToken[1], -exponent);
       }
       else
       {
         if (*pToken == FMT_NUM_EXP_POS_L || *pToken == FMT_NUM_EXP_POS_U)
           *pBuff++ = '+';
-        swprintf(pBuff, szPercentZeroStar_d, pToken[1], exponent);
+        swprintf(pBuff, ARRAY_SIZE(buff) - (pBuff - buff), L"%0*d", pToken[1], exponent);
       }
       while (*pBuff)
         pBuff++;
@@ -1590,7 +1570,7 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
   const BYTE* pToken = NULL;
   HRESULT hRes;
 
-  TRACE("(%s,%s,%p,0x%08x,%p,0x%08x)\n", debugstr_variant(pVarIn),
+  TRACE("%s, %s, %p, %#lx, %p, %#lx.\n", debugstr_variant(pVarIn),
         debugstr_w(lpszFormat), rgbTok, dwFlags, pbstrOut, lcid);
 
   V_VT(&vDate) = VT_EMPTY;
@@ -1605,8 +1585,34 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
     USHORT usFlags = dwFlags & VARIANT_CALENDAR_HIJRI ? VAR_CALENDAR_HIJRI : 0;
 
     hRes = VariantChangeTypeEx(&vDate, pVarIn, lcid, usFlags, VT_DATE);
+    /* 31809.40 and similar are treated as invalid by coercion functions but
+     * it simply is a DATE in string form as far as VarFormat is concerned
+     */
     if (FAILED(hRes))
-      return hRes;
+    {
+      if (V_TYPE(pVarIn) == VT_BSTR)
+      {
+        DATE out;
+        OLECHAR *endptr = NULL;
+	/* Try consume the string with wcstod */
+	double tmp = wcstod(V_BSTR(pVarIn), &endptr);
+
+	/* Not a double in string form */
+	if (*endptr)
+          return hRes;
+
+	hRes = VarDateFromR8(tmp, &out);
+
+	if (FAILED(hRes))
+	  return hRes;
+
+	V_VT(&vDate) = VT_DATE;
+	V_DATE(&vDate) = out;
+      }
+      else
+	return hRes;
+    }
+
     dateHeader = (FMT_DATE_HEADER*)(rgbTok + FmtGetPositive(header));
   }
 
@@ -1697,12 +1703,12 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
       break;
 
     case FMT_DATE_DAY:
-      szPrintFmt = szPercent_d;
+      szPrintFmt = L"%d";
       dwVal = udate.st.wDay;
       break;
 
     case FMT_DATE_DAY_0:
-      szPrintFmt = szPercentZeroTwo_d;
+      szPrintFmt = L"%02d";
       dwVal = udate.st.wDay;
       break;
 
@@ -1736,7 +1742,7 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
       break;
 
     case FMT_DATE_DAY_WEEK:
-      szPrintFmt = szPercent_d;
+      szPrintFmt = L"%d";
       if (pToken[1])
         dwVal = udate.st.wDayOfWeek + 2 - pToken[1];
       else
@@ -1749,19 +1755,19 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
       break;
 
     case FMT_DATE_WEEK_YEAR:
-      szPrintFmt = szPercent_d;
+      szPrintFmt = L"%d";
       dwVal = udate.wDayOfYear / 7 + 1;
       pToken += 2;
       FIXME("Ignoring nFirstDay of %d, nFirstWeek of %d\n", pToken[0], pToken[1]);
       break;
 
     case FMT_DATE_MON:
-      szPrintFmt = szPercent_d;
+      szPrintFmt = L"%d";
       dwVal = udate.st.wMonth;
       break;
 
     case FMT_DATE_MON_0:
-      szPrintFmt = szPercentZeroTwo_d;
+      szPrintFmt = L"%02d";
       dwVal = udate.st.wMonth;
       break;
 
@@ -1780,58 +1786,58 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
       break;
 
     case FMT_DATE_YEAR_DOY:
-      szPrintFmt = szPercent_d;
+      szPrintFmt = L"%d";
       dwVal = udate.wDayOfYear;
       break;
 
     case FMT_DATE_YEAR_0:
-      szPrintFmt = szPercentZeroTwo_d;
+      szPrintFmt = L"%02d";
       dwVal = udate.st.wYear % 100;
       break;
 
     case FMT_DATE_YEAR_LONG:
-      szPrintFmt = szPercent_d;
+      szPrintFmt = L"%d";
       dwVal = udate.st.wYear;
       break;
 
     case FMT_DATE_MIN:
-      szPrintFmt = szPercent_d;
+      szPrintFmt = L"%d";
       dwVal = udate.st.wMinute;
       break;
 
     case FMT_DATE_MIN_0:
-      szPrintFmt = szPercentZeroTwo_d;
+      szPrintFmt = L"%02d";
       dwVal = udate.st.wMinute;
       break;
 
     case FMT_DATE_SEC:
-      szPrintFmt = szPercent_d;
+      szPrintFmt = L"%d";
       dwVal = udate.st.wSecond;
       break;
 
     case FMT_DATE_SEC_0:
-      szPrintFmt = szPercentZeroTwo_d;
+      szPrintFmt = L"%02d";
       dwVal = udate.st.wSecond;
       break;
 
     case FMT_DATE_HOUR:
-      szPrintFmt = szPercent_d;
+      szPrintFmt = L"%d";
       dwVal = udate.st.wHour;
       break;
 
     case FMT_DATE_HOUR_0:
     case FMT_DATE_TIME_UNK2:
-      szPrintFmt = szPercentZeroTwo_d;
+      szPrintFmt = L"%02d";
       dwVal = udate.st.wHour;
       break;
 
     case FMT_DATE_HOUR_12:
-      szPrintFmt = szPercent_d;
+      szPrintFmt = L"%d";
       dwVal = udate.st.wHour ? udate.st.wHour > 12 ? udate.st.wHour - 12 : udate.st.wHour : 12;
       break;
 
     case FMT_DATE_HOUR_12_0:
-      szPrintFmt = szPercentZeroTwo_d;
+      szPrintFmt = L"%02d";
       dwVal = udate.st.wHour ? udate.st.wHour > 12 ? udate.st.wHour - 12 : udate.st.wHour : 12;
       break;
 
@@ -1894,7 +1900,7 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
     }
     else if (szPrintFmt)
     {
-      swprintf(pBuff, szPrintFmt, dwVal);
+      swprintf(pBuff, ARRAY_SIZE(buff) - (pBuff - buff), szPrintFmt, dwVal);
       while (*pBuff)
         pBuff++;
     }
@@ -1918,7 +1924,7 @@ static HRESULT VARIANT_FormatString(LPVARIANT pVarIn, LPOLESTR lpszFormat,
                                     LPBYTE rgbTok, ULONG dwFlags,
                                     BSTR *pbstrOut, LCID lcid)
 {
-  static WCHAR szEmpty[] = { '\0' };
+  static WCHAR szEmpty[] = L"";
   WCHAR buff[256], *pBuff = buff;
   WCHAR *pSrc;
   FMT_HEADER *header = (FMT_HEADER*)rgbTok;
@@ -1929,7 +1935,7 @@ static HRESULT VARIANT_FormatString(LPVARIANT pVarIn, LPOLESTR lpszFormat,
   BOOL bUpper = FALSE;
   HRESULT hRes = S_OK;
 
-  TRACE("%s,%s,%p,0x%08x,%p,0x%08x)\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
+  TRACE("%s, %s, %p, %#lx, %p, %#lx.\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
         rgbTok, dwFlags, pbstrOut, lcid);
 
   V_VT(&vStr) = VT_EMPTY;
@@ -2055,7 +2061,7 @@ HRESULT WINAPI VarFormatFromTokens(LPVARIANT pVarIn, LPOLESTR lpszFormat,
   VARIANT vTmp;
   HRESULT hres;
 
-  TRACE("(%p,%s,%p,%x,%p,0x%08x)\n", pVarIn, debugstr_w(lpszFormat),
+  TRACE("%p, %s, %p, %#lx, %p, %#lx.\n", pVarIn, debugstr_w(lpszFormat),
           rgbTok, dwFlags, pbstrOut, lcid);
 
   if (!pbstrOut)
@@ -2142,7 +2148,7 @@ HRESULT WINAPI VarFormat(LPVARIANT pVarIn, LPOLESTR lpszFormat,
   BYTE buff[256];
   HRESULT hres;
 
-  TRACE("(%s,%s,%d,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
+  TRACE("%s, %s, %d, %d, %#lx, %p.\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
         nFirstDay, nFirstWeek, dwFlags, pbstrOut);
 
   if (!pbstrOut)
@@ -2154,7 +2160,7 @@ HRESULT WINAPI VarFormat(LPVARIANT pVarIn, LPOLESTR lpszFormat,
   if (SUCCEEDED(hres))
     hres = VarFormatFromTokens(pVarIn, lpszFormat, buff, dwFlags,
                                pbstrOut, LOCALE_USER_DEFAULT);
-  TRACE("returning 0x%08x, %s\n", hres, debugstr_w(*pbstrOut));
+  TRACE("returning %#lx, %s\n", hres, debugstr_w(*pbstrOut));
   return hres;
 }
 
@@ -2189,10 +2195,10 @@ HRESULT WINAPI VarFormat(LPVARIANT pVarIn, LPOLESTR lpszFormat,
  */
 HRESULT WINAPI VarFormatDateTime(LPVARIANT pVarIn, INT nFormat, ULONG dwFlags, BSTR *pbstrOut)
 {
-  static WCHAR szEmpty[] = { '\0' };
+  static WCHAR szEmpty[] = L"";
   const BYTE* lpFmt = NULL;
 
-  TRACE("%s,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), nFormat, dwFlags, pbstrOut);
+  TRACE("%s, %d, %#lx, %p.\n", debugstr_variant(pVarIn), nFormat, dwFlags, pbstrOut);
 
   if (!pVarIn || !pbstrOut || nFormat < 0 || nFormat > 4)
     return E_INVALIDARG;
@@ -2244,7 +2250,7 @@ HRESULT WINAPI VarFormatNumber(LPVARIANT pVarIn, INT nDigits, INT nLeading, INT
   HRESULT hRet;
   VARIANT vStr;
 
-  TRACE("(%s,%d,%d,%d,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), nDigits, nLeading,
+  TRACE("%s, %d, %d, %d, %d, %#lx, %p.\n", debugstr_variant(pVarIn), nDigits, nLeading,
         nParens, nGrouping, dwFlags, pbstrOut);
 
   if (!pVarIn || !pbstrOut || nDigits > 9)
@@ -2345,13 +2351,11 @@ HRESULT WINAPI VarFormatNumber(LPVARIANT pVarIn, INT nDigits, INT nLeading, INT
 HRESULT WINAPI VarFormatPercent(LPVARIANT pVarIn, INT nDigits, INT nLeading, INT nParens,
                                 INT nGrouping, ULONG dwFlags, BSTR *pbstrOut)
 {
-  static const WCHAR szPercent[] = { '%','\0' };
-  static const WCHAR szPercentBracket[] = { '%',')','\0' };
   WCHAR buff[256];
   HRESULT hRet;
   VARIANT vDbl;
 
-  TRACE("(%s,%d,%d,%d,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), nDigits, nLeading,
+  TRACE("%s, %d, %d, %d, %d, %#lx, %p.\n", debugstr_variant(pVarIn), nDigits, nLeading,
         nParens, nGrouping, dwFlags, pbstrOut);
 
   if (!pVarIn || !pbstrOut || nDigits > 9)
@@ -2382,7 +2386,7 @@ HRESULT WINAPI VarFormatPercent(LPVARIANT pVarIn, INT nDigits, INT nLeading, INT
 
         dwLen -= bBracket;
         memcpy(buff, *pbstrOut, dwLen * sizeof(WCHAR));
-        lstrcpyW(buff + dwLen, bBracket ? szPercentBracket : szPercent);
+        lstrcpyW(buff + dwLen, bBracket ? L"%)" : L"%");
         SysFreeString(*pbstrOut);
         *pbstrOut = SysAllocString(buff);
         if (!*pbstrOut)
@@ -2423,8 +2427,9 @@ HRESULT WINAPI VarFormatCurrency(LPVARIANT pVarIn, INT nDigits, INT nLeading,
 {
   HRESULT hRet;
   VARIANT vStr;
+  CY cy;
 
-  TRACE("(%s,%d,%d,%d,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), nDigits, nLeading,
+  TRACE("%s, %d, %d, %d, %d, %#lx, %p.\n", debugstr_variant(pVarIn), nDigits, nLeading,
         nParens, nGrouping, dwFlags, pbstrOut);
 
   if (!pVarIn || !pbstrOut || nDigits > 9)
@@ -2432,8 +2437,18 @@ HRESULT WINAPI VarFormatCurrency(LPVARIANT pVarIn, INT nDigits, INT nLeading,
 
   *pbstrOut = NULL;
 
-  V_VT(&vStr) = VT_EMPTY;
-  hRet = VariantCopyInd(&vStr, pVarIn);
+  if (V_VT(pVarIn) == VT_BSTR || V_VT(pVarIn) == (VT_BSTR | VT_BYREF))
+  {
+    hRet = VarCyFromStr(V_ISBYREF(pVarIn) ? *V_BSTRREF(pVarIn) : V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &cy);
+    if (FAILED(hRet)) return hRet;
+    V_VT(&vStr) = VT_CY;
+    V_CY(&vStr) = cy;
+  }
+  else
+  {
+    V_VT(&vStr) = VT_EMPTY;
+    hRet = VariantCopyInd(&vStr, pVarIn);
+  }
 
   if (SUCCEEDED(hRet))
     hRet = VariantChangeTypeEx(&vStr, &vStr, LOCALE_USER_DEFAULT, 0, VT_BSTR);
@@ -2523,7 +2538,7 @@ HRESULT WINAPI VarMonthName(INT iMonth, INT fAbbrev, ULONG dwFlags, BSTR *pbstrO
     return E_INVALIDARG;
 
   if (dwFlags)
-    FIXME("Does not support dwFlags 0x%x, ignoring.\n", dwFlags);
+    FIXME("Does not support flags %#lx, ignoring.\n", dwFlags);
 
   if (fAbbrev)
 	localeValue = LOCALE_SABBREVMONTHNAME1 + iMonth - 1;
@@ -2532,7 +2547,7 @@ HRESULT WINAPI VarMonthName(INT iMonth, INT fAbbrev, ULONG dwFlags, BSTR *pbstrO
 
   size = GetLocaleInfoW(LOCALE_USER_DEFAULT,localeValue, NULL, 0);
   if (!size) {
-    ERR("GetLocaleInfo 0x%x failed.\n", localeValue);
+    ERR("GetLocaleInfo %#lx failed.\n", localeValue);
     return HRESULT_FROM_WIN32(GetLastError());
   }
   *pbstrOut = SysAllocStringLen(NULL,size - 1);
@@ -2540,7 +2555,7 @@ HRESULT WINAPI VarMonthName(INT iMonth, INT fAbbrev, ULONG dwFlags, BSTR *pbstrO
     return E_OUTOFMEMORY;
   size = GetLocaleInfoW(LOCALE_USER_DEFAULT,localeValue, *pbstrOut, size);
   if (!size) {
-    ERR("GetLocaleInfo of 0x%x failed in 2nd stage?!\n", localeValue);
+    ERR("GetLocaleInfo of %#lx failed in 2nd stage?!\n", localeValue);
     SysFreeString(*pbstrOut);
     return HRESULT_FROM_WIN32(GetLastError());
   }
@@ -2580,7 +2595,7 @@ HRESULT WINAPI VarWeekdayName(INT iWeekday, INT fAbbrev, INT iFirstDay,
     return E_INVALIDARG;
 
   if (dwFlags)
-    FIXME("Does not support dwFlags 0x%x, ignoring.\n", dwFlags);
+    FIXME("Does not support flags %#lx, ignoring.\n", dwFlags);
 
   /* If we have to use the default firstDay, find which one it is */
   if (iFirstDay == 0) {
@@ -2589,7 +2604,7 @@ HRESULT WINAPI VarWeekdayName(INT iWeekday, INT fAbbrev, INT iFirstDay,
     size = GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue,
                           (LPWSTR)&firstDay, sizeof(firstDay) / sizeof(WCHAR));
     if (!size) {
-      ERR("GetLocaleInfo 0x%x failed.\n", localeValue);
+      ERR("GetLocaleInfo %#lx failed.\n", localeValue);
       return HRESULT_FROM_WIN32(GetLastError());
     }
     iFirstDay = firstDay + 2;
@@ -2602,7 +2617,7 @@ HRESULT WINAPI VarWeekdayName(INT iWeekday, INT fAbbrev, INT iFirstDay,
   /* Determine the size of the data, allocate memory and retrieve the data */
   size = GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue, NULL, 0);
   if (!size) {
-    ERR("GetLocaleInfo 0x%x failed.\n", localeValue);
+    ERR("GetLocaleInfo %#lx failed.\n", localeValue);
     return HRESULT_FROM_WIN32(GetLastError());
   }
   *pbstrOut = SysAllocStringLen(NULL, size - 1);
@@ -2610,7 +2625,7 @@ HRESULT WINAPI VarWeekdayName(INT iWeekday, INT fAbbrev, INT iFirstDay,
     return E_OUTOFMEMORY;
   size = GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue, *pbstrOut, size);
   if (!size) {
-    ERR("GetLocaleInfo 0x%x failed in 2nd stage?!\n", localeValue);
+    ERR("GetLocaleInfo %#lx failed in 2nd stage?!\n", localeValue);
     SysFreeString(*pbstrOut);
     return HRESULT_FROM_WIN32(GetLastError());
   }
diff --git a/dll/win32/oleaut32/variant.c b/dll/win32/oleaut32/variant.c
index ce96ba14565..bb1e83e9b7e 100644
--- a/dll/win32/oleaut32/variant.c
+++ b/dll/win32/oleaut32/variant.c
@@ -30,9 +30,6 @@
 #include <stdarg.h>
 
 #define COBJMACROS
-#define NONAMELESSUNION
-#define NONAMELESSSTRUCT
-
 #include "windef.h"
 #include "winbase.h"
 #include "winerror.h"
@@ -42,14 +39,6 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(variant);
 
-static CRITICAL_SECTION cache_cs;
-static CRITICAL_SECTION_DEBUG critsect_debug =
-{
-    0, 0, &cache_cs,
-    { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
-      0, 0, { (DWORD_PTR)(__FILE__ ": cache_cs") }
-};
-static CRITICAL_SECTION cache_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
 
 /* Convert a variant from one type to another */
 static inline HRESULT VARIANT_Coerce(VARIANTARG* pd, LCID lcid, USHORT wFlags,
@@ -59,7 +48,7 @@ static inline HRESULT VARIANT_Coerce(VARIANTARG* pd, LCID lcid, USHORT wFlags,
   VARTYPE vtFrom =  V_TYPE(ps);
   DWORD dwFlags = 0;
 
-  TRACE("(%s,0x%08x,0x%04x,%s,%s)\n", debugstr_variant(pd), lcid, wFlags,
+  TRACE("%s, %#lx, 0x%04x, %s, %s.\n", debugstr_variant(pd), lcid, wFlags,
         debugstr_variant(ps), debugstr_vt(vt));
 
   if (vt == VT_BSTR || vtFrom == VT_BSTR)
@@ -436,13 +425,13 @@ static inline HRESULT VARIANT_Coerce(VARIANTARG* pd, LCID lcid, USHORT wFlags,
     {
     case VT_EMPTY:
     case VT_BOOL:
-       DEC_SIGNSCALE(&V_DECIMAL(pd)) = SIGNSCALE(DECIMAL_POS,0);
-       DEC_HI32(&V_DECIMAL(pd)) = 0;
-       DEC_MID32(&V_DECIMAL(pd)) = 0;
+       V_DECIMAL(pd).sign = DECIMAL_POS;
+       V_DECIMAL(pd).scale = 0;
+       V_DECIMAL(pd).Hi32 = 0;
         /* VarDecFromBool() coerces to -1/0, ChangeTypeEx() coerces to 1/0.
          * VT_NULL and VT_EMPTY always give a 0 value.
          */
-       DEC_LO32(&V_DECIMAL(pd)) = vtFrom == VT_BOOL && V_BOOL(ps) ? 1 : 0;
+       V_DECIMAL(pd).Lo64 = vtFrom == VT_BOOL && V_BOOL(ps) ? 1 : 0;
        return S_OK;
     case VT_I1:       return VarDecFromI1(V_I1(ps), &V_DECIMAL(pd));
     case VT_I2:       return VarDecFromI2(V_I2(ps), &V_DECIMAL(pd));
@@ -514,13 +503,13 @@ static inline HRESULT VARIANT_CoerceArray(VARIANTARG* pd, VARIANTARG* ps, VARTYP
 
 static HRESULT VARIANT_FetchDispatchValue(LPVARIANT pvDispatch, LPVARIANT pValue)
 {
+    DISPPARAMS params = { 0 };
     HRESULT hres;
-    static DISPPARAMS emptyParams = { NULL, NULL, 0, 0 };
 
     if ((V_VT(pvDispatch) & VT_TYPEMASK) == VT_DISPATCH) {
         if (NULL == V_DISPATCH(pvDispatch)) return DISP_E_TYPEMISMATCH;
         hres = IDispatch_Invoke(V_DISPATCH(pvDispatch), DISPID_VALUE, &IID_NULL,
-            LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &emptyParams, pValue,
+            LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &params, pValue,
             NULL, NULL);
     } else {
         hres = DISP_E_TYPEMISMATCH;
@@ -553,24 +542,13 @@ static inline HRESULT VARIANT_ValidateType(VARTYPE vt)
 /******************************************************************************
  *		VariantInit	[OLEAUT32.8]
  *
- * Initialise a variant.
- *
- * PARAMS
- *  pVarg [O] Variant to initialise
- *
- * RETURNS
- *  Nothing.
- *
- * NOTES
- *  This function simply sets the type of the variant to VT_EMPTY. It does not
- *  free any existing value, use VariantClear() for that.
+ * Since Windows 8.1 whole structure is initialized, before that only type field was reset to VT_EMPTY.
  */
 void WINAPI VariantInit(VARIANTARG* pVarg)
 {
-  TRACE("(%p)\n", pVarg);
+    TRACE("(%p)\n", pVarg);
 
-  /* Win8.1 zeroes whole struct. Previous implementations don't set any other fields. */
-  V_VT(pVarg) = VT_EMPTY;
+    memset(pVarg, 0, sizeof(*pVarg));
 }
 
 HRESULT VARIANT_ClearInd(VARIANTARG *pVarg)
@@ -607,11 +585,11 @@ HRESULT VARIANT_ClearInd(VARIANTARG *pVarg)
     case VT_RECORD:
     case VT_RECORD | VT_BYREF:
     {
-        struct __tagBRECORD* pBr = &V_UNION(pVarg,brecVal);
-        if (pBr->pRecInfo)
+        IRecordInfo *rec_info = V_RECORDINFO(pVarg);
+        if (rec_info)
         {
-            IRecordInfo_RecordClear(pBr->pRecInfo, pBr->pvRecord);
-            IRecordInfo_Release(pBr->pRecInfo);
+            IRecordInfo_RecordClear(rec_info, V_RECORD(pVarg));
+            IRecordInfo_Release(rec_info);
         }
         break;
     }
@@ -667,11 +645,11 @@ HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG* pVarg)
       }
       else if (V_VT(pVarg) == VT_RECORD)
       {
-        struct __tagBRECORD* pBr = &V_UNION(pVarg,brecVal);
-        if (pBr->pRecInfo)
+        IRecordInfo *rec_info = V_RECORDINFO(pVarg);
+        if (rec_info)
         {
-          IRecordInfo_RecordClear(pBr->pRecInfo, pBr->pvRecord);
-          IRecordInfo_Release(pBr->pRecInfo);
+          IRecordInfo_RecordClear(rec_info, V_RECORD(pVarg));
+          IRecordInfo_Release(rec_info);
         }
       }
       else if (V_VT(pVarg) == VT_DISPATCH ||
@@ -689,32 +667,30 @@ HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG* pVarg)
 /******************************************************************************
  * Copy an IRecordInfo object contained in a variant.
  */
-static HRESULT VARIANT_CopyIRecordInfo(VARIANT *dest, VARIANT *src)
+static HRESULT VARIANT_CopyIRecordInfo(VARIANT *dest, const VARIANT *src)
 {
-  struct __tagBRECORD *dest_rec = &V_UNION(dest, brecVal);
-  struct __tagBRECORD *src_rec = &V_UNION(src, brecVal);
+  IRecordInfo *src_info = V_RECORDINFO(src);
   HRESULT hr = S_OK;
   ULONG size;
 
-  if (!src_rec->pRecInfo)
+  if (!src_info)
   {
-    if (src_rec->pvRecord) return E_INVALIDARG;
+    if (V_RECORD(src)) return E_INVALIDARG;
     return S_OK;
   }
 
-  hr = IRecordInfo_GetSize(src_rec->pRecInfo, &size);
+  hr = IRecordInfo_GetSize(src_info, &size);
   if (FAILED(hr)) return hr;
 
-  /* This could look cleaner if only RecordCreate() was used, but native doesn't use it.
-     Memory should be allocated in a same way as RecordCreate() does, so RecordDestroy()
+  /* Windows does not use RecordCreate() here, memory should be allocated in compatible way so RecordDestroy()
      could free it later. */
-  dest_rec->pvRecord = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
-  if (!dest_rec->pvRecord) return E_OUTOFMEMORY;
+  V_RECORD(dest) = CoTaskMemAlloc(size);
+  if (!V_RECORD(dest)) return E_OUTOFMEMORY;
+  if (size)
+      memset(V_RECORD(dest), 0, size);
 
-  dest_rec->pRecInfo = src_rec->pRecInfo;
-  IRecordInfo_AddRef(src_rec->pRecInfo);
-
-  return IRecordInfo_RecordCopy(src_rec->pRecInfo, src_rec->pvRecord, dest_rec->pvRecord);
+  IRecordInfo_AddRef(V_RECORDINFO(dest) = src_info);
+  return IRecordInfo_RecordCopy(src_info, V_RECORD(src), V_RECORD(dest));
 }
 
 /******************************************************************************
@@ -745,7 +721,7 @@ static HRESULT VARIANT_CopyIRecordInfo(VARIANT *dest, VARIANT *src)
  *    reference count increased using IUnknown_AddRef().
  *  - For all by-reference types, only the referencing pointer is copied.
  */
-HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, VARIANTARG* pvargSrc)
+HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, const VARIANTARG* pvargSrc)
 {
   HRESULT hres = S_OK;
 
@@ -844,9 +820,10 @@ static inline size_t VARIANT_DataSize(const VARIANT* pv)
  *    pvargDest is always cleared using VariantClear() before pvargSrc is copied
  *    to it. If clearing pvargDest fails, so does this function.
  */
-HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc)
+HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, const VARIANTARG* pvargSrc)
 {
-  VARIANTARG vTmp, *pSrc = pvargSrc;
+  const VARIANTARG *pSrc = pvargSrc;
+  VARIANTARG vTmp;
   VARTYPE vt;
   HRESULT hres = S_OK;
 
@@ -920,7 +897,7 @@ HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc)
   }
   else if (V_VT(pSrc) == (VT_DECIMAL|VT_BYREF))
   {
-    memcpy(&DEC_SCALE(&V_DECIMAL(pvargDest)), &DEC_SCALE(V_DECIMALREF(pSrc)),
+    memcpy(&V_DECIMAL(pvargDest).scale, &V_DECIMALREF(pSrc)->scale,
            sizeof(DECIMAL) - sizeof(USHORT));
   }
   else
@@ -934,9 +911,9 @@ HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc)
 VariantCopyInd_Return:
 
   if (pSrc != pvargSrc)
-    VariantClear(pSrc);
+    VariantClear(&vTmp);
 
-  TRACE("returning 0x%08x, %s\n", hres, debugstr_variant(pvargDest));
+  TRACE("returning %#lx, %s\n", hres, debugstr_variant(pvargDest));
   return hres;
 }
 
@@ -959,7 +936,7 @@ VariantCopyInd_Return:
  *  The LCID used for the conversion is LOCALE_USER_DEFAULT.
  *  See VariantChangeTypeEx.
  */
-HRESULT WINAPI DECLSPEC_HOTPATCH VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
+HRESULT WINAPI DECLSPEC_HOTPATCH VariantChangeType(VARIANTARG* pvargDest, const VARIANTARG* pvargSrc,
                                                    USHORT wFlags, VARTYPE vt)
 {
   return VariantChangeTypeEx( pvargDest, pvargSrc, LOCALE_USER_DEFAULT, wFlags, vt );
@@ -985,12 +962,12 @@ HRESULT WINAPI DECLSPEC_HOTPATCH VariantChangeType(VARIANTARG* pvargDest, VARIAN
  *  pvargDest and pvargSrc can point to the same variant to perform an in-place
  *  conversion. If the conversion is successful, pvargSrc will be freed.
  */
-HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
+HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, const VARIANTARG* pvargSrc,
                                    LCID lcid, USHORT wFlags, VARTYPE vt)
 {
   HRESULT res = S_OK;
 
-  TRACE("(%s,%s,0x%08x,0x%04x,%s)\n", debugstr_variant(pvargDest),
+  TRACE("%s, %s, %#lx, 0x%04x, %s.\n", debugstr_variant(pvargDest),
         debugstr_variant(pvargSrc), lcid, wFlags, debugstr_vt(vt));
 
   if (vt == VT_CLSID)
@@ -1039,7 +1016,7 @@ HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
     }
   }
 
-  TRACE("returning 0x%08x, %s\n", res, debugstr_variant(pvargDest));
+  TRACE("returning %#lx, %s\n", res, debugstr_variant(pvargDest));
   return res;
 }
 
@@ -1123,11 +1100,11 @@ static HRESULT VARIANT_RollUdate(UDATE *lpUd)
 
   if (iYear > 9999 || iYear < -9999)
     return E_INVALIDARG; /* Invalid value */
-  /* Year 0 to 29 are treated as 2000 + year */
-  if (iYear >= 0 && iYear < 30)
+  /* Years 0 to 49 are treated as 2000 + year, see also VARIANT_MakeDate() */
+  if (0 <= iYear && iYear <= 49)
     iYear += 2000;
-  /* Remaining years < 100 are treated as 1900 + year */
-  else if (iYear >= 30 && iYear < 100)
+  /* Remaining years 50 to 99 are treated as 1900 + year */
+  else if (50 <= iYear && iYear <= 99)
     iYear += 1900;
 
   iMinute += iSecond / 60;
@@ -1347,7 +1324,7 @@ HRESULT WINAPI VarDateFromUdateEx(UDATE *pUdateIn, LCID lcid, ULONG dwFlags, DAT
   UDATE ud;
   double dateVal = 0;
 
-  TRACE("(%p->%d/%d/%d %d:%d:%d:%d %d %d,0x%08x,0x%08x,%p)\n", pUdateIn,
+  TRACE("%p, %d/%d/%d, %d:%d:%d:%d, %#x, %d, %#lx, %#lx, %p.\n", pUdateIn,
         pUdateIn->st.wMonth, pUdateIn->st.wDay, pUdateIn->st.wYear,
         pUdateIn->st.wHour, pUdateIn->st.wMinute, pUdateIn->st.wSecond,
         pUdateIn->st.wMilliseconds, pUdateIn->st.wDayOfWeek,
@@ -1356,7 +1333,7 @@ HRESULT WINAPI VarDateFromUdateEx(UDATE *pUdateIn, LCID lcid, ULONG dwFlags, DAT
   if (lcid != MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT))
     FIXME("lcid possibly not handled, treating as en-us\n");
   if (dwFlags & ~(VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY))
-    FIXME("unsupported flags: %x\n", dwFlags);
+    FIXME("unsupported flags: %lx\n", dwFlags);
 
   ud = *pUdateIn;
 
@@ -1434,7 +1411,7 @@ HRESULT WINAPI VarUdateFromDate(DATE dateIn, ULONG dwFlags, UDATE *lpUdate)
   double datePart, timePart;
   int julianDays;
 
-  TRACE("(%g,0x%08x,%p)\n", dateIn, dwFlags, lpUdate);
+  TRACE("%g, %#lx, %p.\n", dateIn, dwFlags, lpUdate);
 
   if (dateIn <= (DATE_MIN - 1.0) || dateIn >= (DATE_MAX + 1.0))
     return E_INVALIDARG;
@@ -1506,36 +1483,34 @@ HRESULT WINAPI VarUdateFromDate(DATE dateIn, ULONG dwFlags, UDATE *lpUdate)
   return S_OK;
 }
 
+/* The localised characters that make up a valid number */
+typedef struct tagVARIANT_NUMBER_CHARS
+{
+  WCHAR cNegativeSymbol;
+  WCHAR cPositiveSymbol;
+  WCHAR cDecimalPoint;
+  WCHAR cDigitSeparator;
+  DWORD sCurrencyLen;
+  WCHAR sCurrency[8];
+  WCHAR cCurrencyDecimalPoint;
+  WCHAR cCurrencyDigitSeparator;
+} VARIANT_NUMBER_CHARS;
+
 #define GET_NUMBER_TEXT(fld,name) \
   buff[0] = 0; \
-  if (!GetLocaleInfoW(lcid, lctype|fld, buff, 2)) \
+  if (!GetLocaleInfoW(lcid, lctype|fld, buff, ARRAY_SIZE(buff))) \
     WARN("buffer too small for " #fld "\n"); \
   else \
     if (buff[0]) lpChars->name = buff[0]; \
-  TRACE("lcid 0x%x, " #name "=%d '%c'\n", lcid, lpChars->name, lpChars->name)
+  TRACE("lcid 0x%lx, " #name "=%s\n", lcid, wine_dbgstr_wn(&lpChars->name, 1))
 
 /* Get the valid number characters for an lcid */
 static void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS *lpChars, LCID lcid, DWORD dwFlags)
 {
-  static const VARIANT_NUMBER_CHARS defaultChars = { '-','+','.',',','$',0,'.',',' };
-  static VARIANT_NUMBER_CHARS lastChars;
-  static LCID lastLcid = -1;
-  static DWORD lastFlags = 0;
+  static const VARIANT_NUMBER_CHARS defaultChars = { '-','+','.',0,1,{'$',0},0,',' };
   LCTYPE lctype = dwFlags & LOCALE_NOUSEROVERRIDE;
   WCHAR buff[4];
 
-  /* To make caching thread-safe, a critical section is needed */
-  EnterCriticalSection(&cache_cs);
-
-  /* Asking for default locale entries is very expensive: It is a registry
-     server call. So cache one locally, as Microsoft does it too */
-  if(lcid == lastLcid && dwFlags == lastFlags)
-  {
-    memcpy(lpChars, &lastChars, sizeof(defaultChars));
-    LeaveCriticalSection(&cache_cs);
-    return;
-  }
-
   memcpy(lpChars, &defaultChars, sizeof(defaultChars));
   GET_NUMBER_TEXT(LOCALE_SNEGATIVESIGN, cNegativeSymbol);
   GET_NUMBER_TEXT(LOCALE_SPOSITIVESIGN, cPositiveSymbol);
@@ -1544,22 +1519,16 @@ static void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS *lpChars, LCID
   GET_NUMBER_TEXT(LOCALE_SMONDECIMALSEP, cCurrencyDecimalPoint);
   GET_NUMBER_TEXT(LOCALE_SMONTHOUSANDSEP, cCurrencyDigitSeparator);
 
-  /* Local currency symbols are often 2 characters */
-  lpChars->cCurrencyLocal2 = '\0';
-  switch(GetLocaleInfoW(lcid, lctype|LOCALE_SCURRENCY, buff, ARRAY_SIZE(buff)))
+  if (!GetLocaleInfoW(lcid, lctype|LOCALE_SCURRENCY, lpChars->sCurrency, ARRAY_SIZE(lpChars->sCurrency)))
   {
-    case 3: lpChars->cCurrencyLocal2 = buff[1]; /* Fall through */
-    case 2: lpChars->cCurrencyLocal  = buff[0];
-            break;
-    default: WARN("buffer too small for LOCALE_SCURRENCY\n");
+    if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+      WARN("buffer too small for LOCALE_SCURRENCY\n");
+    *lpChars->sCurrency = 0;
   }
-  TRACE("lcid 0x%x, cCurrencyLocal =%d,%d '%c','%c'\n", lcid, lpChars->cCurrencyLocal,
-        lpChars->cCurrencyLocal2, lpChars->cCurrencyLocal, lpChars->cCurrencyLocal2);
-
-  memcpy(&lastChars, lpChars, sizeof(defaultChars));
-  lastLcid = lcid;
-  lastFlags = dwFlags;
-  LeaveCriticalSection(&cache_cs);
+  if (!*lpChars->sCurrency)
+    wcscpy(lpChars->sCurrency, L"$");
+  lpChars->sCurrencyLen = wcslen(lpChars->sCurrency);
+  TRACE("lcid %#lx, sCurrency %lu %s\n", lcid, lpChars->sCurrencyLen, wine_dbgstr_w(lpChars->sCurrency));
 }
 
 /* Number Parsing States */
@@ -1571,6 +1540,11 @@ static void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS *lpChars, LCID
 #define B_PROCESSING_HEX      0x20
 #define B_PROCESSING_OCT      0x40
 
+static inline BOOL is_digit(WCHAR c)
+{
+    return '0' <= c && c <= '9';
+}
+
 /**********************************************************************
  *              VarParseNumFromStr [OLEAUT32.46]
  *
@@ -1601,7 +1575,7 @@ static void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS *lpChars, LCID
  *  - I am unsure if this function should parse non-Arabic (e.g. Thai)
  *   numerals, so this has not been implemented.
  */
-HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
+HRESULT WINAPI VarParseNumFromStr(const OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
                                   NUMPARSE *pNumprs, BYTE *rgbDig)
 {
   VARIANT_NUMBER_CHARS chars;
@@ -1609,8 +1583,9 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
   DWORD dwState = B_EXPONENT_START|B_INEXACT_ZEROS;
   int iMaxDigits = ARRAY_SIZE(rgbTmp);
   int cchUsed = 0;
+  OLECHAR cDigitSeparator2;
 
-  TRACE("(%s,%d,0x%08x,%p,%p)\n", debugstr_w(lpszStr), lcid, dwFlags, pNumprs, rgbDig);
+  TRACE("%s, %#lx, %#lx, %p, %p.\n", debugstr_w(lpszStr), lcid, dwFlags, pNumprs, rgbDig);
 
   if (!pNumprs || !rgbDig)
     return E_INVALIDARG;
@@ -1628,11 +1603,42 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
     return DISP_E_TYPEMISMATCH;
 
   VARIANT_GetLocalisedNumberChars(&chars, lcid, dwFlags);
+  if (chars.cDigitSeparator == chars.cDecimalPoint)
+    /* The decimal point completely masks the digit separator */
+    chars.cDigitSeparator = 0;
+  /* Setting the thousands separator to a non-breaking space implies regular
+   * spaces are allowed too. But the converse is not true.
+   */
+  cDigitSeparator2 = chars.cDigitSeparator == 0xa0 ? ' ' : 0;
 
   /* First consume all the leading symbols and space from the string */
   while (1)
   {
-    if (pNumprs->dwInFlags & NUMPRS_LEADING_WHITE && iswspace(*lpszStr))
+    if (pNumprs->dwInFlags & NUMPRS_DECIMAL &&
+        (*lpszStr == chars.cDecimalPoint ||
+         *lpszStr == chars.cCurrencyDecimalPoint))
+    {
+      pNumprs->dwOutFlags |= NUMPRS_DECIMAL;
+      if (*lpszStr == chars.cCurrencyDecimalPoint &&
+        chars.cDecimalPoint != chars.cCurrencyDecimalPoint)
+        pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
+      cchUsed++;
+      lpszStr++;
+
+      /* If we have no digits so far, skip leading zeros */
+      if (!pNumprs->cDig)
+      {
+        while (*lpszStr == '0')
+        {
+          dwState |= B_LEADING_ZERO;
+          cchUsed++;
+          lpszStr++;
+          pNumprs->nPwr10--;
+        }
+      }
+      break;
+    }
+    else if (pNumprs->dwInFlags & NUMPRS_LEADING_WHITE && iswspace(*lpszStr))
     {
       pNumprs->dwOutFlags |= NUMPRS_LEADING_WHITE;
       do
@@ -1641,6 +1647,17 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
         lpszStr++;
       } while (iswspace(*lpszStr));
     }
+    else if (pNumprs->dwInFlags & NUMPRS_THOUSANDS &&
+             ((chars.cDigitSeparator && *lpszStr == chars.cDigitSeparator) ||
+              (cDigitSeparator2 && *lpszStr == cDigitSeparator2)))
+    {
+      return DISP_E_TYPEMISMATCH; /* Not allowed before the first digit */
+    }
+    else if ((pNumprs->dwInFlags & (NUMPRS_THOUSANDS|NUMPRS_CURRENCY)) == (NUMPRS_THOUSANDS|NUMPRS_CURRENCY) &&
+             chars.cCurrencyDigitSeparator && *lpszStr == chars.cCurrencyDigitSeparator)
+    {
+      return DISP_E_TYPEMISMATCH; /* Not allowed before the first digit */
+    }
     else if (pNumprs->dwInFlags & NUMPRS_LEADING_PLUS &&
              *lpszStr == chars.cPositiveSymbol &&
              !(pNumprs->dwOutFlags & NUMPRS_LEADING_PLUS))
@@ -1659,15 +1676,11 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
     }
     else if (pNumprs->dwInFlags & NUMPRS_CURRENCY &&
              !(pNumprs->dwOutFlags & NUMPRS_CURRENCY) &&
-             *lpszStr == chars.cCurrencyLocal &&
-             (!chars.cCurrencyLocal2 || lpszStr[1] == chars.cCurrencyLocal2))
+             wcsncmp(lpszStr, chars.sCurrency, chars.sCurrencyLen) == 0)
     {
       pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
-      cchUsed++;
-      lpszStr++;
-      /* Only accept currency characters */
-      chars.cDecimalPoint = chars.cCurrencyDecimalPoint;
-      chars.cDigitSeparator = chars.cCurrencyDigitSeparator;
+      cchUsed += chars.sCurrencyLen;
+      lpszStr += chars.sCurrencyLen;
     }
     else if (pNumprs->dwInFlags & NUMPRS_PARENS && *lpszStr == '(' &&
              !(pNumprs->dwOutFlags & NUMPRS_PARENS))
@@ -1680,28 +1693,24 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
       break;
   }
 
-  if (!(pNumprs->dwOutFlags & NUMPRS_CURRENCY))
-  {
-    /* Only accept non-currency characters */
-    chars.cCurrencyDecimalPoint = chars.cDecimalPoint;
-    chars.cCurrencyDigitSeparator = chars.cDigitSeparator;
-  }
-
-  if ((*lpszStr == '&' && (*(lpszStr+1) == 'H' || *(lpszStr+1) == 'h')) &&
-    pNumprs->dwInFlags & NUMPRS_HEX_OCT)
+  if (!(pNumprs->dwOutFlags & (NUMPRS_CURRENCY|NUMPRS_DECIMAL)))
   {
+    if ((*lpszStr == '&' && (*(lpszStr+1) == 'H' || *(lpszStr+1) == 'h')) &&
+        pNumprs->dwInFlags & NUMPRS_HEX_OCT)
+    {
       dwState |= B_PROCESSING_HEX;
       pNumprs->dwOutFlags |= NUMPRS_HEX_OCT;
       cchUsed=cchUsed+2;
       lpszStr=lpszStr+2;
-  }
-  else if ((*lpszStr == '&' && (*(lpszStr+1) == 'O' || *(lpszStr+1) == 'o')) &&
-    pNumprs->dwInFlags & NUMPRS_HEX_OCT)
-  {
+    }
+    else if ((*lpszStr == '&' && (*(lpszStr+1) == 'O' || *(lpszStr+1) == 'o')) &&
+             pNumprs->dwInFlags & NUMPRS_HEX_OCT)
+    {
       dwState |= B_PROCESSING_OCT;
       pNumprs->dwOutFlags |= NUMPRS_HEX_OCT;
       cchUsed=cchUsed+2;
       lpszStr=lpszStr+2;
+    }
   }
 
   /* Strip Leading zeros */
@@ -1714,14 +1723,14 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
 
   while (*lpszStr)
   {
-    if (iswdigit(*lpszStr))
+    if (is_digit(*lpszStr))
     {
       if (dwState & B_PROCESSING_EXPONENT)
       {
         int exponentSize = 0;
         if (dwState & B_EXPONENT_START)
         {
-          if (!iswdigit(*lpszStr))
+          if (!is_digit(*lpszStr))
             break; /* No exponent digits - invalid */
           while (*lpszStr == '0')
           {
@@ -1731,7 +1740,7 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
           }
         }
 
-        while (iswdigit(*lpszStr))
+        while (is_digit(*lpszStr))
         {
           exponentSize *= 10;
           exponentSize += *lpszStr - '0';
@@ -1775,16 +1784,30 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
         cchUsed++;
       }
     }
-    else if (*lpszStr == chars.cDigitSeparator && pNumprs->dwInFlags & NUMPRS_THOUSANDS)
+    else if (pNumprs->dwInFlags & NUMPRS_THOUSANDS &&
+             !(pNumprs->dwOutFlags & NUMPRS_HEX_OCT) &&
+             ((chars.cDigitSeparator && *lpszStr == chars.cDigitSeparator) ||
+              (cDigitSeparator2 && *lpszStr == cDigitSeparator2)))
     {
       pNumprs->dwOutFlags |= NUMPRS_THOUSANDS;
       cchUsed++;
     }
-    else if (*lpszStr == chars.cDecimalPoint &&
-             pNumprs->dwInFlags & NUMPRS_DECIMAL &&
-             !(pNumprs->dwOutFlags & (NUMPRS_DECIMAL|NUMPRS_EXPONENT)))
+    else if ((pNumprs->dwInFlags & (NUMPRS_THOUSANDS|NUMPRS_CURRENCY)) == (NUMPRS_THOUSANDS|NUMPRS_CURRENCY) &&
+             !(pNumprs->dwOutFlags & NUMPRS_HEX_OCT) &&
+             chars.cCurrencyDigitSeparator && *lpszStr == chars.cCurrencyDigitSeparator)
+    {
+      pNumprs->dwOutFlags |= NUMPRS_THOUSANDS|NUMPRS_CURRENCY;
+      cchUsed++;
+    }
+    else if (pNumprs->dwInFlags & NUMPRS_DECIMAL &&
+             (*lpszStr == chars.cDecimalPoint ||
+              *lpszStr == chars.cCurrencyDecimalPoint) &&
+             !(pNumprs->dwOutFlags & (NUMPRS_HEX_OCT|NUMPRS_DECIMAL|NUMPRS_EXPONENT)))
     {
       pNumprs->dwOutFlags |= NUMPRS_DECIMAL;
+      if (*lpszStr == chars.cCurrencyDecimalPoint &&
+        chars.cDecimalPoint != chars.cCurrencyDecimalPoint)
+        pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
       cchUsed++;
 
       /* If we have no digits so far, skip leading zeros */
@@ -1819,7 +1842,7 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
     }
     else if ((*lpszStr == 'e' || *lpszStr == 'E') &&
              pNumprs->dwInFlags & NUMPRS_EXPONENT &&
-             !(pNumprs->dwOutFlags & NUMPRS_EXPONENT))
+             !(pNumprs->dwOutFlags & (NUMPRS_HEX_OCT|NUMPRS_CURRENCY|NUMPRS_EXPONENT)))
     {
       dwState |= B_PROCESSING_EXPONENT;
       pNumprs->dwOutFlags |= NUMPRS_EXPONENT;
@@ -1903,7 +1926,38 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
   /* Consume any trailing symbols and space */
   while (1)
   {
-    if ((pNumprs->dwInFlags & NUMPRS_TRAILING_WHITE) && iswspace(*lpszStr))
+    if ((chars.cDigitSeparator && *lpszStr == chars.cDigitSeparator) ||
+        (cDigitSeparator2 && *lpszStr == cDigitSeparator2))
+    {
+      if (pNumprs->dwInFlags & NUMPRS_THOUSANDS &&
+          !(pNumprs->dwOutFlags & NUMPRS_HEX_OCT))
+      {
+        pNumprs->dwOutFlags |= NUMPRS_THOUSANDS;
+        cchUsed++;
+        lpszStr++;
+      }
+      else
+      {
+        /* Not allowed, even with NUMPRS_TRAILING_WHITE */
+        break;
+      }
+    }
+    else if (*lpszStr == chars.cCurrencyDigitSeparator)
+    {
+      if ((pNumprs->dwInFlags & (NUMPRS_THOUSANDS|NUMPRS_CURRENCY)) == (NUMPRS_THOUSANDS|NUMPRS_CURRENCY) &&
+          !(pNumprs->dwOutFlags & NUMPRS_HEX_OCT))
+      {
+        pNumprs->dwOutFlags |= NUMPRS_THOUSANDS|NUMPRS_CURRENCY;
+        cchUsed++;
+        lpszStr++;
+      }
+      else
+      {
+        /* Not allowed, even with NUMPRS_TRAILING_WHITE */
+        break;
+      }
+    }
+    else if ((pNumprs->dwInFlags & NUMPRS_TRAILING_WHITE) && iswspace(*lpszStr))
     {
       pNumprs->dwOutFlags |= NUMPRS_TRAILING_WHITE;
       do
@@ -1935,6 +1989,14 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
       lpszStr++;
       pNumprs->dwOutFlags |= NUMPRS_NEG;
     }
+    else if (pNumprs->dwInFlags & NUMPRS_CURRENCY &&
+             !(pNumprs->dwOutFlags & NUMPRS_HEX_OCT) &&
+             wcsncmp(lpszStr, chars.sCurrency, chars.sCurrencyLen) == 0)
+    {
+      pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
+      cchUsed += chars.sCurrencyLen;
+      lpszStr += chars.sCurrencyLen;
+    }
     else
       break;
   }
@@ -2016,7 +2078,7 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
 
   int wholeNumberDigits, fractionalDigits, divisor10 = 0, multiplier10 = 0;
 
-  TRACE("(%p,%p,0x%x,%p)\n", pNumprs, rgbDig, dwVtBits, pVarDst);
+  TRACE("%p, %p, %lx, %p.\n", pNumprs, rgbDig, dwVtBits, pVarDst);
 
   if (pNumprs->nBaseShift)
   {
@@ -2091,9 +2153,10 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
     else if ((dwVtBits & VTBIT_DECIMAL) == VTBIT_DECIMAL)
     {
       V_VT(pVarDst) = VT_DECIMAL;
-      DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_POS,0);
-      DEC_HI32(&V_DECIMAL(pVarDst)) = 0;
-      DEC_LO64(&V_DECIMAL(pVarDst)) = ul64;
+      V_DECIMAL(pVarDst).sign = DECIMAL_POS;
+      V_DECIMAL(pVarDst).scale = 0;
+      V_DECIMAL(pVarDst).Hi32 = 0;
+      V_DECIMAL(pVarDst).Lo64 = ul64;
       return S_OK;
     }
     else if (dwVtBits & VTBIT_R4 && ((ul64 <= I4_MAX)||(l64 >= I4_MIN)))
@@ -2115,7 +2178,7 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
       return S_OK;
     }
 
-    TRACE("Overflow: possible return types: 0x%x, value: %s\n", dwVtBits, wine_dbgstr_longlong(ul64));
+    TRACE("Overflow: possible return types: %#lx, value: %s\n", dwVtBits, wine_dbgstr_longlong(ul64));
     return DISP_E_OVERFLOW;
   }
 
@@ -2276,9 +2339,10 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
         {
           /* Decimal is only output choice left - fast path */
           V_VT(pVarDst) = VT_DECIMAL;
-          DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_NEG,0);
-          DEC_HI32(&V_DECIMAL(pVarDst)) = 0;
-          DEC_LO64(&V_DECIMAL(pVarDst)) = -ul64;
+          V_DECIMAL(pVarDst).sign = DECIMAL_NEG;
+          V_DECIMAL(pVarDst).scale = 0;
+          V_DECIMAL(pVarDst).Hi32 = 0;
+          V_DECIMAL(pVarDst).Lo64 = -ul64;
           return S_OK;
         }
       }
@@ -2338,9 +2402,10 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
       {
         /* Decimal is only output choice left - fast path */
         V_VT(pVarDst) = VT_DECIMAL;
-        DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_POS,0);
-        DEC_HI32(&V_DECIMAL(pVarDst)) = 0;
-        DEC_LO64(&V_DECIMAL(pVarDst)) = ul64;
+        V_DECIMAL(pVarDst).sign = DECIMAL_POS;
+        V_DECIMAL(pVarDst).scale = 0;
+        V_DECIMAL(pVarDst).Hi32 = 0;
+        V_DECIMAL(pVarDst).Lo64 = ul64;
         return S_OK;
       }
     }
@@ -2446,30 +2511,30 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
     DECIMAL* pDec = &V_DECIMAL(pVarDst);
 
     DECIMAL_SETZERO(*pDec);
-    DEC_LO32(pDec) = 0;
+    pDec->Lo32 = 0;
 
     if (pNumprs->dwOutFlags & NUMPRS_NEG)
-      DEC_SIGN(pDec) = DECIMAL_NEG;
+      pDec->sign = DECIMAL_NEG;
     else
-      DEC_SIGN(pDec) = DECIMAL_POS;
+      pDec->sign = DECIMAL_POS;
 
     /* Factor the significant digits */
     for (i = 0; i < pNumprs->cDig; i++)
     {
-      tmp = (ULONG64)DEC_LO32(pDec) * 10 + rgbDig[i];
+      tmp = (ULONG64)pDec->Lo32 * 10 + rgbDig[i];
       carry = (ULONG)(tmp >> 32);
-      DEC_LO32(pDec) = (ULONG)(tmp & UI4_MAX);
-      tmp = (ULONG64)DEC_MID32(pDec) * 10 + carry;
+      pDec->Lo32 = (ULONG)tmp;
+      tmp = (ULONG64)pDec->Mid32 * 10 + carry;
       carry = (ULONG)(tmp >> 32);
-      DEC_MID32(pDec) = (ULONG)(tmp & UI4_MAX);
-      tmp = (ULONG64)DEC_HI32(pDec) * 10 + carry;
-      DEC_HI32(pDec) = (ULONG)(tmp & UI4_MAX);
+      pDec->Mid32 = (ULONG)tmp;
+      tmp = (ULONG64)pDec->Hi32 * 10 + carry;
+      pDec->Hi32 = (ULONG)tmp;
 
-      if (tmp >> 32 & UI4_MAX)
+      if (tmp >> 32)
       {
 VarNumFromParseNum_DecOverflow:
         TRACE("Overflow\n");
-        DEC_LO32(pDec) = DEC_MID32(pDec) = DEC_HI32(pDec) = UI4_MAX;
+        pDec->Lo32 = pDec->Mid32 = pDec->Hi32 = UI4_MAX;
         return DISP_E_OVERFLOW;
       }
     }
@@ -2477,20 +2542,20 @@ VarNumFromParseNum_DecOverflow:
     /* Account for the scale of the number */
     while (multiplier10 > 0)
     {
-      tmp = (ULONG64)DEC_LO32(pDec) * 10;
+      tmp = (ULONG64)pDec->Lo32 * 10;
       carry = (ULONG)(tmp >> 32);
-      DEC_LO32(pDec) = (ULONG)(tmp & UI4_MAX);
-      tmp = (ULONG64)DEC_MID32(pDec) * 10 + carry;
+      pDec->Lo32 = (ULONG)tmp;
+      tmp = (ULONG64)pDec->Mid32 * 10 + carry;
       carry = (ULONG)(tmp >> 32);
-      DEC_MID32(pDec) = (ULONG)(tmp & UI4_MAX);
-      tmp = (ULONG64)DEC_HI32(pDec) * 10 + carry;
-      DEC_HI32(pDec) = (ULONG)(tmp & UI4_MAX);
+      pDec->Mid32 = (ULONG)tmp;
+      tmp = (ULONG64)pDec->Hi32 * 10 + carry;
+      pDec->Hi32 = (ULONG)tmp;
 
-      if (tmp >> 32 & UI4_MAX)
+      if (tmp >> 32)
         goto VarNumFromParseNum_DecOverflow;
       multiplier10--;
     }
-    DEC_SCALE(pDec) = divisor10;
+    pDec->scale = divisor10;
 
     V_VT(pVarDst) = VT_DECIMAL;
     return S_OK;
@@ -2716,7 +2781,7 @@ HRESULT WINAPI VarCmp(LPVARIANT left, LPVARIANT right, LCID lcid, DWORD flags)
     DWORD       xmask;
     HRESULT     rc;
 
-    TRACE("(%s,%s,0x%08x,0x%08x)\n", debugstr_variant(left), debugstr_variant(right), lcid, flags);
+    TRACE("%s, %s, %#lx, %#lx.\n", debugstr_variant(left), debugstr_variant(right), lcid, flags);
 
     lvt = V_VT(left) & VT_TYPEMASK;
     rvt = V_VT(right) & VT_TYPEMASK;
@@ -3009,8 +3074,7 @@ HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
                     resvt = VT_NULL;
                 break;
             case VT_DECIMAL:
-                if (DEC_HI32(&V_DECIMAL(right)) ||
-                    DEC_LO64(&V_DECIMAL(right)))
+                if (V_DECIMAL(right).Hi32 || V_DECIMAL(right).Lo64)
                     resvt = VT_NULL;
                 break;
             case VT_BSTR:
@@ -3311,7 +3375,7 @@ end:
     VariantClear(&tv);
     VariantClear(&tempLeft);
     VariantClear(&tempRight);
-    TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
+    TRACE("returning %#lx, %s\n", hres, debugstr_variant(result));
     return hres;
 }
 
@@ -3500,7 +3564,7 @@ end:
     VariantClear(&tv);
     VariantClear(&tempLeft);
     VariantClear(&tempRight);
-    TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
+    TRACE("returning %#lx, %s\n", hres, debugstr_variant(result));
     return hres;
 }
 
@@ -3662,7 +3726,7 @@ end:
     VariantClear(&rv);
     VariantClear(&tempLeft);
     VariantClear(&tempRight);
-    TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
+    TRACE("returning %#lx, %s\n", hres, debugstr_variant(result));
     return hres;
 }
 
@@ -3925,7 +3989,7 @@ end:
     VariantClear(&rv);
     VariantClear(&tempLeft);
     VariantClear(&tempRight);
-    TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
+    TRACE("returning %#lx, %s\n", hres, debugstr_variant(result));
     return hres;
 }
 
@@ -4045,7 +4109,7 @@ HRESULT WINAPI VarOr(LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut)
             hRet = S_OK;
             goto VarOr_Exit;
         case VT_DECIMAL:
-            if (DEC_HI32(&V_DECIMAL(pVarLeft)) || DEC_LO64(&V_DECIMAL(pVarLeft)))
+            if (V_DECIMAL(pVarLeft).Hi32 || V_DECIMAL(pVarLeft).Lo64)
                 goto VarOr_AsEmpty;
             hRet = S_OK;
             goto VarOr_Exit;
@@ -4262,7 +4326,6 @@ VarOr_Exit:
  */
 HRESULT WINAPI VarAbs(LPVARIANT pVarIn, LPVARIANT pVarOut)
 {
-    VARIANT varIn;
     HRESULT hRet = S_OK;
     VARIANT temp;
 
@@ -4302,21 +4365,24 @@ HRESULT WINAPI VarAbs(LPVARIANT pVarIn, LPVARIANT pVarOut)
     case VT_INT:
     ABS_CASE(I4,I4_MIN);
     ABS_CASE(I8,I8_MIN);
-    ABS_CASE(R4,R4_MIN);
+    case VT_R4:
+        if (V_R4(pVarOut) < 0.0) V_R4(pVarOut) = -V_R4(pVarOut);
+        break;
     case VT_BSTR:
-        hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(&varIn));
+        hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(pVarOut));
         if (FAILED(hRet))
             break;
         V_VT(pVarOut) = VT_R8;
-        pVarIn = &varIn;
         /* Fall through ... */
     case VT_DATE:
-    ABS_CASE(R8,R8_MIN);
+    case VT_R8:
+        if (V_R8(pVarOut) < 0.0) V_R8(pVarOut) = -V_R8(pVarOut);
+        break;
     case VT_CY:
         hRet = VarCyAbs(V_CY(pVarIn), & V_CY(pVarOut));
         break;
     case VT_DECIMAL:
-        DEC_SIGN(&V_DECIMAL(pVarOut)) &= ~DECIMAL_NEG;
+        V_DECIMAL(pVarOut).sign &= ~DECIMAL_NEG;
         break;
     case VT_UI1:
     case VT_UI2:
@@ -4568,6 +4634,7 @@ HRESULT WINAPI VarXor(LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut
         return S_OK;
     }
 
+    V_VT(&varLeft) = V_VT(&varRight) = VT_EMPTY;
     VariantInit(&tempLeft);
     VariantInit(&tempRight);
 
@@ -4586,8 +4653,6 @@ HRESULT WINAPI VarXor(LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut
     }
 
     /* Copy our inputs so we don't disturb anything */
-    V_VT(&varLeft) = V_VT(&varRight) = VT_EMPTY;
-
     hRet = VariantCopy(&varLeft, pVarLeft);
     if (FAILED(hRet))
         goto VarXor_Exit;
@@ -5159,7 +5224,7 @@ VarRound_Exit:
       V_VT(pVarOut) = VT_EMPTY;
     VariantClear(&temp);
 
-    TRACE("returning 0x%08x %s\n", hRet, debugstr_variant(pVarOut));
+    TRACE("returning %#lx, %s\n", hRet, debugstr_variant(pVarOut));
     return hRet;
 }
 
@@ -5336,7 +5401,6 @@ end:
  */
 HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
 {
-    BOOL         lOk        = TRUE;
     HRESULT      rc         = E_FAIL;
     int          resT = 0;
     VARIANT      lv,rv;
@@ -5346,6 +5410,7 @@ HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
     VariantInit(&tempRight);
     VariantInit(&lv);
     VariantInit(&rv);
+    V_VT(result) = VT_EMPTY;
 
     TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
 
@@ -5364,7 +5429,6 @@ HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
     }
 
     /* check for invalid inputs */
-    lOk = TRUE;
     switch (V_VT(left) & VT_TYPEMASK) {
     case VT_BOOL :
     case VT_I1   :
@@ -5436,6 +5500,7 @@ HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
       if(V_VT(left) == VT_EMPTY)
       {
 	V_VT(result) = VT_I4;
+        V_I4(result) = 0;
         rc = S_OK;
         goto end;
       }
@@ -5466,15 +5531,10 @@ HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
       {
 	V_VT(result) = VT_EMPTY;
         rc = DISP_E_BADVARTYPE;
-      } else if((V_VT(left) == VT_NULL) || (V_VT(left) == VT_EMPTY) || (V_VT(left) == VT_ERROR) ||
-		lOk)
+      } else
       {
         V_VT(result) = VT_NULL;
         rc = S_OK;
-      } else
-      {
-	V_VT(result) = VT_NULL;
-        rc = DISP_E_BADVARTYPE;
       }
       goto end;
     case VT_VARIANT:
@@ -5486,7 +5546,7 @@ HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
       rc = DISP_E_TYPEMISMATCH;
       goto end;
     case VT_RECORD:
-      if((V_VT(left) == 15) || ((V_VT(left) >= 24) && (V_VT(left) <= 35)) || !lOk)
+      if((V_VT(left) == 15) || ((V_VT(left) >= 24) && (V_VT(left) <= 35)))
       {
 	V_VT(result) = VT_EMPTY;
         rc = DISP_E_BADVARTYPE;
@@ -5519,14 +5579,14 @@ HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
     rc = VariantChangeType(&lv, left, 0, VT_I8);
     if(FAILED(rc))
     {
-      FIXME("Could not convert left type %d to %d? rc == 0x%X\n", V_VT(left), VT_I8, rc);
+      FIXME("Could not convert left type %d to %d? rc == %#lx.\n", V_VT(left), VT_I8, rc);
       goto end;
     }
 
     rc = VariantChangeType(&rv, right, 0, VT_I8);
     if(FAILED(rc))
     {
-      FIXME("Could not convert right type %d to %d? rc == 0x%X\n", V_VT(right), VT_I8, rc);
+      FIXME("Could not convert right type %d to %d? rc == %#lx.\n", V_VT(right), VT_I8, rc);
       goto end;
     }
 
@@ -5803,7 +5863,7 @@ HRESULT WINAPI VarImp(LPVARIANT left, LPVARIANT right, LPVARIANT result)
         case VT_DATE: if (!V_DATE(right)) resvt = VT_NULL; break;
         case VT_CY:   if (!V_CY(right).int64) resvt = VT_NULL; break;
         case VT_DECIMAL:
-            if (!(DEC_HI32(&V_DECIMAL(right)) || DEC_LO64(&V_DECIMAL(right))))
+            if (!(V_DECIMAL(right).Hi32 || V_DECIMAL(right).Lo64))
                 resvt = VT_NULL;
             break;
         case VT_BSTR:
@@ -5853,7 +5913,7 @@ HRESULT WINAPI VarImp(LPVARIANT left, LPVARIANT right, LPVARIANT result)
         case VT_R8:     if (V_R8(left) == -1.0) resvt = VT_NULL; break;
         case VT_CY:     if (V_CY(left).int64 == -1) resvt = VT_NULL; break;
         case VT_DECIMAL:
-            if (DEC_HI32(&V_DECIMAL(left)) == 0xffffffff)
+            if (V_DECIMAL(left).Hi32 == 0xffffffff)
                 resvt = VT_NULL;
             break;
         case VT_BSTR:
diff --git a/dll/win32/oleaut32/variant.h b/dll/win32/oleaut32/variant.h
index df69c60ca60..562903c19f4 100644
--- a/dll/win32/oleaut32/variant.h
+++ b/dll/win32/oleaut32/variant.h
@@ -18,8 +18,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#pragma once
-
 #include "windef.h"
 #include "winerror.h"
 #include "objbase.h"
@@ -76,26 +74,6 @@
 /* Value of sign for a positive decimal number */
 #define DECIMAL_POS 0
 
-/* Native headers don't change the union ordering for DECIMAL sign/scale (duh).
- * This means that the signscale member is only useful for setting both members to 0.
- * SIGNSCALE creates endian-correct values so that we can properly set both at once
- * to values other than 0.
- */
-#ifdef WORDS_BIGENDIAN
-#define SIGNSCALE(sign,scale) (((scale) << 8) | sign)
-#else
-#define SIGNSCALE(sign,scale) (((sign) << 8) | scale)
-#endif
-
-/* Macros for getting at a DECIMAL's parts */
-#define DEC_SIGN(d)      ((d)->u.s.sign)
-#define DEC_SCALE(d)     ((d)->u.s.scale)
-#define DEC_SIGNSCALE(d) ((d)->u.signscale)
-#define DEC_HI32(d)      ((d)->Hi32)
-#define DEC_MID32(d)     ((d)->u1.s1.Mid32)
-#define DEC_LO32(d)      ((d)->u1.s1.Lo32)
-#define DEC_LO64(d)      ((d)->u1.Lo64)
-
 #define DEC_MAX_SCALE    28 /* Maximum scale for a decimal */
 
 /* Internal flags for low level conversion functions */
@@ -103,20 +81,7 @@
 #define  VAR_BOOLYESNO 0x0800 /* Convert bool to "Yes"/"No" */
 #define  VAR_NEGATIVE  0x1000 /* Number is negative */
 
-/* The localised characters that make up a valid number */
-typedef struct tagVARIANT_NUMBER_CHARS
-{
-  WCHAR cNegativeSymbol;
-  WCHAR cPositiveSymbol;
-  WCHAR cDecimalPoint;
-  WCHAR cDigitSeparator;
-  WCHAR cCurrencyLocal;
-  WCHAR cCurrencyLocal2;
-  WCHAR cCurrencyDecimalPoint;
-  WCHAR cCurrencyDigitSeparator;
-} VARIANT_NUMBER_CHARS;
-
-unsigned int get_type_size(ULONG*, VARTYPE) DECLSPEC_HIDDEN;
-HRESULT VARIANT_ClearInd(VARIANTARG *) DECLSPEC_HIDDEN;
+unsigned int get_type_size(ULONG*, VARTYPE);
+HRESULT VARIANT_ClearInd(VARIANTARG *);
 BOOL get_date_format(LCID, DWORD, const SYSTEMTIME *,
-        const WCHAR *, WCHAR *, int) DECLSPEC_HIDDEN;
+        const WCHAR *, WCHAR *, int);
diff --git a/dll/win32/oleaut32/vartype.c b/dll/win32/oleaut32/vartype.c
index cf18d7db2e9..8fc04f22e92 100644
--- a/dll/win32/oleaut32/vartype.c
+++ b/dll/win32/oleaut32/vartype.c
@@ -19,11 +19,6 @@
  */
 
 #define COBJMACROS
-#define NONAMELESSUNION
-#define NONAMELESSSTRUCT
-
-#include <wchar.h>
-
 #include "wine/debug.h"
 #include "winbase.h"
 #include "winuser.h"
@@ -31,18 +26,17 @@
 #include "variant.h"
 #include "resource.h"
 
+#include "locale.h"
+
 WINE_DEFAULT_DEBUG_CHANNEL(variant);
 
-extern HMODULE hProxyDll DECLSPEC_HIDDEN;
+extern HMODULE hProxyDll;
 
 #define CY_MULTIPLIER   10000             /* 4 dp of precision */
 #define CY_MULTIPLIER_F 10000.0
 #define CY_HALF         (CY_MULTIPLIER/2) /* 0.5 */
 #define CY_HALF_F       (CY_MULTIPLIER_F/2.0)
 
-static const WCHAR szFloatFormatW[] = { '%','.','7','G','\0' };
-static const WCHAR szDoubleFormatW[] = { '%','.','1','5','G','\0' };
-
 /* Copy data from one variant to another. */
 static inline void VARIANT_CopyData(const VARIANT *srcVar, VARTYPE vt, void *pOut)
 {
@@ -87,7 +81,7 @@ static inline void VARIANT_CopyData(const VARIANT *srcVar, VARTYPE vt, void *pOu
 
 
 /* Coerce VT_BSTR to a numeric type */
-static HRESULT VARIANT_NumberFromBstr(OLECHAR* pStrIn, LCID lcid, ULONG ulFlags,
+static HRESULT VARIANT_NumberFromBstr(const OLECHAR* pStrIn, LCID lcid, ULONG ulFlags,
                                       void* pOut, VARTYPE vt)
 {
   VARIANTARG dstVar;
@@ -152,15 +146,15 @@ static HRESULT VARIANT_FromDisp(IDispatch* pdispIn, LCID lcid, void* pOut,
 
 /* Compiler cast where input cannot be negative */
 #define NEGTST(dest, src, func) RETTYP _##func(src in, dest* out) { \
-  if (in < 0) return DISP_E_OVERFLOW; *out = in; return S_OK; }
+  if (in < 0) { return DISP_E_OVERFLOW; } *out = in; return S_OK; }
 
 /* Compiler cast where input cannot be > some number */
 #define POSTST(dest, src, func, tst) RETTYP _##func(src in, dest* out) { \
-  if (in > (dest)tst) return DISP_E_OVERFLOW; *out = in; return S_OK; }
+  if (in > (dest)tst) { return DISP_E_OVERFLOW; } *out = in; return S_OK; }
 
 /* Compiler cast where input cannot be < some number or >= some other number */
 #define BOTHTST(dest, src, func, lo, hi) RETTYP _##func(src in, dest* out) { \
-  if (in < (dest)lo || in > hi) return DISP_E_OVERFLOW; *out = in; return S_OK; }
+  if (in < (dest)lo || in > hi) { return DISP_E_OVERFLOW; } *out = in; return S_OK; }
 
 /* I1 */
 POSTST(signed char, BYTE, VarI1FromUI1, I1_MAX)
@@ -424,7 +418,7 @@ HRESULT WINAPI VarI1FromCy(CY cyIn, signed char* pcOut)
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
-HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, signed char* pcOut)
+HRESULT WINAPI VarI1FromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, signed char* pcOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pcOut, VT_I1);
 }
@@ -520,7 +514,7 @@ HRESULT WINAPI VarI1FromUI4(ULONG ulIn, signed char* pcOut)
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
-HRESULT WINAPI VarI1FromDec(DECIMAL *pdecIn, signed char* pcOut)
+HRESULT WINAPI VarI1FromDec(const DECIMAL *pdecIn, signed char* pcOut)
 {
   LONG64 i64;
   HRESULT hRet;
@@ -717,7 +711,7 @@ HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
-HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
+HRESULT WINAPI VarUI1FromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pbOut, VT_UI1);
 }
@@ -831,7 +825,7 @@ HRESULT WINAPI VarUI1FromUI4(ULONG ulIn, BYTE* pbOut)
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
-HRESULT WINAPI VarUI1FromDec(DECIMAL *pdecIn, BYTE* pbOut)
+HRESULT WINAPI VarUI1FromDec(const DECIMAL *pdecIn, BYTE* pbOut)
 {
   LONG64 i64;
   HRESULT hRet;
@@ -1018,7 +1012,7 @@ HRESULT WINAPI VarI2FromDate(DATE dateIn, SHORT* psOut)
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
-HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, SHORT* psOut)
+HRESULT WINAPI VarI2FromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, SHORT* psOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, psOut, VT_I2);
 }
@@ -1128,7 +1122,7 @@ HRESULT WINAPI VarI2FromUI4(ULONG ulIn, SHORT* psOut)
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
-HRESULT WINAPI VarI2FromDec(DECIMAL *pdecIn, SHORT* psOut)
+HRESULT WINAPI VarI2FromDec(const DECIMAL *pdecIn, SHORT* psOut)
 {
   LONG64 i64;
   HRESULT hRet;
@@ -1332,7 +1326,7 @@ HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut)
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
-HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* pusOut)
+HRESULT WINAPI VarUI2FromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* pusOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pusOut, VT_UI2);
 }
@@ -1425,7 +1419,7 @@ HRESULT WINAPI VarUI2FromUI4(ULONG ulIn, USHORT* pusOut)
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
-HRESULT WINAPI VarUI2FromDec(DECIMAL *pdecIn, USHORT* pusOut)
+HRESULT WINAPI VarUI2FromDec(const DECIMAL *pdecIn, USHORT* pusOut)
 {
   LONG64 i64;
   HRESULT hRet;
@@ -1608,7 +1602,7 @@ HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG *piOut)
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if strIn cannot be converted
  */
-HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG *piOut)
+HRESULT WINAPI VarI4FromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG *piOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, piOut, VT_I4);
 }
@@ -1717,7 +1711,7 @@ HRESULT WINAPI VarI4FromUI4(ULONG ulIn, LONG *piOut)
  *  Failure: E_INVALIDARG, if pdecIn is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
-HRESULT WINAPI VarI4FromDec(DECIMAL *pdecIn, LONG *piOut)
+HRESULT WINAPI VarI4FromDec(const DECIMAL *pdecIn, LONG *piOut)
 {
   LONG64 i64;
   HRESULT hRet;
@@ -1917,7 +1911,7 @@ HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG *pulOut)
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if strIn cannot be converted
  */
-HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG *pulOut)
+HRESULT WINAPI VarUI4FromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG *pulOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pulOut, VT_UI4);
 }
@@ -2009,7 +2003,7 @@ HRESULT WINAPI VarUI4FromUI2(USHORT usIn, ULONG *pulOut)
  *  Failure: E_INVALIDARG, if pdecIn is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
-HRESULT WINAPI VarUI4FromDec(DECIMAL *pdecIn, ULONG *pulOut)
+HRESULT WINAPI VarUI4FromDec(const DECIMAL *pdecIn, ULONG *pulOut)
 {
   LONG64 i64;
   HRESULT hRet;
@@ -2179,9 +2173,9 @@ HRESULT WINAPI VarI8FromCy(CY cyIn, LONG64* pi64Out)
     (*pi64Out)--; /* Mimic Win32 bug */
   else
   {
-    cyIn.int64 -= *pi64Out * CY_MULTIPLIER; /* cyIn.s.Lo now holds fractional remainder */
+    cyIn.int64 -= *pi64Out * CY_MULTIPLIER; /* cyIn.Lo now holds fractional remainder */
 
-    if (cyIn.s.Lo > CY_HALF || (cyIn.s.Lo == CY_HALF && (*pi64Out & 0x1)))
+    if (cyIn.Lo > CY_HALF || (cyIn.Lo == CY_HALF && (*pi64Out & 0x1)))
       (*pi64Out)++;
   }
   return S_OK;
@@ -2224,7 +2218,7 @@ HRESULT WINAPI VarI8FromDate(DATE dateIn, LONG64* pi64Out)
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
-HRESULT WINAPI VarI8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG64* pi64Out)
+HRESULT WINAPI VarI8FromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG64* pi64Out)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pi64Out, VT_I8);
 }
@@ -2332,21 +2326,21 @@ HRESULT WINAPI VarI8FromUI4(ULONG ulIn, LONG64* pi64Out)
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
-HRESULT WINAPI VarI8FromDec(DECIMAL *pdecIn, LONG64* pi64Out)
+HRESULT WINAPI VarI8FromDec(const DECIMAL *pdecIn, LONG64* pi64Out)
 {
-  if (!DEC_SCALE(pdecIn))
+  if (!pdecIn->scale)
   {
     /* This decimal is just a 96 bit integer */
-    if (DEC_SIGN(pdecIn) & ~DECIMAL_NEG)
+    if (pdecIn->sign & ~DECIMAL_NEG)
       return E_INVALIDARG;
 
-    if (DEC_HI32(pdecIn) || DEC_MID32(pdecIn) & 0x80000000)
+    if (pdecIn->Hi32 || pdecIn->Mid32 & 0x80000000)
       return DISP_E_OVERFLOW;
 
-    if (DEC_SIGN(pdecIn))
-      *pi64Out = -DEC_LO64(pdecIn);
+    if (pdecIn->sign)
+      *pi64Out = -pdecIn->Lo64;
     else
-      *pi64Out = DEC_LO64(pdecIn);
+      *pi64Out = pdecIn->Lo64;
     return S_OK;
   }
   else
@@ -2507,9 +2501,9 @@ HRESULT WINAPI VarUI8FromCy(CY cyIn, ULONG64* pui64Out)
   {
     *pui64Out = cyIn.int64 / CY_MULTIPLIER;
 
-    cyIn.int64 -= *pui64Out * CY_MULTIPLIER; /* cyIn.s.Lo now holds fractional remainder */
+    cyIn.int64 -= *pui64Out * CY_MULTIPLIER; /* cyIn.Lo now holds fractional remainder */
 
-    if (cyIn.s.Lo > CY_HALF || (cyIn.s.Lo == CY_HALF && (*pui64Out & 0x1)))
+    if (cyIn.Lo > CY_HALF || (cyIn.Lo == CY_HALF && (*pui64Out & 0x1)))
       (*pui64Out)++;
   }
   return S_OK;
@@ -2552,7 +2546,7 @@ HRESULT WINAPI VarUI8FromDate(DATE dateIn, ULONG64* pui64Out)
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
-HRESULT WINAPI VarUI8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG64* pui64Out)
+HRESULT WINAPI VarUI8FromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG64* pui64Out)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pui64Out, VT_UI8);
 }
@@ -2667,24 +2661,24 @@ HRESULT WINAPI VarUI8FromUI4(ULONG ulIn, ULONG64* pui64Out)
  *  with DISP_E_OVERFLOW. This bug has been fixed in Wine's implementation
  *  (use VarAbs() on pDecIn first if you really want this behaviour).
  */
-HRESULT WINAPI VarUI8FromDec(DECIMAL *pdecIn, ULONG64* pui64Out)
+HRESULT WINAPI VarUI8FromDec(const DECIMAL *pdecIn, ULONG64* pui64Out)
 {
-  if (!DEC_SCALE(pdecIn))
+  if (!pdecIn->scale)
   {
     /* This decimal is just a 96 bit integer */
-    if (DEC_SIGN(pdecIn) & ~DECIMAL_NEG)
+    if (pdecIn->sign & ~DECIMAL_NEG)
       return E_INVALIDARG;
 
-    if (DEC_HI32(pdecIn))
+    if (pdecIn->Hi32)
       return DISP_E_OVERFLOW;
 
-    if (DEC_SIGN(pdecIn))
+    if (pdecIn->sign)
     {
       WARN("Sign would be ignored under Win32!\n");
       return DISP_E_OVERFLOW;
     }
 
-    *pui64Out = DEC_LO64(pdecIn);
+    *pui64Out = pdecIn->Lo64;
     return S_OK;
   }
   else
@@ -2827,7 +2821,7 @@ HRESULT WINAPI VarR4FromDate(DATE dateIn, float *pFltOut)
  *  Failure: E_INVALIDARG, if strIn or pFltOut is invalid.
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
-HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, float *pFltOut)
+HRESULT WINAPI VarR4FromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, float *pFltOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pFltOut, VT_R4);
 }
@@ -2943,31 +2937,31 @@ HRESULT WINAPI VarR4FromUI4(ULONG ulIn, float *pFltOut)
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid.
  */
-HRESULT WINAPI VarR4FromDec(DECIMAL* pDecIn, float *pFltOut)
+HRESULT WINAPI VarR4FromDec(const DECIMAL* pDecIn, float *pFltOut)
 {
-  BYTE scale = DEC_SCALE(pDecIn);
+  BYTE scale = pDecIn->scale;
   double divisor = 1.0;
   double highPart;
 
-  if (scale > DEC_MAX_SCALE || DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
+  if (scale > DEC_MAX_SCALE || pDecIn->sign & ~DECIMAL_NEG)
     return E_INVALIDARG;
 
   while (scale--)
     divisor *= 10.0;
 
-  if (DEC_SIGN(pDecIn))
+  if (pDecIn->sign)
     divisor = -divisor;
 
-  if (DEC_HI32(pDecIn))
+  if (pDecIn->Hi32)
   {
-    highPart = (double)DEC_HI32(pDecIn) / divisor;
+    highPart = (double)pDecIn->Hi32 / divisor;
     highPart *= 4294967296.0F;
     highPart *= 4294967296.0F;
   }
   else
     highPart = 0.0;
 
-  *pFltOut = (double)DEC_LO64(pDecIn) / divisor + highPart;
+  *pFltOut = (double)pDecIn->Lo64 / divisor + highPart;
   return S_OK;
 }
 
@@ -3148,7 +3142,7 @@ HRESULT WINAPI VarR8FromDate(DATE dateIn, double *pDblOut)
  *  Failure: E_INVALIDARG, if strIn or pDblOut is invalid.
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
-HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double *pDblOut)
+HRESULT WINAPI VarR8FromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, double *pDblOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pDblOut, VT_R8);
 }
@@ -3266,28 +3260,28 @@ HRESULT WINAPI VarR8FromUI4(ULONG ulIn, double *pDblOut)
  */
 HRESULT WINAPI VarR8FromDec(const DECIMAL* pDecIn, double *pDblOut)
 {
-  BYTE scale = DEC_SCALE(pDecIn);
+  BYTE scale = pDecIn->scale;
   double divisor = 1.0, highPart;
 
-  if (scale > DEC_MAX_SCALE || DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
+  if (scale > DEC_MAX_SCALE || pDecIn->sign & ~DECIMAL_NEG)
     return E_INVALIDARG;
 
   while (scale--)
     divisor *= 10;
 
-  if (DEC_SIGN(pDecIn))
+  if (pDecIn->sign)
     divisor = -divisor;
 
-  if (DEC_HI32(pDecIn))
+  if (pDecIn->Hi32)
   {
-    highPart = (double)DEC_HI32(pDecIn) / divisor;
+    highPart = (double)pDecIn->Hi32 / divisor;
     highPart *= 4294967296.0F;
     highPart *= 4294967296.0F;
   }
   else
     highPart = 0.0;
 
-  *pDblOut = (double)DEC_LO64(pDecIn) / divisor + highPart;
+  *pDblOut = (double)pDecIn->Lo64 / divisor + highPart;
   return S_OK;
 }
 
@@ -3385,7 +3379,7 @@ HRESULT WINAPI VarR8Round(double dblIn, int nDig, double *pDblOut)
   else if (fract >= 0.0)
     dblIn = whole;
   else if (fract == -0.5)
-    dblIn = whole - fmod(whole, 2.0);
+    dblIn = whole + fmod(whole, 2.0);
   else if (fract > -0.5)
     dblIn = whole;
   else
@@ -3572,7 +3566,7 @@ HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pCyOut)
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
-HRESULT WINAPI VarCyFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, CY* pCyOut)
+HRESULT WINAPI VarCyFromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, CY* pCyOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pCyOut, VT_CY);
 }
@@ -3701,7 +3695,7 @@ HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pCyOut)
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
-HRESULT WINAPI VarCyFromDec(DECIMAL* pdecIn, CY* pCyOut)
+HRESULT WINAPI VarCyFromDec(const DECIMAL* pdecIn, CY* pCyOut)
 {
   DECIMAL rounded;
   HRESULT hRet;
@@ -3712,12 +3706,12 @@ HRESULT WINAPI VarCyFromDec(DECIMAL* pdecIn, CY* pCyOut)
   {
     double d;
 
-    if (DEC_HI32(&rounded))
+    if (rounded.Hi32)
       return DISP_E_OVERFLOW;
 
     /* Note: Without the casts this promotes to int64 which loses precision */
-    d = (double)DEC_LO64(&rounded) / (double)CY_Divisors[DEC_SCALE(&rounded)];
-    if (DEC_SIGN(&rounded))
+    d = (double)rounded.Lo64 / (double)CY_Divisors[rounded.scale];
+    if (rounded.sign)
       d = -d;
     return VarCyFromR8(d, pCyOut);
   }
@@ -3875,7 +3869,7 @@ HRESULT WINAPI VarCySub(CY cyLeft, CY cyRight, CY* pCyOut)
  */
 HRESULT WINAPI VarCyAbs(CY cyIn, CY* pCyOut)
 {
-  if (cyIn.s.Hi == (int)0x80000000 && !cyIn.s.Lo)
+  if (cyIn.Hi == 0x80000000 && !cyIn.Lo)
     return DISP_E_OVERFLOW;
 
   pCyOut->int64 = cyIn.int64 < 0 ? -cyIn.int64 : cyIn.int64;
@@ -3950,7 +3944,7 @@ HRESULT WINAPI VarCyInt(CY cyIn, CY* pCyOut)
  */
 HRESULT WINAPI VarCyNeg(CY cyIn, CY* pCyOut)
 {
-  if (cyIn.s.Hi == (int)0x80000000 && !cyIn.s.Lo)
+  if (cyIn.Hi == 0x80000000 && !cyIn.Lo)
     return DISP_E_OVERFLOW;
 
   pCyOut->int64 = -cyIn.int64;
@@ -4130,18 +4124,19 @@ HRESULT WINAPI VarDecFromI2(SHORT sIn, DECIMAL* pDecOut)
  */
 HRESULT WINAPI VarDecFromI4(LONG lIn, DECIMAL* pDecOut)
 {
-  DEC_HI32(pDecOut) = 0;
-  DEC_MID32(pDecOut) = 0;
+  pDecOut->Hi32 = 0;
+  pDecOut->Mid32 = 0;
+  pDecOut->scale = 0;
 
   if (lIn < 0)
   {
-    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_NEG,0);
-    DEC_LO32(pDecOut) = -lIn;
+      pDecOut->sign = DECIMAL_NEG;
+      pDecOut->Lo32 = -lIn;
   }
   else
   {
-    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
-    DEC_LO32(pDecOut) = lIn;
+      pDecOut->sign = DECIMAL_POS;
+      pDecOut->Lo32 = lIn;
   }
   return S_OK;
 }
@@ -4238,19 +4233,18 @@ HRESULT WINAPI VarDecFromDate(DATE dateIn, DECIMAL* pDecOut)
  */
 HRESULT WINAPI VarDecFromCy(CY cyIn, DECIMAL* pDecOut)
 {
-  DEC_HI32(pDecOut) = 0;
+  pDecOut->Hi32 = 0;
+  pDecOut->scale = 4;
 
-  /* Note: This assumes 2s complement integer representation */
-  if (cyIn.s.Hi & 0x80000000)
+  if (cyIn.int64 < 0)
   {
-    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_NEG,4);
-    DEC_LO64(pDecOut) = -cyIn.int64;
+      pDecOut->sign = DECIMAL_NEG;
+      pDecOut->Lo64 = -cyIn.int64;
   }
   else
   {
-    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,4);
-    DEC_MID32(pDecOut) = cyIn.s.Hi;
-    DEC_LO32(pDecOut) = cyIn.s.Lo;
+      pDecOut->sign = DECIMAL_POS;
+      pDecOut->Lo64 = cyIn.int64;
   }
   return S_OK;
 }
@@ -4270,7 +4264,7 @@ HRESULT WINAPI VarDecFromCy(CY cyIn, DECIMAL* pDecOut)
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
-HRESULT WINAPI VarDecFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DECIMAL* pDecOut)
+HRESULT WINAPI VarDecFromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, DECIMAL* pDecOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pDecOut, VT_DECIMAL);
 }
@@ -4311,17 +4305,17 @@ HRESULT WINAPI VarDecFromDisp(IDispatch* pdispIn, LCID lcid, DECIMAL* pDecOut)
  */
 HRESULT WINAPI VarDecFromBool(VARIANT_BOOL bIn, DECIMAL* pDecOut)
 {
-  DEC_HI32(pDecOut) = 0;
-  DEC_MID32(pDecOut) = 0;
+  pDecOut->Hi32 = 0;
+  pDecOut->scale = 0;
   if (bIn)
   {
-    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_NEG,0);
-    DEC_LO32(pDecOut) = 1;
+      pDecOut->sign = DECIMAL_NEG;
+      pDecOut->Lo64 = 1;
   }
   else
   {
-    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
-    DEC_LO32(pDecOut) = 0;
+      pDecOut->sign = DECIMAL_POS;
+      pDecOut->Lo64 = 0;
   }
   return S_OK;
 }
@@ -4374,11 +4368,11 @@ HRESULT WINAPI VarDecFromUI2(USHORT usIn, DECIMAL* pDecOut)
  */
 HRESULT WINAPI VarDecFromUI4(ULONG ulIn, DECIMAL* pDecOut)
 {
-  DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
-  DEC_HI32(pDecOut) = 0;
-  DEC_MID32(pDecOut) = 0;
-  DEC_LO32(pDecOut) = ulIn;
-  return S_OK;
+    pDecOut->sign = DECIMAL_POS;
+    pDecOut->scale = 0;
+    pDecOut->Hi32 = 0;
+    pDecOut->Lo64 = ulIn;
+    return S_OK;
 }
 
 /************************************************************************
@@ -4395,23 +4389,20 @@ HRESULT WINAPI VarDecFromUI4(ULONG ulIn, DECIMAL* pDecOut)
  */
 HRESULT WINAPI VarDecFromI8(LONG64 llIn, DECIMAL* pDecOut)
 {
-  PULARGE_INTEGER pLi = (PULARGE_INTEGER)&llIn;
+    pDecOut->Hi32 = 0;
+    pDecOut->scale = 0;
 
-  DEC_HI32(pDecOut) = 0;
-
-  /* Note: This assumes 2s complement integer representation */
-  if (pLi->u.HighPart & 0x80000000)
-  {
-    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_NEG,0);
-    DEC_LO64(pDecOut) = -pLi->QuadPart;
-  }
-  else
-  {
-    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
-    DEC_MID32(pDecOut) = pLi->u.HighPart;
-    DEC_LO32(pDecOut) = pLi->u.LowPart;
-  }
-  return S_OK;
+    if (llIn < 0)
+    {
+        pDecOut->sign = DECIMAL_NEG;
+        pDecOut->Lo64 = -llIn;
+    }
+    else
+    {
+        pDecOut->sign = DECIMAL_POS;
+        pDecOut->Lo64 = llIn;
+    }
+    return S_OK;
 }
 
 /************************************************************************
@@ -4428,10 +4419,11 @@ HRESULT WINAPI VarDecFromI8(LONG64 llIn, DECIMAL* pDecOut)
  */
 HRESULT WINAPI VarDecFromUI8(ULONG64 ullIn, DECIMAL* pDecOut)
 {
-  DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
-  DEC_HI32(pDecOut) = 0;
-  DEC_LO64(pDecOut) = ullIn;
-  return S_OK;
+    pDecOut->sign = DECIMAL_POS;
+    pDecOut->scale = 0;
+    pDecOut->Hi32 = 0;
+    pDecOut->Lo64 = ullIn;
+    return S_OK;
 }
 
 /* Make two DECIMALS the same scale; used by math functions below */
@@ -4445,12 +4437,12 @@ static HRESULT VARIANT_DecScale(const DECIMAL** ppDecLeft,
   VARIANT_DI di;
   int scaleAmount, i;
 
-  if (DEC_SIGN(*ppDecLeft) & ~DECIMAL_NEG || DEC_SIGN(*ppDecRight) & ~DECIMAL_NEG)
+  if ((*ppDecLeft)->sign & ~DECIMAL_NEG || (*ppDecRight)->sign & ~DECIMAL_NEG)
     return E_INVALIDARG;
 
-  DEC_LO32(&scaleFactor) = 10;
+  scaleFactor.Lo32 = 10;
 
-  i = scaleAmount = DEC_SCALE(*ppDecLeft) - DEC_SCALE(*ppDecRight);
+  i = scaleAmount = (*ppDecLeft)->scale - (*ppDecRight)->scale;
 
   if (!scaleAmount)
     return S_OK; /* Same scale */
@@ -4476,7 +4468,7 @@ static HRESULT VARIANT_DecScale(const DECIMAL** ppDecLeft,
 
   if (!i)
   {
-    DEC_SCALE(&pDecOut[0]) += (scaleAmount > 0) ? scaleAmount : (-scaleAmount);
+    pDecOut[0].scale += (scaleAmount > 0) ? scaleAmount : (-scaleAmount);
     return S_OK; /* Same scale */
   }
 
@@ -4484,13 +4476,13 @@ static HRESULT VARIANT_DecScale(const DECIMAL** ppDecLeft,
   pDecOut[0] = decTemp;
   if (scaleAmount > 0)
   {
-    DEC_SCALE(&pDecOut[0]) += scaleAmount - i;
+    pDecOut[0].scale += scaleAmount - i;
     VARIANT_DIFromDec(*ppDecLeft, &di);
     *ppDecLeft = &pDecOut[1];
   }
   else
   {
-    DEC_SCALE(&pDecOut[0]) += (-scaleAmount) - i;
+    pDecOut[0].scale += (-scaleAmount) - i;
     VARIANT_DIFromDec(*ppDecRight, &di);
     *ppDecRight = &pDecOut[1];
   }
@@ -4522,8 +4514,8 @@ static ULONG VARIANT_Add(ULONG ulLeft, ULONG ulRight, ULONG* pulHigh)
   ULARGE_INTEGER ul64;
 
   ul64.QuadPart = (ULONG64)ulLeft + (ULONG64)ulRight + (ULONG64)*pulHigh;
-  *pulHigh = ul64.u.HighPart;
-  return ul64.u.LowPart;
+  *pulHigh = ul64.HighPart;
+  return ul64.LowPart;
 }
 
 /* Subtract two unsigned 32 bit values with underflow */
@@ -4544,10 +4536,10 @@ static ULONG VARIANT_Sub(ULONG ulLeft, ULONG ulRight, ULONG* pulHigh)
     invert = TRUE;
   }
   if (invert)
-    ul64.u.HighPart = -ul64.u.HighPart ;
+    ul64.HighPart = -ul64.HighPart ;
 
-  *pulHigh = ul64.u.HighPart;
-  return ul64.u.LowPart;
+  *pulHigh = ul64.HighPart;
+  return ul64.LowPart;
 }
 
 /* Multiply two unsigned 32 bit values with overflow */
@@ -4556,17 +4548,17 @@ static ULONG VARIANT_Mul(ULONG ulLeft, ULONG ulRight, ULONG* pulHigh)
   ULARGE_INTEGER ul64;
 
   ul64.QuadPart = (ULONG64)ulLeft * (ULONG64)ulRight + (ULONG64)*pulHigh;
-  *pulHigh = ul64.u.HighPart;
-  return ul64.u.LowPart;
+  *pulHigh = ul64.HighPart;
+  return ul64.LowPart;
 }
 
 /* Compare two decimals that have the same scale */
 static inline int VARIANT_DecCmp(const DECIMAL *pDecLeft, const DECIMAL *pDecRight)
 {
-  if ( DEC_HI32(pDecLeft) < DEC_HI32(pDecRight) ||
-      (DEC_HI32(pDecLeft) <= DEC_HI32(pDecRight) && DEC_LO64(pDecLeft) < DEC_LO64(pDecRight)))
+  if ( pDecLeft->Hi32 < pDecRight->Hi32 ||
+      (pDecLeft->Hi32 <= pDecRight->Hi32 && pDecLeft->Lo64 < pDecRight->Lo64))
     return -1;
-  else if (DEC_HI32(pDecLeft) == DEC_HI32(pDecRight) && DEC_LO64(pDecLeft) == DEC_LO64(pDecRight))
+  else if (pDecLeft->Hi32 == pDecRight->Hi32 && pDecLeft->Lo64 == pDecRight->Lo64)
     return 0;
   return 1;
 }
@@ -4600,13 +4592,13 @@ HRESULT WINAPI VarDecAdd(const DECIMAL* pDecLeft, const DECIMAL* pDecRight, DECI
     int cmp;
 
     /* Correct for the sign of the result */
-    if (DEC_SIGN(pDecLeft) && DEC_SIGN(pDecRight))
+    if (pDecLeft->sign && pDecRight->sign)
     {
       /* -x + -y : Negative */
       sign = DECIMAL_NEG;
       goto VarDecAdd_AsPositive;
     }
-    else if (DEC_SIGN(pDecLeft) && !DEC_SIGN(pDecRight))
+    else if (pDecLeft->sign && !pDecRight->sign)
     {
       cmp = VARIANT_DecCmp(pDecLeft, pDecRight);
 
@@ -4615,19 +4607,19 @@ HRESULT WINAPI VarDecAdd(const DECIMAL* pDecLeft, const DECIMAL* pDecRight, DECI
       {
         sign = DECIMAL_NEG;
 VarDecAdd_AsNegative:
-        DEC_LO32(pDecOut)  = VARIANT_Sub(DEC_LO32(pDecLeft),  DEC_LO32(pDecRight),  &overflow);
-        DEC_MID32(pDecOut) = VARIANT_Sub(DEC_MID32(pDecLeft), DEC_MID32(pDecRight), &overflow);
-        DEC_HI32(pDecOut)  = VARIANT_Sub(DEC_HI32(pDecLeft),  DEC_HI32(pDecRight),  &overflow);
+        pDecOut->Lo32  = VARIANT_Sub(pDecLeft->Lo32,  pDecRight->Lo32,  &overflow);
+        pDecOut->Mid32 = VARIANT_Sub(pDecLeft->Mid32, pDecRight->Mid32, &overflow);
+        pDecOut->Hi32  = VARIANT_Sub(pDecLeft->Hi32,  pDecRight->Hi32,  &overflow);
       }
       else
       {
 VarDecAdd_AsInvertedNegative:
-        DEC_LO32(pDecOut)  = VARIANT_Sub(DEC_LO32(pDecRight),  DEC_LO32(pDecLeft),  &overflow);
-        DEC_MID32(pDecOut) = VARIANT_Sub(DEC_MID32(pDecRight), DEC_MID32(pDecLeft), &overflow);
-        DEC_HI32(pDecOut)  = VARIANT_Sub(DEC_HI32(pDecRight),  DEC_HI32(pDecLeft),  &overflow);
+        pDecOut->Lo32  = VARIANT_Sub(pDecRight->Lo32,  pDecLeft->Lo32,  &overflow);
+        pDecOut->Mid32 = VARIANT_Sub(pDecRight->Mid32, pDecLeft->Mid32, &overflow);
+        pDecOut->Hi32  = VARIANT_Sub(pDecRight->Hi32,  pDecLeft->Hi32,  &overflow);
       }
     }
-    else if (!DEC_SIGN(pDecLeft) && DEC_SIGN(pDecRight))
+    else if (!pDecLeft->sign && pDecRight->sign)
     {
       cmp = VARIANT_DecCmp(pDecLeft, pDecRight);
 
@@ -4643,16 +4635,53 @@ VarDecAdd_AsInvertedNegative:
     {
       /* x + y : Positive */
 VarDecAdd_AsPositive:
-      DEC_LO32(pDecOut)  = VARIANT_Add(DEC_LO32(pDecLeft),  DEC_LO32(pDecRight),  &overflow);
-      DEC_MID32(pDecOut) = VARIANT_Add(DEC_MID32(pDecLeft), DEC_MID32(pDecRight), &overflow);
-      DEC_HI32(pDecOut)  = VARIANT_Add(DEC_HI32(pDecLeft),  DEC_HI32(pDecRight),  &overflow);
+      pDecOut->Lo32  = VARIANT_Add(pDecLeft->Lo32,  pDecRight->Lo32,  &overflow);
+      pDecOut->Mid32 = VARIANT_Add(pDecLeft->Mid32, pDecRight->Mid32, &overflow);
+      pDecOut->Hi32  = VARIANT_Add(pDecLeft->Hi32,  pDecRight->Hi32,  &overflow);
+
+      if (overflow)
+      {
+        int i;
+        DWORD n[4];
+        unsigned char remainder;
+
+        if (!pDecLeft->scale)
+          return DISP_E_OVERFLOW;
+
+        pDecOut->scale = pDecLeft->scale - 1;
+        pDecOut->sign = sign;
+
+        n[0] = pDecOut->Lo32;
+        n[1] = pDecOut->Mid32;
+        n[2] = pDecOut->Hi32;
+        n[3] = overflow;
+
+        remainder = VARIANT_int_divbychar(n,4,10);
+
+        /* round up the result */
+        if (remainder >= 5)
+        {
+          for (remainder = 1, i = 0; i < ARRAY_SIZE(n) && remainder; i++)
+          {
+            ULONGLONG digit = n[i] + 1;
+            remainder = (digit > 0xFFFFFFFF) ? 1 : 0;
+            n[i] = digit & 0xFFFFFFFF;
+          }
+        }
+
+        pDecOut->Lo32 = n[0] ;
+        pDecOut->Mid32 = n[1];
+        pDecOut->Hi32 = n[2];
+
+        return S_OK;
+      }
     }
 
     if (overflow)
       return DISP_E_OVERFLOW; /* overflowed */
 
-    DEC_SCALE(pDecOut) = DEC_SCALE(pDecLeft);
-    DEC_SIGN(pDecOut) = sign;
+    pDecOut->scale = pDecLeft->scale;
+    pDecOut->sign = sign;
   }
   return hRet;
 }
@@ -4660,25 +4689,21 @@ VarDecAdd_AsPositive:
 /* translate from external DECIMAL format into an internal representation */
 static void VARIANT_DIFromDec(const DECIMAL * from, VARIANT_DI * to)
 {
-    to->scale = DEC_SCALE(from);
-    to->sign = DEC_SIGN(from) ? 1 : 0;
+    to->scale = from->scale;
+    to->sign = from->sign ? 1 : 0;
 
-    to->bitsnum[0] = DEC_LO32(from);
-    to->bitsnum[1] = DEC_MID32(from);
-    to->bitsnum[2] = DEC_HI32(from);
+    to->bitsnum[0] = from->Lo32;
+    to->bitsnum[1] = from->Mid32;
+    to->bitsnum[2] = from->Hi32;
 }
 
 static void VARIANT_DecFromDI(const VARIANT_DI * from, DECIMAL * to)
 {
-    if (from->sign) {
-        DEC_SIGNSCALE(to) = SIGNSCALE(DECIMAL_NEG, from->scale);
-    } else {
-        DEC_SIGNSCALE(to) = SIGNSCALE(DECIMAL_POS, from->scale);
-    }
-
-    DEC_LO32(to) = from->bitsnum[0];
-    DEC_MID32(to) = from->bitsnum[1];
-    DEC_HI32(to) = from->bitsnum[2];
+    to->sign = from->sign ? DECIMAL_NEG : DECIMAL_POS;
+    to->scale = from->scale;
+    to->Lo32 = from->bitsnum[0];
+    to->Mid32 = from->bitsnum[1];
+    to->Hi32 = from->bitsnum[2];
 }
 
 /* clear an internal representation of a DECIMAL */
@@ -5698,7 +5723,7 @@ HRESULT WINAPI VarDecSub(const DECIMAL* pDecLeft, const DECIMAL* pDecRight, DECI
 HRESULT WINAPI VarDecAbs(const DECIMAL* pDecIn, DECIMAL* pDecOut)
 {
   *pDecOut = *pDecIn;
-  DEC_SIGN(pDecOut) &= ~DECIMAL_NEG;
+  pDecOut->sign &= ~DECIMAL_NEG;
   return S_OK;
 }
 
@@ -5724,10 +5749,10 @@ HRESULT WINAPI VarDecFix(const DECIMAL* pDecIn, DECIMAL* pDecOut)
   double dbl;
   HRESULT hr;
 
-  if (DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
+  if (pDecIn->sign & ~DECIMAL_NEG)
     return E_INVALIDARG;
 
-  if (!DEC_SCALE(pDecIn))
+  if (!pDecIn->scale)
   {
     *pDecOut = *pDecIn; /* Already an integer */
     return S_OK;
@@ -5764,10 +5789,10 @@ HRESULT WINAPI VarDecInt(const DECIMAL* pDecIn, DECIMAL* pDecOut)
   double dbl;
   HRESULT hr;
 
-  if (DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
+  if (pDecIn->sign & ~DECIMAL_NEG)
     return E_INVALIDARG;
 
-  if (!(DEC_SIGN(pDecIn) & DECIMAL_NEG) || !DEC_SCALE(pDecIn))
+  if (!(pDecIn->sign & DECIMAL_NEG) || !pDecIn->scale)
     return VarDecFix(pDecIn, pDecOut); /* The same, if +ve or no fractionals */
 
   hr = VarR8FromDec(pDecIn, &dbl);
@@ -5794,7 +5819,7 @@ HRESULT WINAPI VarDecInt(const DECIMAL* pDecIn, DECIMAL* pDecOut)
 HRESULT WINAPI VarDecNeg(const DECIMAL* pDecIn, DECIMAL* pDecOut)
 {
   *pDecOut = *pDecIn;
-  DEC_SIGN(pDecOut) ^= DECIMAL_NEG;
+  pDecOut->sign ^= DECIMAL_NEG;
   return S_OK;
 }
 
@@ -5818,10 +5843,10 @@ HRESULT WINAPI VarDecRound(const DECIMAL* pDecIn, int cDecimals, DECIMAL* pDecOu
   HRESULT hr;
   unsigned int i;
 
-  if (cDecimals < 0 || (DEC_SIGN(pDecIn) & ~DECIMAL_NEG) || DEC_SCALE(pDecIn) > DEC_MAX_SCALE)
+  if (cDecimals < 0 || (pDecIn->sign & ~DECIMAL_NEG) || pDecIn->scale > DEC_MAX_SCALE)
     return E_INVALIDARG;
 
-  if (cDecimals >= DEC_SCALE(pDecIn))
+  if (cDecimals >= pDecIn->scale)
   {
     *pDecOut = *pDecIn; /* More precision than we have */
     return S_OK;
@@ -5829,11 +5854,11 @@ HRESULT WINAPI VarDecRound(const DECIMAL* pDecIn, int cDecimals, DECIMAL* pDecOu
 
   /* truncate significant digits and rescale */
   memset(&divisor, 0, sizeof(divisor));
-  DEC_LO64(&divisor) = 1;
+  divisor.Lo64 = 1;
 
   memset(&tmp, 0, sizeof(tmp));
-  DEC_LO64(&tmp) = 10;
-  for (i = 0; i < DEC_SCALE(pDecIn) - cDecimals; ++i)
+  tmp.Lo64 = 10;
+  for (i = 0; i < pDecIn->scale - cDecimals; ++i)
   {
     hr = VarDecMul(&divisor, &tmp, &divisor);
     if (FAILED(hr))
@@ -5844,7 +5869,7 @@ HRESULT WINAPI VarDecRound(const DECIMAL* pDecIn, int cDecimals, DECIMAL* pDecOu
   if (FAILED(hr))
     return hr;
 
-  DEC_SCALE(pDecOut) = cDecimals;
+  pDecOut->scale = cDecimals;
 
   return S_OK;
 }
@@ -5871,11 +5896,11 @@ HRESULT WINAPI VarDecCmp(const DECIMAL* pDecLeft, const DECIMAL* pDecRight)
   if (!pDecLeft || !pDecRight)
     return VARCMP_NULL;
 
-  if ((!(DEC_SIGN(pDecLeft) & DECIMAL_NEG)) && (DEC_SIGN(pDecRight) & DECIMAL_NEG) &&
-      (DEC_HI32(pDecLeft) | DEC_MID32(pDecLeft) | DEC_LO32(pDecLeft)))
+  if ((!(pDecLeft->sign & DECIMAL_NEG)) && (pDecRight->sign & DECIMAL_NEG) &&
+      (pDecLeft->Hi32 || pDecLeft->Lo64))
     return VARCMP_GT;
-  else if ((DEC_SIGN(pDecLeft) & DECIMAL_NEG) && (!(DEC_SIGN(pDecRight) & DECIMAL_NEG)) &&
-      (DEC_HI32(pDecLeft) | DEC_MID32(pDecLeft) | DEC_LO32(pDecLeft)))
+  else if ((pDecLeft->sign & DECIMAL_NEG) && (!(pDecRight->sign & DECIMAL_NEG)) &&
+      (pDecLeft->Hi32 || pDecLeft->Lo64))
     return VARCMP_LT;
 
   /* Subtract right from left, and compare the result to 0 */
@@ -5883,9 +5908,9 @@ HRESULT WINAPI VarDecCmp(const DECIMAL* pDecLeft, const DECIMAL* pDecRight)
 
   if (SUCCEEDED(hRet))
   {
-    int non_zero = DEC_HI32(&result) | DEC_MID32(&result) | DEC_LO32(&result);
+    int non_zero = result.Hi32 || result.Lo64;
 
-    if ((DEC_SIGN(&result) & DECIMAL_NEG) && non_zero)
+    if ((result.sign & DECIMAL_NEG) && non_zero)
       hRet = (HRESULT)VARCMP_LT;
     else if (non_zero)
       hRet = (HRESULT)VARCMP_GT;
@@ -6111,11 +6136,8 @@ static BOOL VARIANT_GetLocalisedText(LANGID langId, DWORD dwId, WCHAR *lpszDest)
  *  - If the text is not numeric and does not match any of the above, then
  *  DISP_E_TYPEMISMATCH is returned.
  */
-HRESULT WINAPI VarBoolFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL *pBoolOut)
+HRESULT WINAPI VarBoolFromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL *pBoolOut)
 {
-  /* Any VB/VBA programmers out there should recognise these strings... */
-  static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
-  static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
   WCHAR szBuff[64];
   LANGID langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
   HRESULT hRes = S_OK;
@@ -6172,9 +6194,9 @@ VarBoolFromStr_CheckLocalised:
   }
 
   /* All checks against localised text have failed, try #TRUE#/#FALSE# */
-  if (!wcscmp(strIn, szFalse))
+  if (!wcscmp(strIn, L"#FALSE#"))
     *pBoolOut = VARIANT_FALSE;
-  else if (!wcscmp(strIn, szTrue))
+  else if (!wcscmp(strIn, L"#TRUE#"))
     *pBoolOut = VARIANT_TRUE;
   else
   {
@@ -6275,12 +6297,12 @@ HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL *pBoolOut)
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if pDecIn is invalid.
  */
-HRESULT WINAPI VarBoolFromDec(DECIMAL* pDecIn, VARIANT_BOOL *pBoolOut)
+HRESULT WINAPI VarBoolFromDec(const DECIMAL* pDecIn, VARIANT_BOOL *pBoolOut)
 {
-  if (DEC_SCALE(pDecIn) > DEC_MAX_SCALE || (DEC_SIGN(pDecIn) & ~DECIMAL_NEG))
+  if (pDecIn->scale > DEC_MAX_SCALE || (pDecIn->sign & ~DECIMAL_NEG))
     return E_INVALIDARG;
 
-  if (DEC_HI32(pDecIn) || DEC_MID32(pDecIn) || DEC_LO32(pDecIn))
+  if (pDecIn->Hi32 || pDecIn->Lo64)
     *pBoolOut = VARIANT_TRUE;
   else
     *pBoolOut = VARIANT_FALSE;
@@ -6475,22 +6497,26 @@ static BSTR VARIANT_BstrReplaceDecimal(const WCHAR * buff, LCID lcid, ULONG dwFl
   }
   else
   {
-    WCHAR *p;
+    WCHAR *p, *e;
     WCHAR numbuff[256];
-    WCHAR empty[] = {'\0'};
+    WCHAR empty[] = L"";
     NUMBERFMTW minFormat;
 
     minFormat.NumDigits = 0;
-    minFormat.LeadingZero = 0;
     minFormat.Grouping = 0;
     minFormat.lpDecimalSep = lpDecimalSep;
     minFormat.lpThousandSep = empty;
     minFormat.NegativeOrder = 1; /* NLS_NEG_LEFT */
 
-    /* count number of decimal digits in string */
-    p = wcschr( buff, '.' );
-    if (p) minFormat.NumDigits = lstrlenW(p + 1);
+    GetLocaleInfoW(lcid, LOCALE_ILZERO | LOCALE_RETURN_NUMBER | (dwFlags & LOCALE_NOUSEROVERRIDE),
+                   (WCHAR *)&minFormat.LeadingZero, sizeof(DWORD)/sizeof(WCHAR) );
 
+    /* count number of decimal digits in string */
+    p = wcschr(buff, '.');
+    e = wcschr(p ? ++p : buff, 'E');
+    if (p) minFormat.NumDigits = e ? e - p : lstrlenW(p);
+
+    if (e) *e = '\0';
     numbuff[0] = '\0';
     if (!GetNumberFormatW(lcid, 0, buff, &minFormat, numbuff, ARRAY_SIZE(numbuff)))
     {
@@ -6499,6 +6525,11 @@ static BSTR VARIANT_BstrReplaceDecimal(const WCHAR * buff, LCID lcid, ULONG dwFl
     }
     else
     {
+      if (e)
+      {
+        *e = 'E';
+        wcscat(numbuff, e);
+      }
       TRACE("created minimal NLS string %s\n", debugstr_w(numbuff));
       bstrOut = SysAllocString(numbuff);
     }
@@ -6507,14 +6538,45 @@ static BSTR VARIANT_BstrReplaceDecimal(const WCHAR * buff, LCID lcid, ULONG dwFl
 }
 
 static HRESULT VARIANT_BstrFromReal(DOUBLE dblIn, LCID lcid, ULONG dwFlags,
-                                    BSTR* pbstrOut, LPCWSTR lpszFormat)
+                                    BSTR* pbstrOut, int ndigits)
 {
-  WCHAR buff[256];
+#ifndef __REACTOS__
+  _locale_t locale;
+#endif
+  WCHAR *e, buff[256];
+  int len;
 
   if (!pbstrOut)
     return E_INVALIDARG;
 
-  swprintf( buff, lpszFormat, dblIn );
+#ifdef __REACTOS__ /* FIXME: Inspect */
+    len = swprintf(buff, ARRAY_SIZE(buff), L"%.*G", ndigits, dblIn);
+#else
+  if (!(locale = _create_locale(LC_ALL, "C"))) return E_OUTOFMEMORY;
+  len = _swprintf_l(buff, ARRAY_SIZE(buff), L"%.*G", locale, ndigits, dblIn);
+#endif
+  e = wcschr(buff, 'E');
+  if (e)
+  {
+      int extra_decimals;
+      WCHAR *dot;
+
+      dot = wcschr(buff, '.');
+      extra_decimals = dot ? e - dot - 2 : 0;
+      if (labs(wcstol(e+1, NULL, 10)) + extra_decimals < ndigits)
+      {
+#ifdef __REACTOS__ /* FIXME: Inspect */
+          len = swprintf(buff, ARRAY_SIZE(buff), L"%.*f", ndigits, dblIn);
+#else
+          len = _swprintf_l(buff, ARRAY_SIZE(buff), L"%.*f", locale, ndigits, dblIn);
+#endif
+          while (len > 0 && (buff[len-1] == '0')) len--;
+      }
+  }
+  buff[len] = 0;
+#ifndef __REACTOS__
+  _free_locale(locale);
+#endif
 
   /* Negative zeroes are disallowed (some applications depend on this).
      If buff starts with a minus, and then nothing follows but zeroes
@@ -6523,8 +6585,7 @@ static HRESULT VARIANT_BstrFromReal(DOUBLE dblIn, LCID lcid, ULONG dwFlags,
    */
   if (buff[0] == '-')
   {
-    static const WCHAR szAccept[] = {'0', '.', '\0'};
-    if (lstrlenW(buff + 1) == wcsspn(buff + 1, szAccept))
+    if (lstrlenW(buff + 1) == wcsspn(buff + 1, L"0."))
     { buff[0] = '0'; buff[1] = '\0'; }
   }
 
@@ -6565,7 +6626,7 @@ static HRESULT VARIANT_BstrFromReal(DOUBLE dblIn, LCID lcid, ULONG dwFlags,
  */
 HRESULT WINAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
 {
-  return VARIANT_BstrFromReal(fltIn, lcid, dwFlags, pbstrOut, szFloatFormatW);
+    return VARIANT_BstrFromReal(fltIn, lcid, dwFlags, pbstrOut, 7);
 }
 
 /******************************************************************************
@@ -6586,7 +6647,7 @@ HRESULT WINAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR* pbstrO
  */
 HRESULT WINAPI VarBstrFromR8(double dblIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
 {
-  return VARIANT_BstrFromReal(dblIn, lcid, dwFlags, pbstrOut, szDoubleFormatW);
+    return VARIANT_BstrFromReal(dblIn, lcid, dwFlags, pbstrOut, 15);
 }
 
 /******************************************************************************
@@ -6615,9 +6676,9 @@ HRESULT WINAPI VarBstrFromCy(CY cyIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
 
   decVal.scale = 4;
   decVal.sign = 0;
-  decVal.bitsnum[0] = cyIn.s.Lo;
-  decVal.bitsnum[1] = cyIn.s.Hi;
-  if (cyIn.s.Hi & 0x80000000UL) {
+  decVal.bitsnum[0] = cyIn.Lo;
+  decVal.bitsnum[1] = cyIn.Hi;
+  if (cyIn.Hi & 0x80000000UL) {
     DWORD one = 1;
 
     /* Negative number! */
@@ -6690,7 +6751,7 @@ BOOL get_date_format(LCID lcid, DWORD flags, const SYSTEMTIME *st,
     };
 
     if(flags & ~(LOCALE_NOUSEROVERRIDE|VAR_DATEVALUEONLY))
-        FIXME("ignoring flags %x\n", flags);
+        FIXME("ignoring flags %lx\n", flags);
     flags &= LOCALE_NOUSEROVERRIDE;
 
     while(*fmt && date_len) {
@@ -6781,7 +6842,7 @@ HRESULT WINAPI VarBstrFromDate(DATE dateIn, LCID lcid, ULONG dwFlags, BSTR* pbst
   DWORD dwFormatFlags = dwFlags & LOCALE_NOUSEROVERRIDE;
   WCHAR date[128], fmt_buff[80], *time;
 
-  TRACE("(%g,0x%08x,0x%08x,%p)\n", dateIn, lcid, dwFlags, pbstrOut);
+  TRACE("%g, %#lx, %#lx, %p.\n", dateIn, lcid, dwFlags, pbstrOut);
 
   if (!pbstrOut || !VariantTimeToSystemTime(dateIn, &st))
     return E_INVALIDARG;
@@ -6855,7 +6916,7 @@ HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BS
   DWORD dwResId = IDS_TRUE;
   LANGID langId;
 
-  TRACE("%d,0x%08x,0x%08x,%p\n", boolIn, lcid, dwFlags, pbstrOut);
+  TRACE("%d, %#lx, %#lx, %p.\n", boolIn, lcid, dwFlags, pbstrOut);
 
   if (!pbstrOut)
     return E_INVALIDARG;
@@ -6988,7 +7049,7 @@ HRESULT WINAPI VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR* pbstrO
  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
  *           E_OUTOFMEMORY, if memory allocation fails.
  */
-HRESULT WINAPI VarBstrFromDec(DECIMAL* pDecIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
+HRESULT WINAPI VarBstrFromDec(const DECIMAL* pDecIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
 {
   WCHAR buff[256];
   VARIANT_DI temp;
@@ -7160,7 +7221,7 @@ HRESULT WINAPI VarBstrCmp(BSTR pbstrLeft, BSTR pbstrRight, LCID lcid, DWORD dwFl
     HRESULT hres;
     int ret;
 
-    TRACE("%s,%s,%d,%08x\n",
+    TRACE("%s, %s, %#lx, %#lx.\n",
      debugstr_wn(pbstrLeft, SysStringLen(pbstrLeft)),
      debugstr_wn(pbstrRight, SysStringLen(pbstrRight)), lcid, dwFlags);
 
@@ -7200,7 +7261,7 @@ HRESULT WINAPI VarBstrCmp(BSTR pbstrLeft, BSTR pbstrRight, LCID lcid, DWORD dwFl
 
       hres = CompareStringW(lcid, dwFlags, pbstrLeft, lenLeft,
               pbstrRight, lenRight) - CSTR_LESS_THAN;
-      TRACE("%d\n", hres);
+      TRACE("%ld\n", hres);
       return hres;
     }
 }
@@ -7415,7 +7476,7 @@ static inline HRESULT VARIANT_MakeDate(DATEPARSE *dp, DWORD iDate,
   else
     v3 = dp->dwValues[offset + 2];
 
-  TRACE("(%d,%d,%d,%d,%d)\n", v1, v2, v3, iDate, offset);
+  TRACE("%ld, %ld, %ld, %ld, %ld.\n", v1, v2, v3, iDate, offset);
 
   /* If one number must be a month (Because a month name was given), then only
    * consider orders with the month in that position.
@@ -7443,7 +7504,7 @@ static inline HRESULT VARIANT_MakeDate(DATEPARSE *dp, DWORD iDate,
   }
 
 VARIANT_MakeDate_Start:
-  TRACE("dwAllOrders is 0x%08x\n", dwAllOrders);
+  TRACE("dwAllOrders is %#lx\n", dwAllOrders);
 
   while (dwAllOrders)
   {
@@ -7475,7 +7536,7 @@ VARIANT_MakeDate_Start:
       dwTry = dwAllOrders;
     }
 
-    TRACE("Attempt %d, dwTry is 0x%08x\n", dwCount, dwTry);
+    TRACE("Attempt %ld, dwTry is %#lx\n", dwCount, dwTry);
 
     dwCount++;
     if (!dwTry)
@@ -7558,13 +7619,20 @@ VARIANT_MakeDate_OK:
 
   st->wDay = v1;
   st->wMonth = v2;
-  /* FIXME: For 2 digit dates, I'm not sure if 30 is hard coded or not. It may
-   * be retrieved from:
-   * HKCU\Control Panel\International\Calendars\TwoDigitYearMax
-   * But Wine doesn't have/use that key as at the time of writing.
+  /* FIXME: For 2 digit dates old versions of Windows used 29 but
+   * Windows 10 1903 and greater use 49. This cutoff may also be modified by
+   * setting the value as a string for the relevant calendar id in the
+   * registry.
+   *
+   * For instance to emulate old Windows versions:
+   * [HKCU\Control Panel\International\Calendars\TwoDigitYearMax]
+   * "1"="29"
+   * (also 2, 9, 10, 11 and 12 for the other Gregorian calendars)
+   *
+   * But Wine doesn't have/use that key at the time of writing.
    */
-  st->wYear = v3 < 30 ? 2000 + v3 : v3 < 100 ? 1900 + v3 : v3;
-  TRACE("Returning date %d/%d/%d\n", v1, v2, st->wYear);
+  st->wYear = v3 <= 49 ? 2000 + v3 : v3 <= 99 ? 1900 + v3 : v3;
+  TRACE("Returning date %ld/%ld/%d\n", v1, v2, st->wYear);
   return S_OK;
 }
 
@@ -7592,7 +7660,7 @@ VARIANT_MakeDate_OK:
  *  the date is invalid in that format, in which the most compatible format
  *  that produces a valid date will be used.
  */
-HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pdateOut)
+HRESULT WINAPI VarDateFromStr(const OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pdateOut)
 {
   static const USHORT ParseDateTokens[] =
   {
@@ -7633,13 +7701,13 @@ HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pd
 
   *pdateOut = 0.0;
 
-  TRACE("(%s,0x%08x,0x%08x,%p)\n", debugstr_w(strIn), lcid, dwFlags, pdateOut);
+  TRACE("%s, %#lx, %#lx, %p.\n", debugstr_w(strIn), lcid, dwFlags, pdateOut);
 
   memset(&dp, 0, sizeof(dp));
 
   GetLocaleInfoW(lcid, LOCALE_IDATE|LOCALE_RETURN_NUMBER|(dwFlags & LOCALE_NOUSEROVERRIDE),
                  (LPWSTR)&iDate, sizeof(iDate)/sizeof(WCHAR));
-  TRACE("iDate is %d\n", iDate);
+  TRACE("iDate is %ld\n", iDate);
 
   /* Get the month/day/am/pm tokens for this locale */
   for (i = 0; i < ARRAY_SIZE(tokens); i++)
@@ -7659,16 +7727,17 @@ HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pd
   /* Parse the string into our structure */
   while (*strIn)
   {
-    if (iswdigit(*strIn))
+    if ('0' <= *strIn && *strIn <= '9')
     {
+      OLECHAR* end;
       if (dp.dwCount >= 6)
       {
         hRet = DISP_E_TYPEMISMATCH;
         break;
       }
-      dp.dwValues[dp.dwCount] = wcstoul(strIn, &strIn, 10);
+      dp.dwValues[dp.dwCount] = wcstoul(strIn, &end, 10);
       dp.dwCount++;
-      strIn--;
+      strIn = end - 1;
     }
     else if (iswalpha(*strIn))
     {
@@ -7677,7 +7746,7 @@ HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pd
       for (i = 0; i < ARRAY_SIZE(tokens); i++)
       {
         DWORD dwLen = lstrlenW(tokens[i]);
-        if (dwLen && !_wcsnicmp(strIn, tokens[i], dwLen))
+        if (dwLen && !wcsnicmp(strIn, tokens[i], dwLen))
         {
           if (i <= 25)
           {
@@ -7790,7 +7859,7 @@ HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pd
      * magic here occurs in VARIANT_MakeDate() above, where we determine what
      * each date number must represent in the context of iDate.
      */
-    TRACE("0x%08x\n", TIMEFLAG(0)|TIMEFLAG(1)|TIMEFLAG(2)|TIMEFLAG(3)|TIMEFLAG(4));
+    TRACE("%#lx\n", TIMEFLAG(0)|TIMEFLAG(1)|TIMEFLAG(2)|TIMEFLAG(3)|TIMEFLAG(4));
 
     switch (TIMEFLAG(0)|TIMEFLAG(1)|TIMEFLAG(2)|TIMEFLAG(3)|TIMEFLAG(4))
     {
@@ -8002,7 +8071,7 @@ HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut)
  * RETURNS
  *  S_OK.
  */
-HRESULT WINAPI VarDateFromDec(DECIMAL *pdecIn, DATE* pdateOut)
+HRESULT WINAPI VarDateFromDec(const DECIMAL *pdecIn, DATE* pdateOut)
 {
   return VarR8FromDec(pdecIn, pdateOut);
 }
diff --git a/media/doc/WINESYNC.txt b/media/doc/WINESYNC.txt
index 84bf01deedf..b12447cb086 100644
--- a/media/doc/WINESYNC.txt
+++ b/media/doc/WINESYNC.txt
@@ -155,7 +155,7 @@ dll/win32/odbc32              # Synced to WineStaging-4.18. Depends on port of L
 dll/win32/odbccp32            # Synced to WineStaging-4.18
 dll/win32/ole32               # Synced to Wine-10.0
 dll/win32/oleacc              # Synced to Wine-10.0
-dll/win32/oleaut32            # Synced to WineStaging-4.18
+dll/win32/oleaut32            # Synced to Wine-10.0
 dll/win32/olecli32            # Synced to WineStaging-4.18
 dll/win32/oledlg              # Synced to WineStaging-4.18
 dll/win32/olepro32            # Synced to WineStaging-3.3