Sync to Wine-20050830:
authorGé van Geldorp <ge@gse.nl>
Mon, 5 Sep 2005 22:00:07 +0000 (22:00 +0000)
committerGé van Geldorp <ge@gse.nl>
Mon, 5 Sep 2005 22:00:07 +0000 (22:00 +0000)
Francois Gouget <fgouget@free.fr>
- Change some Dll* functions so they are exported by name like on
  Windows.
  Update the documentation accordingly.
Robert Shearman <rob@codeweavers.com>
- Remove redundant QueryInterface in marshal_interface - the object is
  always queried later on for the correct interface of the object.
- Make sure to Release the marshaled pointer in the typelib marshaler
  once it is no longer required.
- Shunt some trace statements over to the typelib channel that aren't
  really much use except in debugging typelib parsing.
- Make sure to release a reference to being returned as VariantCopyInd
  takes one for us.
- Revert to previous behaviour of detecting names with non-alphanumeric
  characters as ones with offsets, but add in a special case for an
  empty name.
- A name in an SLTG typelib only beginning with 0xff is the indicator
  of an offset, instead of any non alpha-numeric character.
- Any dispatch interface should have the fixed vtable size, not just
  dual ones.
- Warn when ITypeInfo_GetDocumentation fails.
- Make typelib marshaler use IRpcChannelBuffer::GetBuffer if possible.
Alexandre Julliard <julliard@winehq.org>
- Replace the ICOM_THIS_From macros by inline functions.
- Moved a number of definitions that are not needed in other files into
  vartype.c
- Removed some unnecessary macros, and make some functions static.
- Get rid of the almost empty tmarshal.h file.
Vincent Beron <vberon@mecano.gme.usherb.ca>
- Uniformize DllMain TRACEing across dlls.
Mike McCormack <mike@codeweavers.com>
- Fix gcc 4.0 warnings.
- gcc 4.0 warning fixes.
Michael Stefaniuc <mstefani@redhat.de>
- Implement IPicture::get_hPal for PICTYPE_BITMAP.
- VarAdd, VarMul: I4 overflows to R8 and not I8 even if the result
  would fit in I8. Fix tests.
- Document a brokeness in the handling of I8 numbers in
  VarNumFromParseNum. Fix tests.
Walt Ogburn <reuben@ugcs.caltech.edu>
- When applying logical / himetric ratio to olefont sizes, must divide
  by the standard ratio 72 / 2540.

svn path=/trunk/; revision=17679

16 files changed:
reactos/lib/oleaut32/ole2disp.spec
reactos/lib/oleaut32/oleaut.c
reactos/lib/oleaut32/oleaut32.spec
reactos/lib/oleaut32/olefont.c
reactos/lib/oleaut32/olepicture.c
reactos/lib/oleaut32/regsvr.c
reactos/lib/oleaut32/safearray.c
reactos/lib/oleaut32/tmarshal.c
reactos/lib/oleaut32/typelib.c
reactos/lib/oleaut32/typelib.h
reactos/lib/oleaut32/typelib.spec
reactos/lib/oleaut32/typelib2.c
reactos/lib/oleaut32/varformat.c
reactos/lib/oleaut32/variant.c
reactos/lib/oleaut32/variant.h
reactos/lib/oleaut32/vartype.c

index 7455880..2f9e2ef 100644 (file)
-1 stub DLLGETCLASSOBJECT\r
-2 pascal SysAllocString(str)           SysAllocString16\r
-3 pascal SysReallocString(ptr str)     SysReAllocString16\r
-4 pascal SysAllocStringLen(str word)   SysAllocStringLen16\r
-5 pascal SysReAllocStringLen(ptr str word) SysReAllocStringLen16\r
-6 pascal SysFreeString(segstr)         SysFreeString16\r
-7 pascal SysStringLen(segstr)          SysStringLen16\r
-8 stub VARIANTINIT\r
-9 stub VARIANTCLEAR\r
-10 stub VARIANTCOPY\r
-11 stub VARIANTCOPYIND\r
-12 stub VARIANTCHANGETYPE\r
-13 stub VARIANTTIMETODOSDATETIME\r
-14 stub DOSDATETIMETOVARIANTTIME\r
-15 stub SAFEARRAYCREATE\r
-16 stub SAFEARRAYDESTROY\r
-17 stub SAFEARRAYGETDIM\r
-18 stub SAFEARRAYGETELEMSIZE\r
-19 stub SAFEARRAYGETUBOUND\r
-20 stub SAFEARRAYGETLBOUND\r
-21 stub SAFEARRAYLOCK\r
-22 stub SAFEARRAYUNLOCK\r
-23 stub SAFEARRAYACCESSDATA\r
-24 stub SAFEARRAYUNACCESSDATA\r
-25 stub SAFEARRAYGETELEMENT\r
-26 stub SAFEARRAYPUTELEMENT\r
-27 stub SAFEARRAYCOPY\r
-28 stub DISPGETPARAM\r
-29 stub DISPGETIDSOFNAMES\r
-30 stub DISPINVOKE\r
-31 pascal CreateDispTypeInfo(ptr long ptr) CreateDispTypeInfo16\r
-32 pascal CreateStdDispatch(ptr ptr ptr ptr) CreateStdDispatch16\r
-33 stub _IID_IDISPATCH\r
-34 stub _IID_IENUMVARIANT\r
-35 pascal RegisterActiveObject(ptr ptr long ptr) RegisterActiveObject16\r
-36 stub REVOKEACTIVEOBJECT\r
-37 stub GETACTIVEOBJECT\r
-38 stub SAFEARRAYALLOCDESCRIPTOR\r
-39 stub SAFEARRAYALLOCDATA\r
-40 stub SAFEARRAYDESTROYDESCRIPTOR\r
-41 stub SAFEARRAYDESTROYDATA\r
-42 stub SAFEARRAYREDIM\r
-43 stub VARI2FROMI4\r
-44 stub VARI2FROMR4\r
-45 stub VARI2FROMR8\r
-46 stub VARI2FROMCY\r
-47 stub VARI2FROMDATE\r
-48 stub VARI2FROMSTR\r
-49 stub VARI2FROMDISP\r
-50 stub VARI2FROMBOOL\r
-51 stub VARI4FROMI2\r
-52 stub VARI4FROMR4\r
-53 stub VARI4FROMR8\r
-54 stub VARI4FROMCY\r
-55 stub VARI4FROMDATE\r
-56 stub VARI4FROMSTR\r
-57 stub VARI4FROMDISP\r
-58 stub VARI4FROMBOOL\r
-59 stub VARR4FROMI2\r
-60 stub VARR4FROMI4\r
-61 stub VARR4FROMR8\r
-62 stub VARR4FROMCY\r
-63 stub VARR4FROMDATE\r
-64 stub VARR4FROMSTR\r
-65 stub VARR4FROMDISP\r
-66 stub VARR4FROMBOOL\r
-67 stub VARR8FROMI2\r
-68 stub VARR8FROMI4\r
-69 stub VARR8FROMR4\r
-70 stub VARR8FROMCY\r
-71 stub VARR8FROMDATE\r
-72 stub VARR8FROMSTR\r
-73 stub VARR8FROMDISP\r
-74 stub VARR8FROMBOOL\r
-75 stub VARDATEFROMI2\r
-76 stub VARDATEFROMI4\r
-77 stub VARDATEFROMR4\r
-78 stub VARDATEFROMR8\r
-79 stub VARDATEFROMCY\r
-80 stub VARDATEFROMSTR\r
-81 stub VARDATEFROMDISP\r
-82 stub VARDATEFROMBOOL\r
-83 stub VARCYFROMI2\r
-84 stub VARCYFROMI4\r
-85 stub VARCYFROMR4\r
-86 stub VARCYFROMR8\r
-87 stub VARCYFROMDATE\r
-88 stub VARCYFROMSTR\r
-89 stub VARCYFROMDISP\r
-90 stub VARCYFROMBOOL\r
-91 stub VARBSTRFROMI2\r
-92 stub VARBSTRFROMI4\r
-93 stub VARBSTRFROMR4\r
-94 stub VARBSTRFROMR8\r
-95 stub VARBSTRFROMCY\r
-96 stub VARBSTRFROMDATE\r
-97 stub VARBSTRFROMDISP\r
-98 stub VARBSTRFROMBOOL\r
-99 stub VARBOOLFROMI2\r
-100 stub VARBOOLFROMI4\r
-101 stub VARBOOLFROMR4\r
-102 stub VARBOOLFROMR8\r
-103 stub VARBOOLFROMDATE\r
-104 stub VARBOOLFROMCY\r
-105 stub VARBOOLFROMSTR\r
-106 stub VARBOOLFROMDISP\r
-107 stub DOINVOKEMETHOD\r
-108 stub VARIANTCHANGETYPEEX\r
-109 stub SAFEARRAYPTROFINDEX\r
-110 stub SETERRORINFO\r
-111 stub GETERRORINFO\r
-112 stub CREATEERRORINFO\r
-113 stub _IID_IERRORINFO\r
-114 stub _IID_ICREATEERRORINFO\r
-115 stub _IID_ISUPPORTERRORINFO\r
-116 stub VARUI1FROMI2\r
-117 stub VARUI1FROMI4\r
-118 stub VARUI1FROMR4\r
-119 stub VARUI1FROMR8\r
-120 stub VARUI1FROMCY\r
-121 stub VARUI1FROMDATE\r
-122 stub VARUI1FROMSTR\r
-123 stub VARUI1FROMDISP\r
-124 stub VARUI1FROMBOOL\r
-125 stub VARI2FROMUI1\r
-126 stub VARI4FROMUI1\r
-127 stub VARR4FROMUI1\r
-128 stub VARR8FROMUI1\r
-129 stub VARDATEFROMUI1\r
-130 stub VARCYFROMUI1\r
-131 stub VARBSTRFROMUI1\r
-132 stub VARBOOLFROMUI1\r
-133 stub DLLCANUNLOADNOW\r
-#134 stub WEP\r
-#135 stub ___EXPORTEDSTUB\r
+1 stub DLLGETCLASSOBJECT
+2 pascal SysAllocString(str)           SysAllocString16
+3 pascal SysReallocString(ptr str)     SysReAllocString16
+4 pascal SysAllocStringLen(str word)   SysAllocStringLen16
+5 pascal SysReAllocStringLen(ptr str word) SysReAllocStringLen16
+6 pascal SysFreeString(segstr)         SysFreeString16
+7 pascal SysStringLen(segstr)          SysStringLen16
+8 stub VARIANTINIT
+9 stub VARIANTCLEAR
+10 stub VARIANTCOPY
+11 stub VARIANTCOPYIND
+12 stub VARIANTCHANGETYPE
+13 stub VARIANTTIMETODOSDATETIME
+14 stub DOSDATETIMETOVARIANTTIME
+15 stub SAFEARRAYCREATE
+16 stub SAFEARRAYDESTROY
+17 stub SAFEARRAYGETDIM
+18 stub SAFEARRAYGETELEMSIZE
+19 stub SAFEARRAYGETUBOUND
+20 stub SAFEARRAYGETLBOUND
+21 stub SAFEARRAYLOCK
+22 stub SAFEARRAYUNLOCK
+23 stub SAFEARRAYACCESSDATA
+24 stub SAFEARRAYUNACCESSDATA
+25 stub SAFEARRAYGETELEMENT
+26 stub SAFEARRAYPUTELEMENT
+27 stub SAFEARRAYCOPY
+28 stub DISPGETPARAM
+29 stub DISPGETIDSOFNAMES
+30 stub DISPINVOKE
+31 pascal CreateDispTypeInfo(ptr long ptr) CreateDispTypeInfo16
+32 pascal CreateStdDispatch(ptr ptr ptr ptr) CreateStdDispatch16
+33 stub _IID_IDISPATCH
+34 stub _IID_IENUMVARIANT
+35 pascal RegisterActiveObject(ptr ptr long ptr) RegisterActiveObject16
+36 stub REVOKEACTIVEOBJECT
+37 stub GETACTIVEOBJECT
+38 stub SAFEARRAYALLOCDESCRIPTOR
+39 stub SAFEARRAYALLOCDATA
+40 stub SAFEARRAYDESTROYDESCRIPTOR
+41 stub SAFEARRAYDESTROYDATA
+42 stub SAFEARRAYREDIM
+43 stub VARI2FROMI4
+44 stub VARI2FROMR4
+45 stub VARI2FROMR8
+46 stub VARI2FROMCY
+47 stub VARI2FROMDATE
+48 stub VARI2FROMSTR
+49 stub VARI2FROMDISP
+50 stub VARI2FROMBOOL
+51 stub VARI4FROMI2
+52 stub VARI4FROMR4
+53 stub VARI4FROMR8
+54 stub VARI4FROMCY
+55 stub VARI4FROMDATE
+56 stub VARI4FROMSTR
+57 stub VARI4FROMDISP
+58 stub VARI4FROMBOOL
+59 stub VARR4FROMI2
+60 stub VARR4FROMI4
+61 stub VARR4FROMR8
+62 stub VARR4FROMCY
+63 stub VARR4FROMDATE
+64 stub VARR4FROMSTR
+65 stub VARR4FROMDISP
+66 stub VARR4FROMBOOL
+67 stub VARR8FROMI2
+68 stub VARR8FROMI4
+69 stub VARR8FROMR4
+70 stub VARR8FROMCY
+71 stub VARR8FROMDATE
+72 stub VARR8FROMSTR
+73 stub VARR8FROMDISP
+74 stub VARR8FROMBOOL
+75 stub VARDATEFROMI2
+76 stub VARDATEFROMI4
+77 stub VARDATEFROMR4
+78 stub VARDATEFROMR8
+79 stub VARDATEFROMCY
+80 stub VARDATEFROMSTR
+81 stub VARDATEFROMDISP
+82 stub VARDATEFROMBOOL
+83 stub VARCYFROMI2
+84 stub VARCYFROMI4
+85 stub VARCYFROMR4
+86 stub VARCYFROMR8
+87 stub VARCYFROMDATE
+88 stub VARCYFROMSTR
+89 stub VARCYFROMDISP
+90 stub VARCYFROMBOOL
+91 stub VARBSTRFROMI2
+92 stub VARBSTRFROMI4
+93 stub VARBSTRFROMR4
+94 stub VARBSTRFROMR8
+95 stub VARBSTRFROMCY
+96 stub VARBSTRFROMDATE
+97 stub VARBSTRFROMDISP
+98 stub VARBSTRFROMBOOL
+99 stub VARBOOLFROMI2
+100 stub VARBOOLFROMI4
+101 stub VARBOOLFROMR4
+102 stub VARBOOLFROMR8
+103 stub VARBOOLFROMDATE
+104 stub VARBOOLFROMCY
+105 stub VARBOOLFROMSTR
+106 stub VARBOOLFROMDISP
+107 stub DOINVOKEMETHOD
+108 stub VARIANTCHANGETYPEEX
+109 stub SAFEARRAYPTROFINDEX
+110 stub SETERRORINFO
+111 stub GETERRORINFO
+112 stub CREATEERRORINFO
+113 stub _IID_IERRORINFO
+114 stub _IID_ICREATEERRORINFO
+115 stub _IID_ISUPPORTERRORINFO
+116 stub VARUI1FROMI2
+117 stub VARUI1FROMI4
+118 stub VARUI1FROMR4
+119 stub VARUI1FROMR8
+120 stub VARUI1FROMCY
+121 stub VARUI1FROMDATE
+122 stub VARUI1FROMSTR
+123 stub VARUI1FROMDISP
+124 stub VARUI1FROMBOOL
+125 stub VARI2FROMUI1
+126 stub VARI4FROMUI1
+127 stub VARR4FROMUI1
+128 stub VARR8FROMUI1
+129 stub VARDATEFROMUI1
+130 stub VARCYFROMUI1
+131 stub VARBSTRFROMUI1
+132 stub VARBOOLFROMUI1
+133 stub DLLCANUNLOADNOW
+#134 stub WEP
+#135 stub ___EXPORTEDSTUB
index b9125b4..1b0f133 100644 (file)
@@ -32,8 +32,7 @@
 #include "ole2.h"
 #include "olectl.h"
 #include "oleauto.h"
-
-#include "tmarshal.h"
+#include "typelib.h"
 
 #include "wine/debug.h"
 
@@ -701,7 +700,7 @@ extern void _get_STDFONT_CF(LPVOID);
 extern void _get_STDPIC_CF(LPVOID);
 
 /***********************************************************************
- *             DllGetClassObject (OLEAUT32.1)
+ *             DllGetClassObject (OLEAUT32.@)
  */
 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
 {
@@ -727,7 +726,7 @@ HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
         return OLEAUTPS_DllGetClassObject(&CLSID_PSDispatch, iid, ppv);
     }
     if (IsEqualGUID(rclsid,&CLSID_PSOAInterface)) {
-       if (S_OK==TypeLibFac_DllGetClassObject(rclsid,iid,ppv))
+       if (S_OK==TMARSHAL_DllGetClassObject(rclsid,iid,ppv))
            return S_OK;
        /*FALLTHROUGH*/
     }
@@ -736,7 +735,7 @@ HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
 }
 
 /***********************************************************************
- *             DllCanUnloadNow (OLEAUT32.410)
+ *             DllCanUnloadNow (OLEAUT32.@)
  *
  * Determine if this dll can be unloaded from the callers address space.
  *
@@ -756,7 +755,7 @@ HRESULT WINAPI DllCanUnloadNow(void)
  */
 BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
 {
-  TRACE("(%p,%lu,%p)\n", hInstDll, fdwReason, lpvReserved);
+  TRACE("(%p,%ld,%p)\n", hInstDll, fdwReason, lpvReserved);
 
   switch (fdwReason) {
   case DLL_PROCESS_ATTACH:
index 2be07f6..cac6ae4 100644 (file)
-1 stdcall -private DllGetClassObject(ptr ptr ptr)\r
-2 stdcall SysAllocString(wstr)\r
-3 stdcall SysReAllocString(ptr wstr)\r
-4 stdcall SysAllocStringLen(wstr long)\r
-5 stdcall SysReAllocStringLen(ptr ptr long)\r
-6 stdcall SysFreeString(wstr)\r
-7 stdcall SysStringLen(wstr)\r
-8 stdcall VariantInit(ptr)\r
-9 stdcall VariantClear(ptr)\r
-10 stdcall VariantCopy(ptr ptr)\r
-11 stdcall VariantCopyInd(ptr ptr)\r
-12 stdcall VariantChangeType(ptr ptr long long)\r
-13 stdcall VariantTimeToDosDateTime(double ptr ptr)\r
-14 stdcall DosDateTimeToVariantTime(long long ptr)\r
-15 stdcall SafeArrayCreate(long long ptr)\r
-16 stdcall SafeArrayDestroy(ptr)\r
-17 stdcall SafeArrayGetDim(ptr)\r
-18 stdcall SafeArrayGetElemsize(ptr)\r
-19 stdcall SafeArrayGetUBound(ptr long long)\r
-20 stdcall SafeArrayGetLBound(ptr long long)\r
-21 stdcall SafeArrayLock(ptr)\r
-22 stdcall SafeArrayUnlock(ptr)\r
-23 stdcall SafeArrayAccessData(ptr ptr)\r
-24 stdcall SafeArrayUnaccessData(ptr)\r
-25 stdcall SafeArrayGetElement(ptr ptr ptr)\r
-26 stdcall SafeArrayPutElement(ptr ptr ptr)\r
-27 stdcall SafeArrayCopy(ptr ptr)\r
-28 stdcall DispGetParam(ptr long long ptr ptr)\r
-29 stdcall DispGetIDsOfNames(ptr ptr long ptr)\r
-30 stdcall DispInvoke(ptr ptr long long ptr ptr ptr ptr)\r
-31 stdcall CreateDispTypeInfo(ptr long ptr)\r
-32 stdcall CreateStdDispatch(ptr ptr ptr ptr)\r
-33 stdcall RegisterActiveObject(ptr ptr long ptr)\r
-34 stdcall RevokeActiveObject(long ptr)\r
-35 stdcall GetActiveObject(ptr ptr ptr)\r
-36 stdcall SafeArrayAllocDescriptor(long ptr)\r
-37 stdcall SafeArrayAllocData(ptr)\r
-38 stdcall SafeArrayDestroyDescriptor(ptr)\r
-39 stdcall SafeArrayDestroyData(ptr)\r
-40 stdcall SafeArrayRedim(ptr ptr)\r
-41 stdcall SafeArrayAllocDescriptorEx(long long ptr)\r
-42 stdcall SafeArrayCreateEx(long long ptr ptr)\r
-43 stdcall SafeArrayCreateVectorEx(long long long ptr)\r
-44 stdcall SafeArraySetRecordInfo(ptr ptr)\r
-45 stdcall SafeArrayGetRecordInfo(ptr ptr)\r
-46 stdcall VarParseNumFromStr(wstr long long ptr ptr)\r
-47 stdcall VarNumFromParseNum(ptr ptr long ptr)\r
-48 stdcall VarI2FromUI1(long ptr)\r
-49 stdcall VarI2FromI4(long ptr)\r
-50 stdcall VarI2FromR4(long ptr)\r
-51 stdcall VarI2FromR8(double ptr)\r
-52 stdcall VarI2FromCy(long long ptr)\r
-53 stdcall VarI2FromDate(double ptr)\r
-54 stdcall VarI2FromStr(wstr long long ptr)\r
-55 stdcall VarI2FromDisp(ptr long ptr)\r
-56 stdcall VarI2FromBool(long ptr)\r
-57 stdcall SafeArraySetIID(ptr ptr)\r
-58 stdcall VarI4FromUI1(long ptr)\r
-59 stdcall VarI4FromI2(long ptr)\r
-60 stdcall VarI4FromR4(long ptr)\r
-61 stdcall VarI4FromR8(double ptr)\r
-62 stdcall VarI4FromCy(long long ptr)\r
-63 stdcall VarI4FromDate(double ptr)\r
-64 stdcall VarI4FromStr(wstr long long ptr)\r
-65 stdcall VarI4FromDisp(ptr long ptr)\r
-66 stdcall VarI4FromBool(long ptr)\r
-67 stdcall SafeArrayGetIID(ptr ptr)\r
-68 stdcall VarR4FromUI1(long ptr)\r
-69 stdcall VarR4FromI2(long ptr)\r
-70 stdcall VarR4FromI4(long ptr)\r
-71 stdcall VarR4FromR8(double ptr)\r
-72 stdcall VarR4FromCy(long long ptr)\r
-73 stdcall VarR4FromDate(double ptr)\r
-74 stdcall VarR4FromStr(wstr long long ptr)\r
-75 stdcall VarR4FromDisp(ptr long ptr)\r
-76 stdcall VarR4FromBool(long ptr)\r
-77 stdcall SafeArrayGetVartype(ptr ptr)\r
-78 stdcall VarR8FromUI1(long ptr)\r
-79 stdcall VarR8FromI2(long ptr)\r
-80 stdcall VarR8FromI4(long ptr)\r
-81 stdcall VarR8FromR4(long ptr)\r
-82 stdcall VarR8FromCy(long long ptr)\r
-83 stdcall VarR8FromDate(double ptr)\r
-84 stdcall VarR8FromStr(wstr long long ptr)\r
-85 stdcall VarR8FromDisp(ptr long ptr)\r
-86 stdcall VarR8FromBool(long ptr)\r
-87 stdcall VarFormat(ptr ptr long long long ptr)\r
-88 stdcall VarDateFromUI1(long ptr)\r
-89 stdcall VarDateFromI2(long ptr)\r
-90 stdcall VarDateFromI4(long ptr)\r
-91 stdcall VarDateFromR4(long ptr)\r
-92 stdcall VarDateFromR8(double ptr)\r
-93 stdcall VarDateFromCy(long long ptr)\r
-94 stdcall VarDateFromStr(wstr long long ptr)\r
-95 stdcall VarDateFromDisp(ptr long ptr)\r
-96 stdcall VarDateFromBool(long ptr)\r
-97 stdcall VarFormatDateTime(ptr long long ptr)\r
-98 stdcall VarCyFromUI1(long ptr)\r
-99 stdcall VarCyFromI2(long ptr)\r
-100 stdcall VarCyFromI4(long ptr)\r
-101 stdcall VarCyFromR4(long ptr)\r
-102 stdcall VarCyFromR8(double ptr)\r
-103 stdcall VarCyFromDate(double ptr)\r
-104 stdcall VarCyFromStr(wstr long long ptr)\r
-105 stdcall VarCyFromDisp(ptr long ptr)\r
-106 stdcall VarCyFromBool(long ptr)\r
-107 stdcall VarFormatNumber(ptr long long long long long ptr)\r
-108 stdcall VarBstrFromUI1(long long long ptr)\r
-109 stdcall VarBstrFromI2(long long long ptr)\r
-110 stdcall VarBstrFromI4(long long long ptr)\r
-111 stdcall VarBstrFromR4(long long long ptr)\r
-112 stdcall VarBstrFromR8(double long long ptr)\r
-113 stdcall VarBstrFromCy(long long long long ptr)\r
-114 stdcall VarBstrFromDate(double long long ptr)\r
-115 stub VarBstrFromDisp\r
-116 stdcall VarBstrFromBool(long long long ptr)\r
-117 stdcall VarFormatPercent(ptr long long long long long ptr)\r
-118 stdcall VarBoolFromUI1(long ptr)\r
-119 stdcall VarBoolFromI2(long ptr)\r
-120 stdcall VarBoolFromI4(long ptr)\r
-121 stdcall VarBoolFromR4(long ptr)\r
-122 stdcall VarBoolFromR8(double ptr)\r
-123 stdcall VarBoolFromDate(double ptr)\r
-124 stdcall VarBoolFromCy(long long ptr)\r
-125 stdcall VarBoolFromStr(wstr long long ptr)\r
-126 stdcall VarBoolFromDisp(ptr long ptr)\r
-127 stdcall VarFormatCurrency(ptr long long long long long ptr)\r
-128 stub VarWeekdayName # stdcall (long long long long ptr)\r
-129 stdcall VarMonthName(long long long ptr)\r
-130 stdcall VarUI1FromI2(long ptr)\r
-131 stdcall VarUI1FromI4(long ptr)\r
-132 stdcall VarUI1FromR4(long ptr)\r
-133 stdcall VarUI1FromR8(double ptr)\r
-134 stdcall VarUI1FromCy(long long ptr)\r
-135 stdcall VarUI1FromDate(double ptr)\r
-136 stdcall VarUI1FromStr(wstr long long ptr)\r
-137 stdcall VarUI1FromDisp(ptr long ptr)\r
-138 stdcall VarUI1FromBool(long ptr)\r
-139 stdcall VarFormatFromTokens (ptr ptr ptr long ptr long)\r
-140 stdcall VarTokenizeFormatString (ptr ptr long long long long ptr)\r
-141 stdcall VarAdd(ptr ptr ptr)\r
-142 stdcall VarAnd(ptr ptr ptr)\r
-143 stdcall VarDiv(ptr ptr ptr)\r
-144 stub OACreateTypeLib2\r
-146 stdcall DispCallFunc(ptr long long long long ptr ptr ptr)\r
-147 stdcall VariantChangeTypeEx(ptr ptr long long long)\r
-148 stdcall SafeArrayPtrOfIndex(ptr ptr ptr)\r
-149 stdcall SysStringByteLen(ptr)\r
-150 stdcall SysAllocStringByteLen(ptr long)\r
-152 stdcall VarEqv(ptr ptr ptr)\r
-153 stdcall VarIdiv(ptr ptr ptr)\r
-154 stub VarImp # stdcall (ptr ptr ptr)\r
-155 stdcall VarMod(ptr ptr ptr)\r
-156 stdcall VarMul(ptr ptr ptr)\r
-157 stdcall VarOr(ptr ptr ptr)\r
-158 stdcall VarPow(ptr ptr ptr)\r
-159 stdcall VarSub(ptr ptr ptr)\r
-160 stdcall CreateTypeLib(long wstr ptr)\r
-161 stdcall LoadTypeLib (wstr ptr)\r
-162 stdcall LoadRegTypeLib (ptr long long long ptr)\r
-163 stdcall RegisterTypeLib(ptr wstr wstr)\r
-164 stdcall QueryPathOfRegTypeLib(ptr long long long ptr)\r
-165 stdcall LHashValOfNameSys(long long wstr)\r
-166 stdcall LHashValOfNameSysA(long long str)\r
-167 stdcall VarXor(ptr ptr ptr)\r
-168 stdcall VarAbs(ptr ptr)\r
-169 stdcall VarFix(ptr ptr)\r
-170 stdcall OaBuildVersion()\r
-171 stdcall ClearCustData(ptr)\r
-172 stdcall VarInt(ptr ptr)\r
-173 stdcall VarNeg(ptr ptr)\r
-174 stdcall VarNot(ptr ptr)\r
-175 stdcall VarRound(ptr long ptr)\r
-176 stdcall VarCmp(ptr ptr long long)\r
-177 stdcall VarDecAdd(ptr ptr ptr)\r
-178 stdcall VarDecDiv(ptr ptr ptr)\r
-179 stdcall VarDecMul(ptr ptr ptr)\r
-180 stdcall CreateTypeLib2(long wstr ptr)\r
-181 stdcall VarDecSub(ptr ptr ptr)\r
-182 stdcall VarDecAbs(ptr ptr)\r
-183 stdcall LoadTypeLibEx (wstr long ptr)\r
-184 stdcall SystemTimeToVariantTime(ptr ptr)\r
-185 stdcall VariantTimeToSystemTime(double ptr)\r
-186 stdcall UnRegisterTypeLib (ptr long long long long)\r
-187 stdcall VarDecFix(ptr ptr)\r
-188 stdcall VarDecInt(ptr ptr)\r
-189 stdcall VarDecNeg(ptr ptr)\r
-190 stdcall VarDecFromUI1(long ptr)\r
-191 stdcall VarDecFromI2(long ptr)\r
-192 stdcall VarDecFromI4(long ptr)\r
-193 stdcall VarDecFromR4(long ptr)\r
-194 stdcall VarDecFromR8(double ptr)\r
-195 stdcall VarDecFromDate(double ptr)\r
-196 stdcall VarDecFromCy(long long ptr)\r
-197 stdcall VarDecFromStr(wstr long long ptr)\r
-198 stdcall VarDecFromDisp(ptr long ptr)\r
-199 stdcall VarDecFromBool(long ptr)\r
-200 stdcall GetErrorInfo(long ptr) ole32.GetErrorInfo\r
-201 stdcall SetErrorInfo(long ptr) ole32.SetErrorInfo\r
-202 stdcall CreateErrorInfo(ptr) ole32.CreateErrorInfo\r
-203 stdcall VarDecRound(ptr long ptr)\r
-204 stdcall VarDecCmp(ptr ptr)\r
-205 stdcall VarI2FromI1(long ptr)\r
-206 stdcall VarI2FromUI2(long ptr)\r
-207 stdcall VarI2FromUI4(long ptr)\r
-208 stdcall VarI2FromDec(ptr ptr)\r
-209 stdcall VarI4FromI1(long ptr)\r
-210 stdcall VarI4FromUI2(long ptr)\r
-211 stdcall VarI4FromUI4(long ptr)\r
-212 stdcall VarI4FromDec(ptr ptr)\r
-213 stdcall VarR4FromI1(long ptr)\r
-214 stdcall VarR4FromUI2(long ptr)\r
-215 stdcall VarR4FromUI4(long ptr)\r
-216 stdcall VarR4FromDec(ptr ptr)\r
-217 stdcall VarR8FromI1(long ptr)\r
-218 stdcall VarR8FromUI2(long ptr)\r
-219 stdcall VarR8FromUI4(long ptr)\r
-220 stdcall VarR8FromDec(ptr ptr)\r
-221 stdcall VarDateFromI1(long ptr)\r
-222 stdcall VarDateFromUI2(long ptr)\r
-223 stdcall VarDateFromUI4(long ptr)\r
-224 stdcall VarDateFromDec(ptr ptr)\r
-225 stdcall VarCyFromI1(long ptr)\r
-226 stdcall VarCyFromUI2(long ptr)\r
-227 stdcall VarCyFromUI4(long ptr)\r
-228 stdcall VarCyFromDec(ptr ptr)\r
-229 stdcall VarBstrFromI1(long long long ptr)\r
-230 stdcall VarBstrFromUI2(long long long ptr)\r
-231 stdcall VarBstrFromUI4(long long long ptr)\r
-232 stdcall VarBstrFromDec(ptr long long ptr)\r
-233 stdcall VarBoolFromI1(long ptr)\r
-234 stdcall VarBoolFromUI2(long ptr)\r
-235 stdcall VarBoolFromUI4(long ptr)\r
-236 stdcall VarBoolFromDec(ptr ptr)\r
-237 stdcall VarUI1FromI1(long ptr)\r
-238 stdcall VarUI1FromUI2(long ptr)\r
-239 stdcall VarUI1FromUI4(long ptr)\r
-240 stdcall VarUI1FromDec(ptr ptr)\r
-241 stdcall VarDecFromI1(long ptr)\r
-242 stdcall VarDecFromUI2(long ptr)\r
-243 stdcall VarDecFromUI4(long ptr)\r
-244 stdcall VarI1FromUI1(long ptr)\r
-245 stdcall VarI1FromI2(long ptr)\r
-246 stdcall VarI1FromI4(long ptr)\r
-247 stdcall VarI1FromR4(long ptr)\r
-248 stdcall VarI1FromR8(double ptr)\r
-249 stdcall VarI1FromDate(double ptr)\r
-250 stdcall VarI1FromCy(long long ptr)\r
-251 stdcall VarI1FromStr(wstr long long ptr)\r
-252 stdcall VarI1FromDisp(ptr long ptr)\r
-253 stdcall VarI1FromBool(long ptr)\r
-254 stdcall VarI1FromUI2(long ptr)\r
-255 stdcall VarI1FromUI4(long ptr)\r
-256 stdcall VarI1FromDec(ptr ptr)\r
-257 stdcall VarUI2FromUI1(long ptr)\r
-258 stdcall VarUI2FromI2(long ptr)\r
-259 stdcall VarUI2FromI4(long ptr)\r
-260 stdcall VarUI2FromR4(long ptr)\r
-261 stdcall VarUI2FromR8(double ptr)\r
-262 stdcall VarUI2FromDate(double ptr)\r
-263 stdcall VarUI2FromCy(long long ptr)\r
-264 stdcall VarUI2FromStr(wstr long long ptr)\r
-265 stdcall VarUI2FromDisp(ptr long ptr)\r
-266 stdcall VarUI2FromBool(long ptr)\r
-267 stdcall VarUI2FromI1(long ptr)\r
-268 stdcall VarUI2FromUI4(long ptr)\r
-269 stdcall VarUI2FromDec(ptr ptr)\r
-270 stdcall VarUI4FromUI1(long ptr)\r
-271 stdcall VarUI4FromI2(long ptr)\r
-272 stdcall VarUI4FromI4(long ptr)\r
-273 stdcall VarUI4FromR4(long ptr)\r
-274 stdcall VarUI4FromR8(double ptr)\r
-275 stdcall VarUI4FromDate(double ptr)\r
-276 stdcall VarUI4FromCy(long long ptr)\r
-277 stdcall VarUI4FromStr(wstr long long ptr)\r
-278 stdcall VarUI4FromDisp(ptr long ptr)\r
-279 stdcall VarUI4FromBool(long ptr)\r
-280 stdcall VarUI4FromI1(long ptr)\r
-281 stdcall VarUI4FromUI2(long ptr)\r
-282 stdcall VarUI4FromDec(ptr ptr)\r
-283 stdcall BSTR_UserSize(ptr long ptr)\r
-284 stdcall BSTR_UserMarshal(ptr ptr ptr)\r
-285 stdcall BSTR_UserUnmarshal(ptr ptr ptr)\r
-286 stdcall BSTR_UserFree(ptr ptr)\r
-287 stdcall VARIANT_UserSize(ptr long ptr)\r
-288 stdcall VARIANT_UserMarshal(ptr ptr ptr)\r
-289 stdcall VARIANT_UserUnmarshal(ptr ptr ptr)\r
-290 stdcall VARIANT_UserFree(ptr ptr)\r
-291 stub LPSAFEARRAY_UserSize\r
-292 stub LPSAFEARRAY_UserMarshal\r
-293 stub LPSAFEARRAY_UserUnmarshal\r
-294 stub LPSAFEARRAY_UserFree\r
-295 stub LPSAFEARRAY_Size\r
-296 stub LPSAFEARRAY_Marshal\r
-297 stub LPSAFEARRAY_Unmarshal\r
-298 stdcall VarDecCmpR8(ptr double)\r
-299 stdcall VarCyAdd(long long long long ptr)\r
-303 stdcall VarCyMul(long long long long ptr)\r
-304 stdcall VarCyMulI4(long long long ptr)\r
-305 stdcall VarCySub(long long long long ptr)\r
-306 stdcall VarCyAbs(long long ptr)\r
-307 stdcall VarCyFix(long long ptr)\r
-308 stdcall VarCyInt(long long ptr)\r
-309 stdcall VarCyNeg(long long ptr)\r
-310 stdcall VarCyRound(long long long ptr)\r
-311 stdcall VarCyCmp(long long long long)\r
-312 stdcall VarCyCmpR8(long long double)\r
-313 stdcall VarBstrCat(wstr wstr ptr)\r
-314 stdcall VarBstrCmp(wstr wstr long long)\r
-315 stdcall VarR8Pow(double double ptr)\r
-316 stdcall VarR4CmpR8(long double)\r
-317 stdcall VarR8Round(double long ptr)\r
-318 stdcall VarCat(ptr ptr ptr)\r
-319 stdcall VarDateFromUdateEx(ptr long long ptr)\r
-320 stdcall -private DllRegisterServer()\r
-321 stdcall -private DllUnregisterServer()\r
-322 stdcall GetRecordInfoFromGuids(ptr long long long ptr ptr)\r
-323 stdcall GetRecordInfoFromTypeInfo(ptr ptr)\r
-325 stub SetVarConversionLocaleSetting\r
-326 stub GetVarConversionLocaleSetting\r
-327 stdcall SetOaNoCache()\r
-329 stdcall VarCyMulI8(long long long long ptr)\r
-330 stdcall VarDateFromUdate(ptr long ptr)\r
-331 stdcall VarUdateFromDate(double long ptr)\r
-332 stub GetAltMonthNames\r
-333 stdcall VarI8FromUI1(long long)\r
-334 stdcall VarI8FromI2(long long)\r
-335 stdcall VarI8FromR4(long long)\r
-336 stdcall VarI8FromR8(double long)\r
-337 stdcall VarI8FromCy(long long ptr)\r
-338 stdcall VarI8FromDate(double long)\r
-339 stdcall VarI8FromStr(wstr long long ptr)\r
-340 stdcall VarI8FromDisp(ptr long ptr)\r
-341 stdcall VarI8FromBool(long long)\r
-342 stdcall VarI8FromI1(long long)\r
-343 stdcall VarI8FromUI2(long long)\r
-344 stdcall VarI8FromUI4(long long)\r
-345 stdcall VarI8FromDec(ptr ptr)\r
-346 stdcall VarI2FromI8(long long ptr)\r
-347 stdcall VarI2FromUI8(long long ptr)\r
-348 stdcall VarI4FromI8(long long ptr)\r
-349 stdcall VarI4FromUI8(long long ptr)\r
-360 stdcall VarR4FromI8(long long ptr)\r
-361 stdcall VarR4FromUI8(long long ptr)\r
-362 stdcall VarR8FromI8(long long ptr)\r
-363 stdcall VarR8FromUI8(long long ptr)\r
-364 stdcall VarDateFromI8(long long ptr)\r
-365 stdcall VarDateFromUI8(long long ptr)\r
-366 stdcall VarCyFromI8(long long ptr)\r
-367 stdcall VarCyFromUI8(long long ptr)\r
-368 stdcall VarBstrFromI8(long long long long ptr)\r
-369 stdcall VarBstrFromUI8(long long long long ptr)\r
-370 stdcall VarBoolFromI8(long long ptr)\r
-371 stdcall VarBoolFromUI8(long long ptr)\r
-372 stdcall VarUI1FromI8(long long ptr)\r
-373 stdcall VarUI1FromUI8(long long ptr)\r
-374 stdcall VarDecFromI8(long long ptr)\r
-375 stdcall VarDecFromUI8(long long ptr)\r
-376 stdcall VarI1FromI8(long long ptr)\r
-377 stdcall VarI1FromUI8(long long ptr)\r
-378 stdcall VarUI2FromI8(long long ptr)\r
-379 stdcall VarUI2FromUI8(long long ptr)\r
-380 stub UserHWND_from_local\r
-381 stub UserHWND_to_local\r
-382 stub UserHWND_free_inst\r
-383 stub UserHWND_free_local\r
-384 stub UserBSTR_from_local\r
-385 stub UserBSTR_to_local\r
-386 stub UserBSTR_free_inst\r
-387 stub UserBSTR_free_local\r
-388 stub UserVARIANT_from_local\r
-389 stub UserVARIANT_to_local\r
-390 stub UserVARIANT_free_inst\r
-391 stub UserVARIANT_free_local\r
-392 stub UserEXCEPINFO_from_local\r
-393 stub UserEXCEPINFO_to_local\r
-394 stub UserEXCEPINFO_free_inst\r
-395 stub UserEXCEPINFO_free_local\r
-396 stub UserMSG_from_local\r
-397 stub UserMSG_to_local\r
-398 stub UserMSG_free_inst\r
-399 stub UserMSG_free_local\r
-401 stdcall OleLoadPictureEx(ptr long long long long long long ptr)\r
-402 stub OleLoadPictureFileEx\r
-410 stdcall -private DllCanUnloadNow()\r
-411 stdcall SafeArrayCreateVector(long long long)\r
-412 stdcall SafeArrayCopyData(ptr ptr)\r
-413 stdcall VectorFromBstr(ptr ptr)\r
-414 stdcall BstrFromVector(ptr ptr)\r
-415 stdcall OleIconToCursor(long long)\r
-416 stdcall OleCreatePropertyFrameIndirect(ptr)\r
-417 stdcall OleCreatePropertyFrame(ptr long long ptr long ptr long ptr ptr long ptr)\r
-418 stdcall OleLoadPicture(ptr long long ptr ptr)\r
-419 stdcall OleCreatePictureIndirect(ptr ptr long ptr)\r
-420 stdcall OleCreateFontIndirect(ptr ptr ptr)\r
-421 stdcall OleTranslateColor(long long long)\r
-422 stub OleLoadPictureFile\r
-423 stub OleSavePictureFile\r
-424 stdcall OleLoadPicturePath(wstr ptr long long ptr ptr)\r
-425 stdcall VarUI4FromI8(long long ptr)\r
-426 stdcall VarUI4FromUI8(long long ptr)\r
-427 stdcall VarI8FromUI8(long long ptr)\r
-428 stdcall VarUI8FromI8(long long ptr)\r
-429 stdcall VarUI8FromUI1(long ptr)\r
-430 stdcall VarUI8FromI2(long ptr)\r
-431 stdcall VarUI8FromR4(long ptr)\r
-432 stdcall VarUI8FromR8(double ptr)\r
-433 stdcall VarUI8FromCy(long long ptr)\r
-434 stdcall VarUI8FromDate(double ptr)\r
-435 stdcall VarUI8FromStr(wstr long long ptr)\r
-436 stdcall VarUI8FromDisp(ptr long ptr)\r
-437 stdcall VarUI8FromBool(long ptr)\r
-438 stdcall VarUI8FromI1(long ptr)\r
-439 stdcall VarUI8FromUI2(long ptr)\r
-440 stdcall VarUI8FromUI4(long ptr)\r
-441 stdcall VarUI8FromDec(long ptr)\r
+2 stdcall SysAllocString(wstr)
+3 stdcall SysReAllocString(ptr wstr)
+4 stdcall SysAllocStringLen(wstr long)
+5 stdcall SysReAllocStringLen(ptr ptr long)
+6 stdcall SysFreeString(wstr)
+7 stdcall SysStringLen(wstr)
+8 stdcall VariantInit(ptr)
+9 stdcall VariantClear(ptr)
+10 stdcall VariantCopy(ptr ptr)
+11 stdcall VariantCopyInd(ptr ptr)
+12 stdcall VariantChangeType(ptr ptr long long)
+13 stdcall VariantTimeToDosDateTime(double ptr ptr)
+14 stdcall DosDateTimeToVariantTime(long long ptr)
+15 stdcall SafeArrayCreate(long long ptr)
+16 stdcall SafeArrayDestroy(ptr)
+17 stdcall SafeArrayGetDim(ptr)
+18 stdcall SafeArrayGetElemsize(ptr)
+19 stdcall SafeArrayGetUBound(ptr long long)
+20 stdcall SafeArrayGetLBound(ptr long long)
+21 stdcall SafeArrayLock(ptr)
+22 stdcall SafeArrayUnlock(ptr)
+23 stdcall SafeArrayAccessData(ptr ptr)
+24 stdcall SafeArrayUnaccessData(ptr)
+25 stdcall SafeArrayGetElement(ptr ptr ptr)
+26 stdcall SafeArrayPutElement(ptr ptr ptr)
+27 stdcall SafeArrayCopy(ptr ptr)
+28 stdcall DispGetParam(ptr long long ptr ptr)
+29 stdcall DispGetIDsOfNames(ptr ptr long ptr)
+30 stdcall DispInvoke(ptr ptr long long ptr ptr ptr ptr)
+31 stdcall CreateDispTypeInfo(ptr long ptr)
+32 stdcall CreateStdDispatch(ptr ptr ptr ptr)
+33 stdcall RegisterActiveObject(ptr ptr long ptr)
+34 stdcall RevokeActiveObject(long ptr)
+35 stdcall GetActiveObject(ptr ptr ptr)
+36 stdcall SafeArrayAllocDescriptor(long ptr)
+37 stdcall SafeArrayAllocData(ptr)
+38 stdcall SafeArrayDestroyDescriptor(ptr)
+39 stdcall SafeArrayDestroyData(ptr)
+40 stdcall SafeArrayRedim(ptr ptr)
+41 stdcall SafeArrayAllocDescriptorEx(long long ptr)
+42 stdcall SafeArrayCreateEx(long long ptr ptr)
+43 stdcall SafeArrayCreateVectorEx(long long long ptr)
+44 stdcall SafeArraySetRecordInfo(ptr ptr)
+45 stdcall SafeArrayGetRecordInfo(ptr ptr)
+46 stdcall VarParseNumFromStr(wstr long long ptr ptr)
+47 stdcall VarNumFromParseNum(ptr ptr long ptr)
+48 stdcall VarI2FromUI1(long ptr)
+49 stdcall VarI2FromI4(long ptr)
+50 stdcall VarI2FromR4(long ptr)
+51 stdcall VarI2FromR8(double ptr)
+52 stdcall VarI2FromCy(long long ptr)
+53 stdcall VarI2FromDate(double ptr)
+54 stdcall VarI2FromStr(wstr long long ptr)
+55 stdcall VarI2FromDisp(ptr long ptr)
+56 stdcall VarI2FromBool(long ptr)
+57 stdcall SafeArraySetIID(ptr ptr)
+58 stdcall VarI4FromUI1(long ptr)
+59 stdcall VarI4FromI2(long ptr)
+60 stdcall VarI4FromR4(long ptr)
+61 stdcall VarI4FromR8(double ptr)
+62 stdcall VarI4FromCy(long long ptr)
+63 stdcall VarI4FromDate(double ptr)
+64 stdcall VarI4FromStr(wstr long long ptr)
+65 stdcall VarI4FromDisp(ptr long ptr)
+66 stdcall VarI4FromBool(long ptr)
+67 stdcall SafeArrayGetIID(ptr ptr)
+68 stdcall VarR4FromUI1(long ptr)
+69 stdcall VarR4FromI2(long ptr)
+70 stdcall VarR4FromI4(long ptr)
+71 stdcall VarR4FromR8(double ptr)
+72 stdcall VarR4FromCy(long long ptr)
+73 stdcall VarR4FromDate(double ptr)
+74 stdcall VarR4FromStr(wstr long long ptr)
+75 stdcall VarR4FromDisp(ptr long ptr)
+76 stdcall VarR4FromBool(long ptr)
+77 stdcall SafeArrayGetVartype(ptr ptr)
+78 stdcall VarR8FromUI1(long ptr)
+79 stdcall VarR8FromI2(long ptr)
+80 stdcall VarR8FromI4(long ptr)
+81 stdcall VarR8FromR4(long ptr)
+82 stdcall VarR8FromCy(long long ptr)
+83 stdcall VarR8FromDate(double ptr)
+84 stdcall VarR8FromStr(wstr long long ptr)
+85 stdcall VarR8FromDisp(ptr long ptr)
+86 stdcall VarR8FromBool(long ptr)
+87 stdcall VarFormat(ptr ptr long long long ptr)
+88 stdcall VarDateFromUI1(long ptr)
+89 stdcall VarDateFromI2(long ptr)
+90 stdcall VarDateFromI4(long ptr)
+91 stdcall VarDateFromR4(long ptr)
+92 stdcall VarDateFromR8(double ptr)
+93 stdcall VarDateFromCy(long long ptr)
+94 stdcall VarDateFromStr(wstr long long ptr)
+95 stdcall VarDateFromDisp(ptr long ptr)
+96 stdcall VarDateFromBool(long ptr)
+97 stdcall VarFormatDateTime(ptr long long ptr)
+98 stdcall VarCyFromUI1(long ptr)
+99 stdcall VarCyFromI2(long ptr)
+100 stdcall VarCyFromI4(long ptr)
+101 stdcall VarCyFromR4(long ptr)
+102 stdcall VarCyFromR8(double ptr)
+103 stdcall VarCyFromDate(double ptr)
+104 stdcall VarCyFromStr(wstr long long ptr)
+105 stdcall VarCyFromDisp(ptr long ptr)
+106 stdcall VarCyFromBool(long ptr)
+107 stdcall VarFormatNumber(ptr long long long long long ptr)
+108 stdcall VarBstrFromUI1(long long long ptr)
+109 stdcall VarBstrFromI2(long long long ptr)
+110 stdcall VarBstrFromI4(long long long ptr)
+111 stdcall VarBstrFromR4(long long long ptr)
+112 stdcall VarBstrFromR8(double long long ptr)
+113 stdcall VarBstrFromCy(long long long long ptr)
+114 stdcall VarBstrFromDate(double long long ptr)
+115 stub VarBstrFromDisp
+116 stdcall VarBstrFromBool(long long long ptr)
+117 stdcall VarFormatPercent(ptr long long long long long ptr)
+118 stdcall VarBoolFromUI1(long ptr)
+119 stdcall VarBoolFromI2(long ptr)
+120 stdcall VarBoolFromI4(long ptr)
+121 stdcall VarBoolFromR4(long ptr)
+122 stdcall VarBoolFromR8(double ptr)
+123 stdcall VarBoolFromDate(double ptr)
+124 stdcall VarBoolFromCy(long long ptr)
+125 stdcall VarBoolFromStr(wstr long long ptr)
+126 stdcall VarBoolFromDisp(ptr long ptr)
+127 stdcall VarFormatCurrency(ptr long long long long long ptr)
+128 stub VarWeekdayName # stdcall (long long long long ptr)
+129 stdcall VarMonthName(long long long ptr)
+130 stdcall VarUI1FromI2(long ptr)
+131 stdcall VarUI1FromI4(long ptr)
+132 stdcall VarUI1FromR4(long ptr)
+133 stdcall VarUI1FromR8(double ptr)
+134 stdcall VarUI1FromCy(long long ptr)
+135 stdcall VarUI1FromDate(double ptr)
+136 stdcall VarUI1FromStr(wstr long long ptr)
+137 stdcall VarUI1FromDisp(ptr long ptr)
+138 stdcall VarUI1FromBool(long ptr)
+139 stdcall VarFormatFromTokens (ptr ptr ptr long ptr long)
+140 stdcall VarTokenizeFormatString (ptr ptr long long long long ptr)
+141 stdcall VarAdd(ptr ptr ptr)
+142 stdcall VarAnd(ptr ptr ptr)
+143 stdcall VarDiv(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)
+152 stdcall VarEqv(ptr ptr ptr)
+153 stdcall VarIdiv(ptr ptr ptr)
+154 stub VarImp # stdcall (ptr ptr ptr)
+155 stdcall VarMod(ptr ptr ptr)
+156 stdcall VarMul(ptr ptr ptr)
+157 stdcall VarOr(ptr ptr ptr)
+158 stdcall VarPow(ptr ptr ptr)
+159 stdcall VarSub(ptr ptr ptr)
+160 stdcall CreateTypeLib(long wstr ptr)
+161 stdcall LoadTypeLib (wstr ptr)
+162 stdcall LoadRegTypeLib (ptr long long long ptr)
+163 stdcall RegisterTypeLib(ptr wstr wstr)
+164 stdcall QueryPathOfRegTypeLib(ptr long long long ptr)
+165 stdcall LHashValOfNameSys(long long wstr)
+166 stdcall LHashValOfNameSysA(long long str)
+167 stdcall VarXor(ptr ptr ptr)
+168 stdcall VarAbs(ptr ptr)
+169 stdcall VarFix(ptr ptr)
+170 stdcall OaBuildVersion()
+171 stdcall ClearCustData(ptr)
+172 stdcall VarInt(ptr ptr)
+173 stdcall VarNeg(ptr ptr)
+174 stdcall VarNot(ptr ptr)
+175 stdcall VarRound(ptr long ptr)
+176 stdcall VarCmp(ptr ptr long long)
+177 stdcall VarDecAdd(ptr ptr ptr)
+178 stdcall VarDecDiv(ptr ptr ptr)
+179 stdcall VarDecMul(ptr ptr ptr)
+180 stdcall CreateTypeLib2(long wstr ptr)
+181 stdcall VarDecSub(ptr ptr ptr)
+182 stdcall VarDecAbs(ptr ptr)
+183 stdcall LoadTypeLibEx (wstr long ptr)
+184 stdcall SystemTimeToVariantTime(ptr ptr)
+185 stdcall VariantTimeToSystemTime(double ptr)
+186 stdcall UnRegisterTypeLib (ptr long long long long)
+187 stdcall VarDecFix(ptr ptr)
+188 stdcall VarDecInt(ptr ptr)
+189 stdcall VarDecNeg(ptr ptr)
+190 stdcall VarDecFromUI1(long ptr)
+191 stdcall VarDecFromI2(long ptr)
+192 stdcall VarDecFromI4(long ptr)
+193 stdcall VarDecFromR4(long ptr)
+194 stdcall VarDecFromR8(double ptr)
+195 stdcall VarDecFromDate(double ptr)
+196 stdcall VarDecFromCy(long long ptr)
+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
+203 stdcall VarDecRound(ptr long ptr)
+204 stdcall VarDecCmp(ptr ptr)
+205 stdcall VarI2FromI1(long ptr)
+206 stdcall VarI2FromUI2(long ptr)
+207 stdcall VarI2FromUI4(long ptr)
+208 stdcall VarI2FromDec(ptr ptr)
+209 stdcall VarI4FromI1(long ptr)
+210 stdcall VarI4FromUI2(long ptr)
+211 stdcall VarI4FromUI4(long ptr)
+212 stdcall VarI4FromDec(ptr ptr)
+213 stdcall VarR4FromI1(long ptr)
+214 stdcall VarR4FromUI2(long ptr)
+215 stdcall VarR4FromUI4(long ptr)
+216 stdcall VarR4FromDec(ptr ptr)
+217 stdcall VarR8FromI1(long ptr)
+218 stdcall VarR8FromUI2(long ptr)
+219 stdcall VarR8FromUI4(long ptr)
+220 stdcall VarR8FromDec(ptr ptr)
+221 stdcall VarDateFromI1(long ptr)
+222 stdcall VarDateFromUI2(long ptr)
+223 stdcall VarDateFromUI4(long ptr)
+224 stdcall VarDateFromDec(ptr ptr)
+225 stdcall VarCyFromI1(long ptr)
+226 stdcall VarCyFromUI2(long ptr)
+227 stdcall VarCyFromUI4(long ptr)
+228 stdcall VarCyFromDec(ptr ptr)
+229 stdcall VarBstrFromI1(long long long ptr)
+230 stdcall VarBstrFromUI2(long long long ptr)
+231 stdcall VarBstrFromUI4(long long long ptr)
+232 stdcall VarBstrFromDec(ptr long long ptr)
+233 stdcall VarBoolFromI1(long ptr)
+234 stdcall VarBoolFromUI2(long ptr)
+235 stdcall VarBoolFromUI4(long ptr)
+236 stdcall VarBoolFromDec(ptr ptr)
+237 stdcall VarUI1FromI1(long ptr)
+238 stdcall VarUI1FromUI2(long ptr)
+239 stdcall VarUI1FromUI4(long ptr)
+240 stdcall VarUI1FromDec(ptr ptr)
+241 stdcall VarDecFromI1(long ptr)
+242 stdcall VarDecFromUI2(long ptr)
+243 stdcall VarDecFromUI4(long ptr)
+244 stdcall VarI1FromUI1(long ptr)
+245 stdcall VarI1FromI2(long ptr)
+246 stdcall VarI1FromI4(long ptr)
+247 stdcall VarI1FromR4(long ptr)
+248 stdcall VarI1FromR8(double ptr)
+249 stdcall VarI1FromDate(double ptr)
+250 stdcall VarI1FromCy(long long ptr)
+251 stdcall VarI1FromStr(wstr long long ptr)
+252 stdcall VarI1FromDisp(ptr long ptr)
+253 stdcall VarI1FromBool(long ptr)
+254 stdcall VarI1FromUI2(long ptr)
+255 stdcall VarI1FromUI4(long ptr)
+256 stdcall VarI1FromDec(ptr ptr)
+257 stdcall VarUI2FromUI1(long ptr)
+258 stdcall VarUI2FromI2(long ptr)
+259 stdcall VarUI2FromI4(long ptr)
+260 stdcall VarUI2FromR4(long ptr)
+261 stdcall VarUI2FromR8(double ptr)
+262 stdcall VarUI2FromDate(double ptr)
+263 stdcall VarUI2FromCy(long long ptr)
+264 stdcall VarUI2FromStr(wstr long long ptr)
+265 stdcall VarUI2FromDisp(ptr long ptr)
+266 stdcall VarUI2FromBool(long ptr)
+267 stdcall VarUI2FromI1(long ptr)
+268 stdcall VarUI2FromUI4(long ptr)
+269 stdcall VarUI2FromDec(ptr ptr)
+270 stdcall VarUI4FromUI1(long ptr)
+271 stdcall VarUI4FromI2(long ptr)
+272 stdcall VarUI4FromI4(long ptr)
+273 stdcall VarUI4FromR4(long ptr)
+274 stdcall VarUI4FromR8(double ptr)
+275 stdcall VarUI4FromDate(double ptr)
+276 stdcall VarUI4FromCy(long long ptr)
+277 stdcall VarUI4FromStr(wstr long long ptr)
+278 stdcall VarUI4FromDisp(ptr long ptr)
+279 stdcall VarUI4FromBool(long ptr)
+280 stdcall VarUI4FromI1(long ptr)
+281 stdcall VarUI4FromUI2(long ptr)
+282 stdcall VarUI4FromDec(ptr ptr)
+283 stdcall BSTR_UserSize(ptr long ptr)
+284 stdcall BSTR_UserMarshal(ptr ptr ptr)
+285 stdcall BSTR_UserUnmarshal(ptr ptr ptr)
+286 stdcall BSTR_UserFree(ptr ptr)
+287 stdcall VARIANT_UserSize(ptr long ptr)
+288 stdcall VARIANT_UserMarshal(ptr ptr ptr)
+289 stdcall VARIANT_UserUnmarshal(ptr ptr ptr)
+290 stdcall VARIANT_UserFree(ptr ptr)
+291 stub LPSAFEARRAY_UserSize
+292 stub LPSAFEARRAY_UserMarshal
+293 stub LPSAFEARRAY_UserUnmarshal
+294 stub LPSAFEARRAY_UserFree
+295 stub LPSAFEARRAY_Size
+296 stub LPSAFEARRAY_Marshal
+297 stub LPSAFEARRAY_Unmarshal
+298 stdcall VarDecCmpR8(ptr double)
+299 stdcall VarCyAdd(long long long long ptr)
+303 stdcall VarCyMul(long long long long ptr)
+304 stdcall VarCyMulI4(long long long ptr)
+305 stdcall VarCySub(long long long long ptr)
+306 stdcall VarCyAbs(long long ptr)
+307 stdcall VarCyFix(long long ptr)
+308 stdcall VarCyInt(long long ptr)
+309 stdcall VarCyNeg(long long ptr)
+310 stdcall VarCyRound(long long long ptr)
+311 stdcall VarCyCmp(long long long long)
+312 stdcall VarCyCmpR8(long long double)
+313 stdcall VarBstrCat(wstr wstr ptr)
+314 stdcall VarBstrCmp(wstr wstr long long)
+315 stdcall VarR8Pow(double double ptr)
+316 stdcall VarR4CmpR8(long double)
+317 stdcall VarR8Round(double long ptr)
+318 stdcall VarCat(ptr ptr ptr)
+319 stdcall VarDateFromUdateEx(ptr long long ptr)
+322 stdcall GetRecordInfoFromGuids(ptr long long long ptr ptr)
+323 stdcall GetRecordInfoFromTypeInfo(ptr ptr)
+325 stub SetVarConversionLocaleSetting
+326 stub GetVarConversionLocaleSetting
+327 stdcall SetOaNoCache()
+329 stdcall VarCyMulI8(long long long long ptr)
+330 stdcall VarDateFromUdate(ptr long ptr)
+331 stdcall VarUdateFromDate(double long ptr)
+332 stub GetAltMonthNames
+333 stdcall VarI8FromUI1(long long)
+334 stdcall VarI8FromI2(long long)
+335 stdcall VarI8FromR4(long long)
+336 stdcall VarI8FromR8(double long)
+337 stdcall VarI8FromCy(long long ptr)
+338 stdcall VarI8FromDate(double long)
+339 stdcall VarI8FromStr(wstr long long ptr)
+340 stdcall VarI8FromDisp(ptr long ptr)
+341 stdcall VarI8FromBool(long long)
+342 stdcall VarI8FromI1(long long)
+343 stdcall VarI8FromUI2(long long)
+344 stdcall VarI8FromUI4(long long)
+345 stdcall VarI8FromDec(ptr ptr)
+346 stdcall VarI2FromI8(long long ptr)
+347 stdcall VarI2FromUI8(long long ptr)
+348 stdcall VarI4FromI8(long long ptr)
+349 stdcall VarI4FromUI8(long long ptr)
+360 stdcall VarR4FromI8(long long ptr)
+361 stdcall VarR4FromUI8(long long ptr)
+362 stdcall VarR8FromI8(long long ptr)
+363 stdcall VarR8FromUI8(long long ptr)
+364 stdcall VarDateFromI8(long long ptr)
+365 stdcall VarDateFromUI8(long long ptr)
+366 stdcall VarCyFromI8(long long ptr)
+367 stdcall VarCyFromUI8(long long ptr)
+368 stdcall VarBstrFromI8(long long long long ptr)
+369 stdcall VarBstrFromUI8(long long long long ptr)
+370 stdcall VarBoolFromI8(long long ptr)
+371 stdcall VarBoolFromUI8(long long ptr)
+372 stdcall VarUI1FromI8(long long ptr)
+373 stdcall VarUI1FromUI8(long long ptr)
+374 stdcall VarDecFromI8(long long ptr)
+375 stdcall VarDecFromUI8(long long ptr)
+376 stdcall VarI1FromI8(long long ptr)
+377 stdcall VarI1FromUI8(long long ptr)
+378 stdcall VarUI2FromI8(long long ptr)
+379 stdcall VarUI2FromUI8(long long 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 long long long long ptr)
+402 stub OleLoadPictureFileEx
+411 stdcall SafeArrayCreateVector(long long long)
+412 stdcall SafeArrayCopyData(ptr ptr)
+413 stdcall VectorFromBstr(ptr ptr)
+414 stdcall BstrFromVector(ptr ptr)
+415 stdcall OleIconToCursor(long long)
+416 stdcall OleCreatePropertyFrameIndirect(ptr)
+417 stdcall OleCreatePropertyFrame(ptr long long ptr long ptr long ptr ptr long ptr)
+418 stdcall OleLoadPicture(ptr long long ptr ptr)
+419 stdcall OleCreatePictureIndirect(ptr ptr long ptr)
+420 stdcall OleCreateFontIndirect(ptr ptr ptr)
+421 stdcall OleTranslateColor(long long long)
+422 stub OleLoadPictureFile
+423 stub OleSavePictureFile
+424 stdcall OleLoadPicturePath(wstr ptr long long ptr ptr)
+425 stdcall VarUI4FromI8(long long ptr)
+426 stdcall VarUI4FromUI8(long long ptr)
+427 stdcall VarI8FromUI8(long long ptr)
+428 stdcall VarUI8FromI8(long long ptr)
+429 stdcall VarUI8FromUI1(long ptr)
+430 stdcall VarUI8FromI2(long ptr)
+431 stdcall VarUI8FromR4(long ptr)
+432 stdcall VarUI8FromR8(double ptr)
+433 stdcall VarUI8FromCy(long long ptr)
+434 stdcall VarUI8FromDate(double ptr)
+435 stdcall VarUI8FromStr(wstr long long ptr)
+436 stdcall VarUI8FromDisp(ptr long ptr)
+437 stdcall VarUI8FromBool(long ptr)
+438 stdcall VarUI8FromI1(long ptr)
+439 stdcall VarUI8FromUI2(long ptr)
+440 stdcall VarUI8FromUI4(long ptr)
+441 stdcall VarUI8FromDec(long ptr)
+
+@ stdcall -private DllCanUnloadNow()
+@ stdcall -private DllGetClassObject(ptr ptr ptr)
+@ stdcall -private DllRegisterServer()
+@ stdcall -private DllUnregisterServer()
index 0fce581..ca4fd1c 100644 (file)
@@ -63,12 +63,12 @@ struct OLEFontImpl
    * The first two are supported by the first vtable, the next two are
    * supported by the second table and the last two have their own.
    */
-  const IFontVtbl*                     lpvtbl1;
-  const IDispatchVtbl*                 lpvtbl2;
-  const IPersistStreamVtbl*            lpvtbl3;
-  const IConnectionPointContainerVtbl* lpvtbl4;
-  const IPersistPropertyBagVtbl*       lpvtbl5;
-  const IPersistStreamInitVtbl*        lpvtbl6;
+  const IFontVtbl*                     lpVtbl;
+  const IDispatchVtbl*                 lpvtblIDispatch;
+  const IPersistStreamVtbl*            lpvtblIPersistStream;
+  const IConnectionPointContainerVtbl* lpvtblIConnectionPointContainer;
+  const IPersistPropertyBagVtbl*       lpvtblIPersistPropertyBag;
+  const IPersistStreamInitVtbl*        lpvtblIPersistStreamInit;
   /*
    * Reference count for that instance of the class.
    */
@@ -104,11 +104,31 @@ struct OLEFontImpl
  * There is a version to accommodate all of the VTables implemented
  * by this object.
  */
-#define _ICOM_THIS_From_IDispatch(class, name) class* this = (class*)(((char*)name)-sizeof(void*))
-#define _ICOM_THIS_From_IPersistStream(class, name) class* this = (class*)(((char*)name)-2*sizeof(void*))
-#define _ICOM_THIS_From_IConnectionPointContainer(class, name) class* this = (class*)(((char*)name)-3*sizeof(void*))
-#define _ICOM_THIS_From_IPersistPropertyBag(class, name) class* this = (class*)(((char*)name)-4*sizeof(void*))
-#define _ICOM_THIS_From_IPersistStreamInit(class, name) class* this = (class*)(((char*)name)-5*sizeof(void*))
+
+static inline OLEFontImpl *impl_from_IDispatch( IDispatch *iface )
+{
+    return (OLEFontImpl *)((char*)iface - FIELD_OFFSET(OLEFontImpl, lpvtblIDispatch));
+}
+
+static inline OLEFontImpl *impl_from_IPersistStream( IPersistStream *iface )
+{
+    return (OLEFontImpl *)((char*)iface - FIELD_OFFSET(OLEFontImpl, lpvtblIPersistStream));
+}
+
+static inline OLEFontImpl *impl_from_IConnectionPointContainer( IConnectionPointContainer *iface )
+{
+    return (OLEFontImpl *)((char*)iface - FIELD_OFFSET(OLEFontImpl, lpvtblIConnectionPointContainer));
+}
+
+static inline OLEFontImpl *impl_from_IPersistPropertyBag( IPersistPropertyBag *iface )
+{
+    return (OLEFontImpl *)((char*)iface - FIELD_OFFSET(OLEFontImpl, lpvtblIPersistPropertyBag));
+}
+
+static inline OLEFontImpl *impl_from_IPersistStreamInit( IPersistStreamInit *iface )
+{
+    return (OLEFontImpl *)((char*)iface - FIELD_OFFSET(OLEFontImpl, lpvtblIPersistStreamInit));
+}
 
 
 /***********************************************************************
@@ -402,12 +422,12 @@ static OLEFontImpl* OLEFontImpl_Construct(LPFONTDESC fontDesc)
   /*
    * Initialize the virtual function table.
    */
-  newObject->lpvtbl1 = &OLEFontImpl_VTable;
-  newObject->lpvtbl2 = &OLEFontImpl_IDispatch_VTable;
-  newObject->lpvtbl3 = &OLEFontImpl_IPersistStream_VTable;
-  newObject->lpvtbl4 = &OLEFontImpl_IConnectionPointContainer_VTable;
-  newObject->lpvtbl5 = &OLEFontImpl_IPersistPropertyBag_VTable;
-  newObject->lpvtbl6 = &OLEFontImpl_IPersistStreamInit_VTable;
+  newObject->lpVtbl = &OLEFontImpl_VTable;
+  newObject->lpvtblIDispatch = &OLEFontImpl_IDispatch_VTable;
+  newObject->lpvtblIPersistStream = &OLEFontImpl_IPersistStream_VTable;
+  newObject->lpvtblIConnectionPointContainer = &OLEFontImpl_IConnectionPointContainer_VTable;
+  newObject->lpvtblIPersistPropertyBag = &OLEFontImpl_IPersistPropertyBag_VTable;
+  newObject->lpvtblIPersistStreamInit = &OLEFontImpl_IPersistStreamInit_VTable;
 
   /*
    * Start with one reference count. The caller of this function
@@ -495,17 +515,17 @@ HRESULT WINAPI OLEFontImpl_QueryInterface(
   if (IsEqualGUID(&IID_IFont, riid))
     *ppvObject = (IFont*)this;
   if (IsEqualGUID(&IID_IDispatch, riid))
-    *ppvObject = (IDispatch*)&(this->lpvtbl2);
+    *ppvObject = (IDispatch*)&(this->lpvtblIDispatch);
   if (IsEqualGUID(&IID_IFontDisp, riid))
-    *ppvObject = (IDispatch*)&(this->lpvtbl2);
+    *ppvObject = (IDispatch*)&(this->lpvtblIDispatch);
   if (IsEqualGUID(&IID_IPersistStream, riid))
-    *ppvObject = (IPersistStream*)&(this->lpvtbl3);
+    *ppvObject = (IPersistStream*)&(this->lpvtblIPersistStream);
   if (IsEqualGUID(&IID_IConnectionPointContainer, riid))
-    *ppvObject = (IConnectionPointContainer*)&(this->lpvtbl4);
+    *ppvObject = (IConnectionPointContainer*)&(this->lpvtblIConnectionPointContainer);
   if (IsEqualGUID(&IID_IPersistPropertyBag, riid))
-    *ppvObject = (IPersistPropertyBag*)&(this->lpvtbl5);
+    *ppvObject = (IPersistPropertyBag*)&(this->lpvtblIPersistPropertyBag);
   if (IsEqualGUID(&IID_IPersistStreamInit, riid))
-    *ppvObject = (IPersistStreamInit*)&(this->lpvtbl6);
+    *ppvObject = (IPersistStreamInit*)&(this->lpvtblIPersistStreamInit);
 
   /*
    * Check that we obtained an interface.
@@ -933,7 +953,9 @@ static HRESULT WINAPI OLEFontImpl_get_hFont(
      */
     IFont_get_Size(iface, &cySize);
 
-    fontHeight = MulDiv( cySize.s.Lo, this->cyLogical, this->cyHimetric );
+    /* Standard ratio is 72 / 2540, or 18 / 635 in lowest terms. */
+    /* Ratio is applied here relative to the standard. */
+    fontHeight = MulDiv( cySize.s.Lo, this->cyLogical*635, this->cyHimetric*18 );
 
     memset(&logFont, 0, sizeof(LOGFONTW));
 
@@ -1000,7 +1022,7 @@ static HRESULT WINAPI OLEFontImpl_Clone(
   /* We need to clone the HFONT too. This is just cut & paste from above */
   IFont_get_Size(iface, &cySize);
 
-  fontHeight = MulDiv(cySize.s.Lo, this->cyLogical,this->cyHimetric);
+  fontHeight = MulDiv(cySize.s.Lo, this->cyLogical*635,this->cyHimetric*18);
 
   memset(&logFont, 0, sizeof(LOGFONTW));
 
@@ -1156,9 +1178,9 @@ static HRESULT WINAPI OLEFontImpl_IDispatch_QueryInterface(
   REFIID     riid,
   VOID**     ppvoid)
 {
-  _ICOM_THIS_From_IDispatch(IFont, iface);
+  OLEFontImpl *this = impl_from_IDispatch(iface);
 
-  return IFont_QueryInterface(this, riid, ppvoid);
+  return IFont_QueryInterface((IFont *)this, riid, ppvoid);
 }
 
 /************************************************************************
@@ -1169,9 +1191,9 @@ static HRESULT WINAPI OLEFontImpl_IDispatch_QueryInterface(
 static ULONG WINAPI OLEFontImpl_IDispatch_Release(
   IDispatch* iface)
 {
-  _ICOM_THIS_From_IDispatch(IFont, iface);
+  OLEFontImpl *this = impl_from_IDispatch(iface);
 
-  return IFont_Release(this);
+  return IFont_Release((IFont *)this);
 }
 
 /************************************************************************
@@ -1182,9 +1204,9 @@ static ULONG WINAPI OLEFontImpl_IDispatch_Release(
 static ULONG WINAPI OLEFontImpl_IDispatch_AddRef(
   IDispatch* iface)
 {
-  _ICOM_THIS_From_IDispatch(IFont, iface);
+  OLEFontImpl *this = impl_from_IDispatch(iface);
 
-  return IFont_AddRef(this);
+  return IFont_AddRef((IFont *)this);
 }
 
 /************************************************************************
@@ -1196,7 +1218,7 @@ static HRESULT WINAPI OLEFontImpl_GetTypeInfoCount(
   IDispatch*    iface,
   unsigned int* pctinfo)
 {
-  _ICOM_THIS_From_IDispatch(IFont, iface);
+  OLEFontImpl *this = impl_from_IDispatch(iface);
   FIXME("(%p)->(%p): Stub\n", this, pctinfo);
 
   return E_NOTIMPL;
@@ -1217,7 +1239,7 @@ static HRESULT WINAPI OLEFontImpl_GetTypeInfo(
   ITypeLib *tl;
   HRESULT hres;
 
-  _ICOM_THIS_From_IDispatch(OLEFontImpl, iface);
+  OLEFontImpl *this = impl_from_IDispatch(iface);
   TRACE("(%p, iTInfo=%d, lcid=%04x, %p)\n", this, iTInfo, (int)lcid, ppTInfo);
   if (iTInfo != 0)
     return E_FAIL;
@@ -1246,7 +1268,7 @@ static HRESULT WINAPI OLEFontImpl_GetIDsOfNames(
   LCID        lcid,
   DISPID*     rgDispId)
 {
-  _ICOM_THIS_From_IDispatch(IFont, iface);
+  OLEFontImpl *this = impl_from_IDispatch(iface);
   FIXME("(%p,%s,%p,%d,%04x,%p), stub!\n", this, debugstr_guid(riid), rgszNames,
        cNames, (int)lcid, rgDispId
   );
@@ -1273,7 +1295,7 @@ static HRESULT WINAPI OLEFontImpl_Invoke(
   EXCEPINFO*  pExepInfo,
   UINT*     puArgErr)
 {
-  _ICOM_THIS_From_IDispatch(IFont, iface);
+  OLEFontImpl *this = impl_from_IDispatch(iface);
   OLEFontImpl *xthis = (OLEFontImpl*)this;
 
   switch (dispIdMember) {
@@ -1282,7 +1304,7 @@ static HRESULT WINAPI OLEFontImpl_Invoke(
     case DISPATCH_PROPERTYGET:
     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
       V_VT(pVarResult) = VT_BSTR;
-      return OLEFontImpl_get_Name(this, &V_BSTR(pVarResult));
+      return OLEFontImpl_get_Name((IFont *)this, &V_BSTR(pVarResult));
     case DISPATCH_PROPERTYPUT: {
       BSTR name;
       BOOL freename;
@@ -1334,7 +1356,7 @@ static HRESULT WINAPI OLEFontImpl_Invoke(
     case DISPATCH_PROPERTYGET:
     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
       V_VT(pVarResult) = VT_BOOL;
-      return OLEFontImpl_get_Bold(this, (BOOL*)&V_BOOL(pVarResult));
+      return OLEFontImpl_get_Bold((IFont *)this, (BOOL*)&V_BOOL(pVarResult));
     case DISPATCH_PROPERTYPUT:
       if (V_VT(&pDispParams->rgvarg[0]) != VT_BOOL) {
        FIXME("DISPID_FONT_BOLD/put, vt is %d, not VT_BOOL.\n",V_VT(&pDispParams->rgvarg[0]));
@@ -1350,7 +1372,7 @@ static HRESULT WINAPI OLEFontImpl_Invoke(
     case DISPATCH_PROPERTYGET:
     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
       V_VT(pVarResult) = VT_BOOL;
-      return OLEFontImpl_get_Italic(this, (BOOL*)&V_BOOL(pVarResult));
+      return OLEFontImpl_get_Italic((IFont *)this, (BOOL*)&V_BOOL(pVarResult));
     case DISPATCH_PROPERTYPUT:
       if (V_VT(&pDispParams->rgvarg[0]) != VT_BOOL) {
        FIXME("DISPID_FONT_ITALIC/put, vt is %d, not VT_BOOL.\n",V_VT(&pDispParams->rgvarg[0]));
@@ -1366,7 +1388,7 @@ static HRESULT WINAPI OLEFontImpl_Invoke(
     case DISPATCH_PROPERTYGET:
     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
       V_VT(pVarResult) = VT_BOOL;
-      return OLEFontImpl_get_Underline(this, (BOOL*)&V_BOOL(pVarResult));
+      return OLEFontImpl_get_Underline((IFont *)this, (BOOL*)&V_BOOL(pVarResult));
     case DISPATCH_PROPERTYPUT:
       if (V_VT(&pDispParams->rgvarg[0]) != VT_BOOL) {
        FIXME("DISPID_FONT_UNDER/put, vt is %d, not VT_BOOL.\n",V_VT(&pDispParams->rgvarg[0]));
@@ -1382,7 +1404,7 @@ static HRESULT WINAPI OLEFontImpl_Invoke(
     case DISPATCH_PROPERTYGET:
     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
       V_VT(pVarResult) = VT_BOOL;
-      return OLEFontImpl_get_Strikethrough(this, (BOOL*)&V_BOOL(pVarResult));
+      return OLEFontImpl_get_Strikethrough((IFont *)this, (BOOL*)&V_BOOL(pVarResult));
     case DISPATCH_PROPERTYPUT:
       if (V_VT(&pDispParams->rgvarg[0]) != VT_BOOL) {
        FIXME("DISPID_FONT_STRIKE/put, vt is %d, not VT_BOOL.\n",V_VT(&pDispParams->rgvarg[0]));
@@ -1412,7 +1434,7 @@ static HRESULT WINAPI OLEFontImpl_Invoke(
     case DISPATCH_PROPERTYGET:
     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
       V_VT(pVarResult) = VT_CY;
-      return OLEFontImpl_get_Size(this, &V_CY(pVarResult));
+      return OLEFontImpl_get_Size((IFont *)this, &V_CY(pVarResult));
     }
     break;
   case DISPID_FONT_CHARSET:
@@ -1426,7 +1448,7 @@ static HRESULT WINAPI OLEFontImpl_Invoke(
     case DISPATCH_PROPERTYGET:
     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
       V_VT(pVarResult) = VT_I2;
-      return OLEFontImpl_get_Charset(this, &V_I2(pVarResult));
+      return OLEFontImpl_get_Charset((IFont *)this, &V_I2(pVarResult));
     }
     break;
   }
@@ -1447,9 +1469,9 @@ static HRESULT WINAPI OLEFontImpl_IPersistStream_QueryInterface(
   REFIID     riid,
   VOID**     ppvoid)
 {
-  _ICOM_THIS_From_IPersistStream(IFont, iface);
+  OLEFontImpl *this = impl_from_IPersistStream(iface);
 
-  return IFont_QueryInterface(this, riid, ppvoid);
+  return IFont_QueryInterface((IFont *)this, riid, ppvoid);
 }
 
 /************************************************************************
@@ -1460,9 +1482,9 @@ static HRESULT WINAPI OLEFontImpl_IPersistStream_QueryInterface(
 static ULONG WINAPI OLEFontImpl_IPersistStream_Release(
   IPersistStream* iface)
 {
-  _ICOM_THIS_From_IPersistStream(IFont, iface);
+  OLEFontImpl *this = impl_from_IPersistStream(iface);
 
-  return IFont_Release(this);
+  return IFont_Release((IFont *)this);
 }
 
 /************************************************************************
@@ -1473,9 +1495,9 @@ static ULONG WINAPI OLEFontImpl_IPersistStream_Release(
 static ULONG WINAPI OLEFontImpl_IPersistStream_AddRef(
   IPersistStream* iface)
 {
-  _ICOM_THIS_From_IPersistStream(IFont, iface);
+  OLEFontImpl *this = impl_from_IPersistStream(iface);
 
-  return IFont_AddRef(this);
+  return IFont_AddRef((IFont *)this);
 }
 
 /************************************************************************
@@ -1540,7 +1562,7 @@ static HRESULT WINAPI OLEFontImpl_Load(
   BYTE  bStringSize;
   INT len;
 
-  _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
+  OLEFontImpl *this = impl_from_IPersistStream(iface);
 
   /*
    * Read the version byte
@@ -1632,7 +1654,7 @@ static HRESULT WINAPI OLEFontImpl_Save(
   BYTE  bAttributes;
   BYTE  bStringSize;
 
-  _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
+  OLEFontImpl *this = impl_from_IPersistStream(iface);
 
   /*
    * Read the version byte
@@ -1725,7 +1747,7 @@ static HRESULT WINAPI OLEFontImpl_GetSizeMax(
   IPersistStream*  iface,
   ULARGE_INTEGER*  pcbSize)
 {
-  _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
+  OLEFontImpl *this = impl_from_IPersistStream(iface);
 
   if (pcbSize==NULL)
     return E_POINTER;
@@ -1756,7 +1778,7 @@ static HRESULT WINAPI OLEFontImpl_IConnectionPointContainer_QueryInterface(
   REFIID     riid,
   VOID**     ppvoid)
 {
-  _ICOM_THIS_From_IConnectionPointContainer(OLEFontImpl, iface);
+  OLEFontImpl *this = impl_from_IConnectionPointContainer(iface);
 
   return IFont_QueryInterface((IFont*)this, riid, ppvoid);
 }
@@ -1769,7 +1791,7 @@ static HRESULT WINAPI OLEFontImpl_IConnectionPointContainer_QueryInterface(
 static ULONG WINAPI OLEFontImpl_IConnectionPointContainer_Release(
   IConnectionPointContainer* iface)
 {
-  _ICOM_THIS_From_IConnectionPointContainer(OLEFontImpl, iface);
+  OLEFontImpl *this = impl_from_IConnectionPointContainer(iface);
 
   return IFont_Release((IFont*)this);
 }
@@ -1782,7 +1804,7 @@ static ULONG WINAPI OLEFontImpl_IConnectionPointContainer_Release(
 static ULONG WINAPI OLEFontImpl_IConnectionPointContainer_AddRef(
   IConnectionPointContainer* iface)
 {
-  _ICOM_THIS_From_IConnectionPointContainer(OLEFontImpl, iface);
+  OLEFontImpl *this = impl_from_IConnectionPointContainer(iface);
 
   return IFont_AddRef((IFont*)this);
 }
@@ -1797,7 +1819,7 @@ static HRESULT WINAPI OLEFontImpl_EnumConnectionPoints(
   IConnectionPointContainer* iface,
   IEnumConnectionPoints **ppEnum)
 {
-  _ICOM_THIS_From_IConnectionPointContainer(OLEFontImpl, iface);
+  OLEFontImpl *this = impl_from_IConnectionPointContainer(iface);
 
   FIXME("(%p)->(%p): stub\n", this, ppEnum);
   return E_NOTIMPL;
@@ -1814,7 +1836,7 @@ static HRESULT WINAPI OLEFontImpl_FindConnectionPoint(
    REFIID riid,
    IConnectionPoint **ppCp)
 {
-  _ICOM_THIS_From_IConnectionPointContainer(OLEFontImpl, iface);
+  OLEFontImpl *this = impl_from_IConnectionPointContainer(iface);
   TRACE("(%p)->(%s, %p): stub\n", this, debugstr_guid(riid), ppCp);
 
   if(memcmp(riid, &IID_IPropertyNotifySink, sizeof(IID_IPropertyNotifySink)) == 0) {
@@ -1832,22 +1854,22 @@ static HRESULT WINAPI OLEFontImpl_FindConnectionPoint(
 static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_QueryInterface(
    IPersistPropertyBag *iface, REFIID riid, LPVOID *ppvObj
 ) {
-  _ICOM_THIS_From_IPersistPropertyBag(IFont, iface);
-  return IFont_QueryInterface(this,riid,ppvObj);
+  OLEFontImpl *this = impl_from_IPersistPropertyBag(iface);
+  return IFont_QueryInterface((IFont *)this,riid,ppvObj);
 }
 
 static ULONG WINAPI OLEFontImpl_IPersistPropertyBag_AddRef(
    IPersistPropertyBag *iface
 ) {
-  _ICOM_THIS_From_IPersistPropertyBag(IFont, iface);
-  return IFont_AddRef(this);
+  OLEFontImpl *this = impl_from_IPersistPropertyBag(iface);
+  return IFont_AddRef((IFont *)this);
 }
 
 static ULONG WINAPI OLEFontImpl_IPersistPropertyBag_Release(
    IPersistPropertyBag *iface
 ) {
-  _ICOM_THIS_From_IPersistPropertyBag(IFont, iface);
-  return IFont_Release(this);
+  OLEFontImpl *this = impl_from_IPersistPropertyBag(iface);
+  return IFont_Release((IFont *)this);
 }
 
 static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_GetClassID(
@@ -1886,7 +1908,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
     VARIANT rawAttr;
     VARIANT valueAttr;
     HRESULT iRes = S_OK;
-    _ICOM_THIS_From_IPersistPropertyBag(IFont, iface);
+    OLEFontImpl *this = impl_from_IPersistPropertyBag(iface);
 
     VariantInit(&rawAttr);
     VariantInit(&valueAttr);
@@ -1897,7 +1919,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
         {
             iRes = VariantChangeType(&rawAttr, &valueAttr, 0, VT_BSTR);
             if (iRes == S_OK)
-                iRes = IFont_put_Name(this, V_BSTR(&valueAttr));
+                iRes = IFont_put_Name((IFont *)this, V_BSTR(&valueAttr));
         }
         else if (iRes == E_INVALIDARG)
             iRes = S_OK;
@@ -1911,7 +1933,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
         {
             iRes = VariantChangeType(&rawAttr, &valueAttr, 0, VT_CY);
             if (iRes == S_OK)
-                iRes = IFont_put_Size(this, V_CY(&valueAttr));
+                iRes = IFont_put_Size((IFont *)this, V_CY(&valueAttr));
         }
         else if (iRes == E_INVALIDARG)
             iRes = S_OK;
@@ -1925,7 +1947,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
         {
             iRes = VariantChangeType(&rawAttr, &valueAttr, 0, VT_I2);
             if (iRes == S_OK)
-                iRes = IFont_put_Charset(this, V_I2(&valueAttr));
+                iRes = IFont_put_Charset((IFont *)this, V_I2(&valueAttr));
         }
         else if (iRes == E_INVALIDARG)
             iRes = S_OK;
@@ -1939,7 +1961,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
         {
             iRes = VariantChangeType(&rawAttr, &valueAttr, 0, VT_I2);
             if (iRes == S_OK)
-                iRes = IFont_put_Weight(this, V_I2(&valueAttr));
+                iRes = IFont_put_Weight((IFont *)this, V_I2(&valueAttr));
         }
         else if (iRes == E_INVALIDARG)
             iRes = S_OK;
@@ -1954,7 +1976,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
         {
             iRes = VariantChangeType(&rawAttr, &valueAttr, 0, VT_BOOL);
             if (iRes == S_OK)
-                iRes = IFont_put_Underline(this, V_BOOL(&valueAttr));
+                iRes = IFont_put_Underline((IFont *)this, V_BOOL(&valueAttr));
         }
         else if (iRes == E_INVALIDARG)
             iRes = S_OK;
@@ -1968,7 +1990,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
         {
             iRes = VariantChangeType(&rawAttr, &valueAttr, 0, VT_BOOL);
             if (iRes == S_OK)
-                iRes = IFont_put_Italic(this, V_BOOL(&valueAttr));
+                iRes = IFont_put_Italic((IFont *)this, V_BOOL(&valueAttr));
         }
         else if (iRes == E_INVALIDARG)
             iRes = S_OK;
@@ -1982,7 +2004,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
         {
             iRes = VariantChangeType(&rawAttr, &valueAttr, 0, VT_BOOL);
             if (iRes == S_OK)
-                IFont_put_Strikethrough(this, V_BOOL(&valueAttr));
+                IFont_put_Strikethrough((IFont *)this, V_BOOL(&valueAttr));
         }
         else if (iRes == E_INVALIDARG)
             iRes = S_OK;
@@ -2021,22 +2043,22 @@ static const IPersistPropertyBagVtbl OLEFontImpl_IPersistPropertyBag_VTable =
 static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_QueryInterface(
    IPersistStreamInit *iface, REFIID riid, LPVOID *ppvObj
 ) {
-  _ICOM_THIS_From_IPersistStreamInit(IFont, iface);
-  return IFont_QueryInterface(this,riid,ppvObj);
+  OLEFontImpl *this = impl_from_IPersistStreamInit(iface);
+  return IFont_QueryInterface((IFont *)this,riid,ppvObj);
 }
 
 static ULONG WINAPI OLEFontImpl_IPersistStreamInit_AddRef(
    IPersistStreamInit *iface
 ) {
-  _ICOM_THIS_From_IPersistStreamInit(IFont, iface);
-  return IFont_AddRef(this);
+  OLEFontImpl *this = impl_from_IPersistStreamInit(iface);
+  return IFont_AddRef((IFont *)this);
 }
 
 static ULONG WINAPI OLEFontImpl_IPersistStreamInit_Release(
    IPersistStreamInit *iface
 ) {
-  _ICOM_THIS_From_IPersistStreamInit(IFont, iface);
-  return IFont_Release(this);
+  OLEFontImpl *this = impl_from_IPersistStreamInit(iface);
+  return IFont_Release((IFont *)this);
 }
 
 static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_GetClassID(
index 171ee03..e1e4024 100644 (file)
@@ -125,10 +125,10 @@ typedef struct OLEPictureImpl {
    * IPicture handles IUnknown
    */
 
-    const IPictureVtbl       *lpvtbl1;
-    const IDispatchVtbl      *lpvtbl2;
-    const IPersistStreamVtbl *lpvtbl3;
-    const IConnectionPointContainerVtbl *lpvtbl4;
+    const IPictureVtbl       *lpVtbl;
+    const IDispatchVtbl      *lpvtblIDispatch;
+    const IPersistStreamVtbl *lpvtblIPersistStream;
+    const IConnectionPointContainerVtbl *lpvtblIConnectionPointContainer;
 
   /* Object reference count */
     LONG ref;
@@ -168,12 +168,21 @@ typedef struct OLEPictureImpl {
 /*
  * Macros to retrieve pointer to IUnknown (IPicture) from the other VTables.
  */
-#define ICOM_THIS_From_IDispatch(impl, name) \
-    impl *This = (impl*)(((char*)name)-sizeof(void*));
-#define ICOM_THIS_From_IPersistStream(impl, name) \
-    impl *This = (impl*)(((char*)name)-2*sizeof(void*));
-#define ICOM_THIS_From_IConnectionPointContainer(impl, name) \
-    impl *This = (impl*)(((char*)name)-3*sizeof(void*));
+
+static inline OLEPictureImpl *impl_from_IDispatch( IDispatch *iface )
+{
+    return (OLEPictureImpl *)((char*)iface - FIELD_OFFSET(OLEPictureImpl, lpvtblIDispatch));
+}
+
+static inline OLEPictureImpl *impl_from_IPersistStream( IPersistStream *iface )
+{
+    return (OLEPictureImpl *)((char*)iface - FIELD_OFFSET(OLEPictureImpl, lpvtblIPersistStream));
+}
+
+static inline OLEPictureImpl *impl_from_IConnectionPointContainer( IConnectionPointContainer *iface )
+{
+    return (OLEPictureImpl *)((char*)iface - FIELD_OFFSET(OLEPictureImpl, lpvtblIConnectionPointContainer));
+}
 
 /*
  * Predeclare VTables.  They get initialized at the end.
@@ -265,10 +274,10 @@ static OLEPictureImpl* OLEPictureImpl_Construct(LPPICTDESC pictDesc, BOOL fOwn)
   /*
    * Initialize the virtual function table.
    */
-  newObject->lpvtbl1 = &OLEPictureImpl_VTable;
-  newObject->lpvtbl2 = &OLEPictureImpl_IDispatch_VTable;
-  newObject->lpvtbl3 = &OLEPictureImpl_IPersistStream_VTable;
-  newObject->lpvtbl4 = &OLEPictureImpl_IConnectionPointContainer_VTable;
+  newObject->lpVtbl = &OLEPictureImpl_VTable;
+  newObject->lpvtblIDispatch = &OLEPictureImpl_IDispatch_VTable;
+  newObject->lpvtblIPersistStream = &OLEPictureImpl_IPersistStream_VTable;
+  newObject->lpvtblIConnectionPointContainer = &OLEPictureImpl_IConnectionPointContainer_VTable;
 
   CreateConnectionPoint((IUnknown*)newObject,&IID_IPropertyNotifySink,&newObject->pCP);
 
@@ -407,19 +416,19 @@ static HRESULT WINAPI OLEPictureImpl_QueryInterface(
   }
   else if (memcmp(&IID_IDispatch, riid, sizeof(IID_IDispatch)) == 0)
   {
-    *ppvObject = (IDispatch*)&(This->lpvtbl2);
+    *ppvObject = (IDispatch*)&(This->lpvtblIDispatch);
   }
   else if (memcmp(&IID_IPictureDisp, riid, sizeof(IID_IPictureDisp)) == 0)
   {
-    *ppvObject = (IDispatch*)&(This->lpvtbl2);
+    *ppvObject = (IDispatch*)&(This->lpvtblIDispatch);
   }
   else if (memcmp(&IID_IPersistStream, riid, sizeof(IID_IPersistStream)) == 0)
   {
-  *ppvObject = (IPersistStream*)&(This->lpvtbl3);
+  *ppvObject = (IPersistStream*)&(This->lpvtblIPersistStream);
   }
   else if (memcmp(&IID_IConnectionPointContainer, riid, sizeof(IID_IConnectionPointContainer)) == 0)
   {
-  *ppvObject = (IConnectionPointContainer*)&(This->lpvtbl4);
+  *ppvObject = (IConnectionPointContainer*)&(This->lpvtblIConnectionPointContainer);
   }
   /*
    * Check that we obtained an interface.
@@ -540,10 +549,34 @@ static HRESULT WINAPI OLEPictureImpl_get_hPal(IPicture *iface,
                                              OLE_HANDLE *phandle)
 {
   OLEPictureImpl *This = (OLEPictureImpl *)iface;
-  FIXME("(%p)->(%p): stub, return 0 palette.\n", This, phandle);
+  HRESULT hres;
+  TRACE("(%p)->(%p)\n", This, phandle);
 
-  *phandle = 0;
-  return S_OK;
+  if (!phandle)
+    return E_POINTER;
+
+  switch (This->desc.picType) {
+    case PICTYPE_UNINITIALIZED:
+    case PICTYPE_NONE:
+      *phandle = 0;
+      hres = S_FALSE;
+      break;
+    case PICTYPE_BITMAP:
+      *phandle = (OLE_HANDLE)This->desc.u.bmp.hpal;
+      hres = S_OK;
+      break;
+    case PICTYPE_ICON:
+    case PICTYPE_METAFILE:
+    case PICTYPE_ENHMETAFILE:
+    default:
+      FIXME("unimplemented for type %d. Returning 0 palette.\n",
+           This->desc.picType);
+      *phandle = 0;
+      hres = S_OK;
+  }
+
+  TRACE("returning 0x%08lx, palette handle %08x\n", hres, *phandle);
+  return hres;
 }
 
 /************************************************************************
@@ -791,34 +824,34 @@ static HRESULT WINAPI OLEPictureImpl_get_Attributes(IPicture *iface,
 static HRESULT WINAPI OLEPictureImpl_IConnectionPointContainer_QueryInterface(
   IConnectionPointContainer* iface,
   REFIID riid,
-  VOID** ppvoid
-{
-  ICOM_THIS_From_IConnectionPointContainer(IPicture,iface);
+  VOID** ppvoid)
+{
+  OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 
-  return IPicture_QueryInterface(This,riid,ppvoid);
+  return IPicture_QueryInterface((IPicture *)This,riid,ppvoid);
 }
 
 static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_AddRef(
   IConnectionPointContainer* iface)
 {
-  ICOM_THIS_From_IConnectionPointContainer(IPicture, iface);
+  OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 
-  return IPicture_AddRef(This);
+  return IPicture_AddRef((IPicture *)This);
 }
 
 static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_Release(
   IConnectionPointContainer* iface)
 {
-  ICOM_THIS_From_IConnectionPointContainer(IPicture, iface);
+  OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 
-  return IPicture_Release(This);
+  return IPicture_Release((IPicture *)This);
 }
 
 static HRESULT WINAPI OLEPictureImpl_EnumConnectionPoints(
   IConnectionPointContainer* iface,
-  IEnumConnectionPoints** ppEnum
-{
-  ICOM_THIS_From_IConnectionPointContainer(IPicture, iface);
+  IEnumConnectionPoints** ppEnum)
+{
+  OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 
   FIXME("(%p,%p), stub!\n",This,ppEnum);
   return E_NOTIMPL;
@@ -827,9 +860,9 @@ static HRESULT WINAPI OLEPictureImpl_EnumConnectionPoints(
 static HRESULT WINAPI OLEPictureImpl_FindConnectionPoint(
   IConnectionPointContainer* iface,
   REFIID riid,
-  IConnectionPoint **ppCP
-{
-  ICOM_THIS_From_IConnectionPointContainer(OLEPictureImpl, iface);
+  IConnectionPoint **ppCP)
+{
+  OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
   TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppCP);
   if (!ppCP)
       return E_POINTER;
@@ -852,9 +885,9 @@ static HRESULT WINAPI OLEPictureImpl_IPersistStream_QueryInterface(
   REFIID     riid,
   VOID**     ppvoid)
 {
-  ICOM_THIS_From_IPersistStream(IPicture, iface);
+  OLEPictureImpl *This = impl_from_IPersistStream(iface);
 
-  return IPicture_QueryInterface(This, riid, ppvoid);
+  return IPicture_QueryInterface((IPicture *)This, riid, ppvoid);
 }
 
 /************************************************************************
@@ -865,9 +898,9 @@ static HRESULT WINAPI OLEPictureImpl_IPersistStream_QueryInterface(
 static ULONG WINAPI OLEPictureImpl_IPersistStream_AddRef(
   IPersistStream* iface)
 {
-  ICOM_THIS_From_IPersistStream(IPicture, iface);
+  OLEPictureImpl *This = impl_from_IPersistStream(iface);
 
-  return IPicture_AddRef(This);
+  return IPicture_AddRef((IPicture *)This);
 }
 
 /************************************************************************
@@ -878,9 +911,9 @@ static ULONG WINAPI OLEPictureImpl_IPersistStream_AddRef(
 static ULONG WINAPI OLEPictureImpl_IPersistStream_Release(
   IPersistStream* iface)
 {
-  ICOM_THIS_From_IPersistStream(IPicture, iface);
+  OLEPictureImpl *This = impl_from_IPersistStream(iface);
 
-  return IPicture_Release(This);
+  return IPicture_Release((IPicture *)This);
 }
 
 /************************************************************************
@@ -889,7 +922,7 @@ static ULONG WINAPI OLEPictureImpl_IPersistStream_Release(
 static HRESULT WINAPI OLEPictureImpl_GetClassID(
   IPersistStream* iface,CLSID* pClassID)
 {
-  ICOM_THIS_From_IPersistStream(IPicture, iface);
+  OLEPictureImpl *This = impl_from_IPersistStream(iface);
   FIXME("(%p),stub!\n",This);
   return E_FAIL;
 }
@@ -900,7 +933,7 @@ static HRESULT WINAPI OLEPictureImpl_GetClassID(
 static HRESULT WINAPI OLEPictureImpl_IsDirty(
   IPersistStream* iface)
 {
-  ICOM_THIS_From_IPersistStream(IPicture, iface);
+  OLEPictureImpl *This = impl_from_IPersistStream(iface);
   FIXME("(%p),stub!\n",This);
   return E_NOTIMPL;
 }
@@ -1028,7 +1061,7 @@ static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface,IStream*pStm) {
   DWORD                header[2];
   WORD         magic;
   STATSTG       statstg;
-  ICOM_THIS_From_IPersistStream(OLEPictureImpl, iface);
+  OLEPictureImpl *This = impl_from_IPersistStream(iface);
   
   TRACE("(%p,%p)\n",This,pStm);
 
@@ -1519,7 +1552,7 @@ static HRESULT WINAPI OLEPictureImpl_Save(
     ULONG dummy;
     int iSerializeResult = 0;
 
-  ICOM_THIS_From_IPersistStream(OLEPictureImpl, iface);
+  OLEPictureImpl *This = impl_from_IPersistStream(iface);
 
     switch (This->desc.picType) {
     case PICTYPE_ICON:
@@ -1837,7 +1870,7 @@ static int serializeIcon(HICON hIcon, void ** ppBuffer, unsigned int * pLength)
 static HRESULT WINAPI OLEPictureImpl_GetSizeMax(
   IPersistStream* iface,ULARGE_INTEGER*pcbSize)
 {
-  ICOM_THIS_From_IPersistStream(IPicture, iface);
+  OLEPictureImpl *This = impl_from_IPersistStream(iface);
   FIXME("(%p,%p),stub!\n",This,pcbSize);
   return E_NOTIMPL;
 }
@@ -1855,9 +1888,9 @@ static HRESULT WINAPI OLEPictureImpl_IDispatch_QueryInterface(
   REFIID     riid,
   VOID**     ppvoid)
 {
-  ICOM_THIS_From_IDispatch(IPicture, iface);
+  OLEPictureImpl *This = impl_from_IDispatch(iface);
 
-  return IPicture_QueryInterface(This, riid, ppvoid);
+  return IPicture_QueryInterface((IPicture *)This, riid, ppvoid);
 }
 
 /************************************************************************
@@ -1868,9 +1901,9 @@ static HRESULT WINAPI OLEPictureImpl_IDispatch_QueryInterface(
 static ULONG WINAPI OLEPictureImpl_IDispatch_AddRef(
   IDispatch* iface)
 {
-  ICOM_THIS_From_IDispatch(IPicture, iface);
+  OLEPictureImpl *This = impl_from_IDispatch(iface);
 
-  return IPicture_AddRef(This);
+  return IPicture_AddRef((IPicture *)This);
 }
 
 /************************************************************************
@@ -1881,9 +1914,9 @@ static ULONG WINAPI OLEPictureImpl_IDispatch_AddRef(
 static ULONG WINAPI OLEPictureImpl_IDispatch_Release(
   IDispatch* iface)
 {
-  ICOM_THIS_From_IDispatch(IPicture, iface);
+  OLEPictureImpl *This = impl_from_IDispatch(iface);
 
-  return IPicture_Release(This);
+  return IPicture_Release((IPicture *)This);
 }
 
 /************************************************************************
index daa9d55..9ab5fd4 100644 (file)
@@ -901,7 +901,7 @@ static struct regsvr_interface const interface_list[] = {
 };
 
 /***********************************************************************
- *             DllRegisterServer (OLEAUT32.320)
+ *             DllRegisterServer (OLEAUT32.@)
  */
 HRESULT WINAPI DllRegisterServer(void)
 {
@@ -916,7 +916,7 @@ HRESULT WINAPI DllRegisterServer(void)
 }
 
 /***********************************************************************
- *             DllUnregisterServer (OLEAUT32.321)
+ *             DllUnregisterServer (OLEAUT32.@)
  */
 HRESULT WINAPI DllUnregisterServer(void)
 {
index e984895..b84226b 100644 (file)
@@ -789,12 +789,12 @@ HRESULT WINAPI SafeArrayLock(SAFEARRAY *psa)
   if (!psa)
     return E_INVALIDARG;
 
-  ulLocks = InterlockedIncrement(&psa->cLocks);
+  ulLocks = InterlockedIncrement( (LONG*) &psa->cLocks);
 
   if (ulLocks > 0xffff) /* Maximum of 16384 locks at a time */
   {
     WARN("Out of locks!\n");
-    InterlockedDecrement(&psa->cLocks);
+    InterlockedDecrement( (LONG*) &psa->cLocks);
     return E_UNEXPECTED;
   }
   return S_OK;
@@ -823,10 +823,10 @@ HRESULT WINAPI SafeArrayUnlock(SAFEARRAY *psa)
   if (!psa)
     return E_INVALIDARG;
 
-  if ((LONG)InterlockedDecrement(&psa->cLocks) < 0)
+  if ((LONG)InterlockedDecrement( (LONG*) &psa->cLocks) < 0)
   {
     WARN("Unlocked but no lock held!\n");
-    InterlockedIncrement(&psa->cLocks);
+    InterlockedIncrement( (LONG*) &psa->cLocks);
     return E_UNEXPECTED;
   }
   return S_OK;
index 720dc74..cf82a31 100644 (file)
@@ -159,7 +159,6 @@ _unmarshal_interface(marshal_state *buf, REFIID riid, LPUNKNOWN *pUnk) {
 
 static HRESULT
 _marshal_interface(marshal_state *buf, REFIID riid, LPUNKNOWN pUnk) {
-    LPUNKNOWN          newiface = NULL;
     LPBYTE             tempbuf = NULL;
     IStream            *pStm = NULL;
     STATSTG            ststg;
@@ -183,11 +182,6 @@ _marshal_interface(marshal_state *buf, REFIID riid, LPUNKNOWN pUnk) {
     hres = E_FAIL;
 
     TRACE("...%s...\n",debugstr_guid(riid));
-    hres = IUnknown_QueryInterface(pUnk,riid,(LPVOID*)&newiface);
-    if (hres) {
-       WARN("%p does not support iface %s\n",pUnk,debugstr_guid(riid));
-       goto fail;
-    }
     
     hres = CreateStreamOnHGlobal(0,TRUE,&pStm);
     if (hres) {
@@ -195,7 +189,7 @@ _marshal_interface(marshal_state *buf, REFIID riid, LPUNKNOWN pUnk) {
        goto fail;
     }
     
-    hres = CoMarshalInterface(pStm,riid,newiface,0,NULL,0);
+    hres = CoMarshalInterface(pStm,riid,pUnk,0,NULL,0);
     if (hres) {
        ERR("Marshalling interface %s failed with %lx\n", debugstr_guid(riid), hres);
        goto fail;
@@ -226,7 +220,6 @@ _marshal_interface(marshal_state *buf, REFIID riid, LPUNKNOWN pUnk) {
     hres = xbuf_add(buf,tempbuf,ststg.cbSize.u.LowPart);
     
     HeapFree(GetProcessHeap(),0,tempbuf);
-    IUnknown_Release(newiface);
     IStream_Release(pStm);
     
     return hres;
@@ -235,7 +228,6 @@ fail:
     xsize = 0;
     xbuf_add(buf,(LPBYTE)&xsize,sizeof(xsize));
     if (pStm) IUnknown_Release(pStm);
-    if (newiface) IUnknown_Release(newiface);
     HeapFree(GetProcessHeap(), 0, tempbuf);
     return hres;
 }
@@ -556,7 +548,7 @@ serialize_param(
            if (hres) return hres;
        }
        /* need to recurse since we need to free the stuff */
-       hres = serialize_param(tinfo,writeit,debugout,dealloc,&tdesc2,&(V_I4(vt)),buf);
+       hres = serialize_param(tinfo,writeit,debugout,dealloc,&tdesc2,(DWORD*)&(V_I4(vt)),buf);
        if (debugout) TRACE_(olerelay)(")");
        return hres;
     }
@@ -663,6 +655,8 @@ serialize_param(
        case TKIND_INTERFACE:
            if (writeit)
               hres=_marshal_interface(buf,&(tattr->guid),(LPUNKNOWN)arg);
+           if (dealloc)
+               IUnknown_Release((LPUNKNOWN)arg);
            break;
        case TKIND_RECORD: {
            int i;
@@ -1077,7 +1071,7 @@ deserialize_param(
                tdesc2.vt = vttype;
                V_VT(vt)  = vttype;
                if (debugout) TRACE_(olerelay)("Vt(%ld)(",vttype);
-               hres = deserialize_param(tinfo, readit, debugout, alloc, &tdesc2, &(V_I4(vt)), buf);
+               hres = deserialize_param(tinfo, readit, debugout, alloc, &tdesc2, (DWORD*)&(V_I4(vt)), buf);
                TRACE_(olerelay)(")");
                return hres;
            } else {
@@ -1526,7 +1520,7 @@ xCall(LPVOID retptr, int method, TMProxyImpl *tpinfo /*, args */)
     ULONG              status;
     BSTR               fname,iname;
     BSTR               names[10];
-    int                        nrofnames;
+    UINT               nrofnames;
     int                        is_idispatch_getidsofnames = 0;
     DWORD              remoteresult = 0;
     ITypeInfo          *tinfo;
@@ -2016,7 +2010,7 @@ TMStubImpl_Invoke(
     HRESULT    hres;
     DWORD      *args, res, *xargs, nrofargs;
     marshal_state      buf;
-    int                nrofnames;
+    UINT       nrofnames;
     BSTR       names[10];
     BSTR       fname = NULL,iname = NULL;
     BOOL       is_idispatch_getidsofnames = 0;
@@ -2220,11 +2214,34 @@ afterserialize:
        return hres;
 
     ITypeInfo_Release(tinfo);
+    HeapFree(GetProcessHeap(), 0, args);
+
     xmsg->cbBuffer     = buf.curoff;
-    I_RpcGetBuffer((RPC_MESSAGE *)xmsg);
-    memcpy(xmsg->Buffer, buf.base, buf.curoff);
-    HeapFree(GetProcessHeap(),0,args);
-    return S_OK;
+    if (rpcchanbuf)
+    {
+        hres = IRpcChannelBuffer_GetBuffer(rpcchanbuf, xmsg, &This->iid);
+        if (hres != S_OK)
+            ERR("IRpcChannelBuffer_GetBuffer failed with error 0x%08lx\n", hres);
+    }
+    else
+    {
+        /* FIXME: remove this case when we start sending an IRpcChannelBuffer
+         * object with builtin OLE */
+        RPC_STATUS status = I_RpcGetBuffer((RPC_MESSAGE *)xmsg);
+        if (status != RPC_S_OK)
+        {
+            ERR("I_RpcGetBuffer failed with error %ld\n", status);
+            hres = E_FAIL;
+        }
+    }
+
+    if (hres == S_OK)
+        memcpy(xmsg->Buffer, buf.base, buf.curoff);
+
+    HeapFree(GetProcessHeap(), 0, buf.base);
+
+    TRACE("returning\n");
+    return hres;
 }
 
 static LPRPCSTUBBUFFER WINAPI
@@ -2237,6 +2254,7 @@ static ULONG WINAPI
 TMStubImpl_CountRefs(LPRPCSTUBBUFFER iface) {
     TMStubImpl *This = (TMStubImpl *)iface;
 
+    FIXME("()\n");
     return This->ref; /*FIXME? */
 }
 
@@ -2305,10 +2323,9 @@ static const IPSFactoryBufferVtbl psfacbufvtbl = {
 static const IPSFactoryBufferVtbl *lppsfac = &psfacbufvtbl;
 
 /***********************************************************************
- *           DllGetClassObject [OLE32.63]
+ *           TMARSHAL_DllGetClassObject
  */
-HRESULT WINAPI
-TypeLibFac_DllGetClassObject(REFCLSID rclsid, REFIID iid,LPVOID *ppv)
+HRESULT TMARSHAL_DllGetClassObject(REFCLSID rclsid, REFIID iid,LPVOID *ppv)
 {
     if (IsEqualIID(iid,&IID_IPSFactoryBuffer)) {
        *ppv = &lppsfac;
index e49fa4a..f60b013 100644 (file)
@@ -247,7 +247,7 @@ HRESULT WINAPI QueryPathOfRegTypeLib(
 
     while (hr != S_OK)
     {
-        DWORD dwPathLen = sizeof(Path);
+        LONG dwPathLen = sizeof(Path);
 
         get_lcid_subkey( myLCID, SYS_WIN32, buffer );
 
@@ -885,8 +885,10 @@ typedef struct tagITypeLibImpl
 static const ITypeLib2Vtbl tlbvt;
 static const ITypeCompVtbl tlbtcvt;
 
-#define _ITypeComp_Offset(impl) ((int)(&(((impl*)0)->lpVtblTypeComp)))
-#define ICOM_THIS_From_ITypeComp(impl, iface) impl* This = (impl*)(((char*)iface)-_ITypeComp_Offset(impl))
+static inline ITypeLibImpl *impl_from_ITypeComp( ITypeComp *iface )
+{
+    return (ITypeLibImpl *)((char*)iface - FIELD_OFFSET(ITypeLibImpl, lpVtblTypeComp));
+}
 
 /* ITypeLib methods */
 static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength);
@@ -995,6 +997,11 @@ typedef struct tagITypeInfoImpl
     struct tagITypeInfoImpl * next;
 } ITypeInfoImpl;
 
+static inline ITypeInfoImpl *info_impl_from_ITypeComp( ITypeComp *iface )
+{
+    return (ITypeInfoImpl *)((char*)iface - FIELD_OFFSET(ITypeInfoImpl, lpVtblTypeComp));
+}
+
 static const ITypeInfo2Vtbl tinfvt;
 static const ITypeCompVtbl  tcompvt;
 
@@ -2909,7 +2916,7 @@ static SLTG_TypeInfoTail *SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
                paramName = NULL;
                HaveOffs = TRUE;
            }
-           else if(!isalnum(*(paramName-1)))
+           else if(paramName[-1] && !isalnum(paramName[-1]))
                HaveOffs = TRUE;
 
            pArg++;
@@ -3125,7 +3132,7 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
     DWORD len, order;
     ITypeInfoImpl **ppTypeInfoImpl;
 
-    TRACE("%p, TLB length = %ld\n", pLib, dwTLBLength);
+    TRACE_(typelib)("%p, TLB length = %ld\n", pLib, dwTLBLength);
 
     pTypeLibImpl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ITypeLibImpl));
     if (!pTypeLibImpl) return NULL;
@@ -3135,8 +3142,8 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
 
     pHeader = pLib;
 
-    TRACE("header:\n");
-    TRACE("\tmagic=0x%08lx, file blocks = %d\n", pHeader->SLTG_magic,
+    TRACE_(typelib)("header:\n");
+    TRACE_(typelib)("\tmagic=0x%08lx, file blocks = %d\n", pHeader->SLTG_magic,
          pHeader->nrOfFileBlks );
     if (pHeader->SLTG_magic != SLTG_SIGNATURE) {
        FIXME("Header type magic 0x%08lx not supported.\n",
@@ -3212,7 +3219,7 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
        }
        w = *(WORD*)(ptr + 4 + len);
        if(w != 0xffff) {
-           TRACE("\twith %s\n", debugstr_an(ptr + 6 + len, w));
+           TRACE_(typelib)("\twith %s\n", debugstr_an(ptr + 6 + len, w));
            len += w;
            pOtherTypeInfoBlks[i].other_name = HeapAlloc(GetProcessHeap(),0,
                                                         w+1);
@@ -3359,7 +3366,7 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
          (*ppTypeInfoImpl)->TypeAttr.cbSizeInstance = pTITail->cbSizeInstance;
          (*ppTypeInfoImpl)->TypeAttr.cbSizeVft = pTITail->cbSizeVft;
 
-#define X(x) TRACE("tt "#x": %x\n",pTITail->res##x);
+#define X(x) TRACE_(typelib)("tt "#x": %x\n",pTITail->res##x);
          X(06);
          X(08);
          X(0a);
@@ -4003,23 +4010,23 @@ static const ITypeLib2Vtbl tlbvt = {
 
 static HRESULT WINAPI ITypeLibComp_fnQueryInterface(ITypeComp * iface, REFIID riid, LPVOID * ppv)
 {
-    ICOM_THIS_From_ITypeComp(ITypeLibImpl, iface);
+    ITypeLibImpl *This = impl_from_ITypeComp(iface);
 
-    return ITypeInfo_QueryInterface((ITypeInfo *)This, riid, ppv);
+    return ITypeLib2_QueryInterface((ITypeLib *)This, riid, ppv);
 }
 
 static ULONG WINAPI ITypeLibComp_fnAddRef(ITypeComp * iface)
 {
-    ICOM_THIS_From_ITypeComp(ITypeLibImpl, iface);
+    ITypeLibImpl *This = impl_from_ITypeComp(iface);
 
-    return ITypeInfo_AddRef((ITypeInfo *)This);
+    return ITypeLib2_AddRef((ITypeLib2 *)This);
 }
 
 static ULONG WINAPI ITypeLibComp_fnRelease(ITypeComp * iface)
 {
-    ICOM_THIS_From_ITypeComp(ITypeLibImpl, iface);
+    ITypeLibImpl *This = impl_from_ITypeComp(iface);
 
-    return ITypeInfo_Release((ITypeInfo *)This);
+    return ITypeLib2_Release((ITypeLib2 *)This);
 }
 
 static HRESULT WINAPI ITypeLibComp_fnBind(
@@ -4169,7 +4176,7 @@ static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( ITypeInfo2 *iface,
     if(This->TypeAttr.typekind == TKIND_ALIAS) /* need to deep copy typedesc */
        copy_typedesc(&(*ppTypeAttr)->tdescAlias, &This->TypeAttr.tdescAlias);
 
-    if((*ppTypeAttr)->typekind == TKIND_DISPATCH && (*ppTypeAttr)->wTypeFlags & TYPEFLAG_FDUAL) {
+    if((*ppTypeAttr)->typekind == TKIND_DISPATCH) {
         (*ppTypeAttr)->cFuncs = (*ppTypeAttr)->cbSizeVft / 4; /* This should include all the inherited
                                                                  funcs */
         (*ppTypeAttr)->cbSizeVft = 28; /* This is always the size of IDispatch's vtbl */
@@ -4990,6 +4997,14 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
                             dump_Variant(&varresult);
                         }
                         hres = VariantCopyInd(pVarResult, &varresult);
+                        /* free data stored in varresult. Note that
+                         * VariantClear doesn't do what we want because we are
+                         * working with byref types. */
+                        /* FIXME: clear safearrays, bstrs, records and
+                         * variants here too */
+                        if ((V_VT(&varresult) == (VT_UNKNOWN | VT_BYREF)) ||
+                            (V_VT(&varresult) == (VT_DISPATCH | VT_BYREF)))
+                            IUnknown_Release(*V_UNKNOWNREF(&varresult));
                         break;
                    }
                }
@@ -5113,6 +5128,7 @@ static HRESULT WINAPI ITypeInfo_fnGetDocumentation( ITypeInfo2 *iface,
            return S_OK;
         }
     }
+    WARN("member %ld not found\n", memid);
     return TYPE_E_ELEMENTNOTFOUND;
 }
 
@@ -5207,7 +5223,7 @@ static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
             ITypeLib *pTLib = NULL;
 
            if(pRefType->pImpTLInfo == TLB_REF_INTERNAL) {
-               int Index;
+               UINT Index;
                result = ITypeInfo_GetContainingTypeLib(iface, &pTLib, &Index);
            } else {
                if(pRefType->pImpTLInfo->pImpTypeLib) {
@@ -5955,21 +5971,21 @@ HRESULT WINAPI CreateDispTypeInfo(
 
 static HRESULT WINAPI ITypeComp_fnQueryInterface(ITypeComp * iface, REFIID riid, LPVOID * ppv)
 {
-    ICOM_THIS_From_ITypeComp(ITypeInfoImpl, iface);
+    ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
 
     return ITypeInfo_QueryInterface((ITypeInfo *)This, riid, ppv);
 }
 
 static ULONG WINAPI ITypeComp_fnAddRef(ITypeComp * iface)
 {
-    ICOM_THIS_From_ITypeComp(ITypeInfoImpl, iface);
+    ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
 
     return ITypeInfo_AddRef((ITypeInfo *)This);
 }
 
 static ULONG WINAPI ITypeComp_fnRelease(ITypeComp * iface)
 {
-    ICOM_THIS_From_ITypeComp(ITypeInfoImpl, iface);
+    ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
 
     return ITypeInfo_Release((ITypeInfo *)This);
 }
@@ -5983,7 +5999,7 @@ static HRESULT WINAPI ITypeComp_fnBind(
     DESCKIND * pDescKind,
     BINDPTR * pBindPtr)
 {
-    ICOM_THIS_From_ITypeComp(ITypeInfoImpl, iface);
+    ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
     TLBFuncDesc * pFDesc;
     TLBVarDesc * pVDesc;
 
index 5e9c90f..031eb85 100644 (file)
@@ -597,9 +597,12 @@ WORD offset from start of block to SAFEARRAY
 WORD typeofarray
 */
 
+#include "poppack.h"
+
 extern DWORD _invoke(FARPROC func,CALLCONV callconv, int nrargs, DWORD *args);
 extern void dump_Variant(VARIANT * pvar);
-#include "poppack.h"
+
+HRESULT TMARSHAL_DllGetClassObject(REFCLSID rclsid, REFIID iid,LPVOID *ppv);
 
 /*---------------------------END--------------------------------------------*/
 #endif
index e01b58d..3f943e2 100644 (file)
@@ -1,12 +1,12 @@
-2  stub CREATETYPELIB\r
-3  pascal LoadTypeLib(ptr ptr) LoadTypeLib16\r
-4  stub LHASHVALOFNAMESYS\r
-5  stub _IID_ICREATETYPEINFO\r
-6  stub _IID_ICREATETYPELIB\r
-7  stub _IID_ITYPECOMP\r
-8  stub _IID_ITYPEINFO\r
-9  stub _IID_ITYPELIB\r
-10 stub REGISTERTYPELIB\r
-11 stub LOADREGTYPELIB\r
-14 pascal QueryPathOfRegTypeLib(ptr word word word ptr) QueryPathOfRegTypeLib16\r
-15 pascal OaBuildVersion() OaBuildVersion16\r
+2  stub CREATETYPELIB
+3  pascal LoadTypeLib(ptr ptr) LoadTypeLib16
+4  stub LHASHVALOFNAMESYS
+5  stub _IID_ICREATETYPEINFO
+6  stub _IID_ICREATETYPELIB
+7  stub _IID_ITYPECOMP
+8  stub _IID_ITYPEINFO
+9  stub _IID_ITYPELIB
+10 stub REGISTERTYPELIB
+11 stub LOADREGTYPELIB
+14 pascal QueryPathOfRegTypeLib(ptr word word word ptr) QueryPathOfRegTypeLib16
+15 pascal OaBuildVersion() OaBuildVersion16
index ffc5b88..7b4c670 100644 (file)
@@ -166,8 +166,10 @@ typedef struct tagICreateTypeLib2Impl
     struct tagICreateTypeInfo2Impl *last_typeinfo;
 } ICreateTypeLib2Impl;
 
-#define _ITypeLib2_Offset(impl) ((int)(&(((impl*)0)->lpVtblTypeLib2)))
-#define ICOM_THIS_From_ITypeLib2(impl, iface) impl* This = (impl*)(((char*)iface)-_ITypeLib2_Offset(impl))
+static inline ICreateTypeLib2Impl *impl_from_ITypeLib2( ITypeLib2 *iface )
+{
+    return (ICreateTypeLib2Impl *)((char*)iface - FIELD_OFFSET(ICreateTypeLib2Impl, lpVtblTypeLib2));
+}
 
 typedef struct tagICreateTypeInfo2Impl
 {
@@ -192,8 +194,10 @@ typedef struct tagICreateTypeInfo2Impl
     struct tagICreateTypeInfo2Impl *next_typeinfo;
 } ICreateTypeInfo2Impl;
 
-#define _ITypeInfo2_Offset(impl) ((int)(&(((impl*)0)->lpVtblTypeInfo2)))
-#define ICOM_THIS_From_ITypeInfo2(impl, iface) impl* This = (impl*)(((char*)iface)-_ITypeInfo2_Offset(impl))
+static inline ICreateTypeInfo2Impl *impl_from_ITypeInfo2( ITypeInfo2 *iface )
+{
+    return (ICreateTypeInfo2Impl *)((char*)iface - FIELD_OFFSET(ICreateTypeInfo2Impl, lpVtblTypeInfo2));
+}
 
 static ULONG WINAPI ICreateTypeLib2_fnRelease(ICreateTypeLib2 *iface);
 
@@ -1328,7 +1332,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddRefTypeInfo(
     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
 
     ITypeLib *container;
-    int index;
+    UINT index;
     HRESULT res;
 
     TRACE("(%p,%p,%p)\n", iface, pTInfo, phRefType);
@@ -2198,7 +2202,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnSetName(
  */
 static HRESULT WINAPI ITypeInfo2_fnQueryInterface(ITypeInfo2 * iface, REFIID riid, LPVOID * ppv)
 {
-    ICOM_THIS_From_ITypeInfo2(ICreateTypeInfo2Impl, iface);
+    ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
 
     return ICreateTypeInfo2_QueryInterface((ICreateTypeInfo2 *)This, riid, ppv);
 }
@@ -2210,7 +2214,7 @@ static HRESULT WINAPI ITypeInfo2_fnQueryInterface(ITypeInfo2 * iface, REFIID rii
  */
 static ULONG WINAPI ITypeInfo2_fnAddRef(ITypeInfo2 * iface)
 {
-    ICOM_THIS_From_ITypeInfo2(ICreateTypeInfo2Impl, iface);
+    ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
 
     return ICreateTypeInfo2_AddRef((ICreateTypeInfo2 *)This);
 }
@@ -2222,7 +2226,7 @@ static ULONG WINAPI ITypeInfo2_fnAddRef(ITypeInfo2 * iface)
  */
 static ULONG WINAPI ITypeInfo2_fnRelease(ITypeInfo2 * iface)
 {
-    ICOM_THIS_From_ITypeInfo2(ICreateTypeInfo2Impl, iface);
+    ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
 
     return ICreateTypeInfo2_Release((ICreateTypeInfo2 *)This);
 }
@@ -2461,7 +2465,7 @@ static HRESULT WINAPI ITypeInfo2_fnGetContainingTypeLib(
         ITypeLib** ppTLib,
         UINT* pIndex)
 {
-    ICOM_THIS_From_ITypeInfo2(ICreateTypeInfo2Impl, iface);
+    ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
 
     TRACE("(%p,%p,%p)\n", iface, ppTLib, pIndex);
     
@@ -3431,7 +3435,7 @@ static HRESULT WINAPI ICreateTypeLib2_fnSetHelpStringDll(
  */
 static HRESULT WINAPI ITypeLib2_fnQueryInterface(ITypeLib2 * iface, REFIID riid, LPVOID * ppv)
 {
-    ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
     return ICreateTypeLib2_QueryInterface((ICreateTypeLib2 *)This, riid, ppv);
 }
@@ -3443,7 +3447,7 @@ static HRESULT WINAPI ITypeLib2_fnQueryInterface(ITypeLib2 * iface, REFIID riid,
  */
 static ULONG WINAPI ITypeLib2_fnAddRef(ITypeLib2 * iface)
 {
-    ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
     return ICreateTypeLib2_AddRef((ICreateTypeLib2 *)This);
 }
@@ -3455,7 +3459,7 @@ static ULONG WINAPI ITypeLib2_fnAddRef(ITypeLib2 * iface)
  */
 static ULONG WINAPI ITypeLib2_fnRelease(ITypeLib2 * iface)
 {
-    ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
     return ICreateTypeLib2_Release((ICreateTypeLib2 *)This);
 }
@@ -3468,7 +3472,7 @@ static ULONG WINAPI ITypeLib2_fnRelease(ITypeLib2 * iface)
 static UINT WINAPI ITypeLib2_fnGetTypeInfoCount(
         ITypeLib2 * iface)
 {
-    ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
     TRACE("(%p)\n", iface);
 
@@ -3485,7 +3489,7 @@ static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
         UINT index,
         ITypeInfo** ppTInfo)
 {
-    ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
     TRACE("(%p,%d,%p)\n", iface, index, ppTInfo);
 
@@ -3506,7 +3510,7 @@ static HRESULT WINAPI ITypeLib2_fnGetTypeInfoType(
         UINT index,
         TYPEKIND* pTKind)
 {
-    ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
     TRACE("(%p,%d,%p)\n", iface, index, pTKind);
 
@@ -3529,7 +3533,7 @@ static HRESULT WINAPI ITypeLib2_fnGetTypeInfoOfGuid(
         REFGUID guid,
         ITypeInfo** ppTinfo)
 {
-    ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
     int guidoffset;
     int typeinfo;
@@ -3554,9 +3558,9 @@ static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
         ITypeLib2 * iface,
         TLIBATTR** ppTLibAttr)
 {
-/*     ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface); */
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
-    FIXME("(%p,%p), stub!\n", iface, ppTLibAttr);
+    FIXME("(%p,%p), stub!\n", This, ppTLibAttr);
 
     return E_OUTOFMEMORY;
 }
@@ -3570,9 +3574,9 @@ static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
         ITypeLib2 * iface,
         ITypeComp** ppTComp)
 {
-/*     ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface); */
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
-    FIXME("(%p,%p), stub!\n", iface, ppTComp);
+    FIXME("(%p,%p), stub!\n", This, ppTComp);
 
     return E_OUTOFMEMORY;
 }
@@ -3590,9 +3594,9 @@ static HRESULT WINAPI ITypeLib2_fnGetDocumentation(
         DWORD* pdwHelpContext,
         BSTR* pBstrHelpFile)
 {
-/*     ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface); */
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
-    FIXME("(%p,%d,%p,%p,%p,%p), stub!\n", iface, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
+    FIXME("(%p,%d,%p,%p,%p,%p), stub!\n", This, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
 
     return E_OUTOFMEMORY;
 }
@@ -3608,7 +3612,7 @@ static HRESULT WINAPI ITypeLib2_fnIsName(
         ULONG lHashVal,
         BOOL* pfName)
 {
-    ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
     char *encoded_name;
     int nameoffset;
@@ -3646,9 +3650,9 @@ static HRESULT WINAPI ITypeLib2_fnFindName(
         MEMBERID* rgMemId,
         USHORT* pcFound)
 {
-/*     ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface); */
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
-    FIXME("(%p,%s,%lx,%p,%p,%p), stub!\n", iface, debugstr_w(szNameBuf), lHashVal, ppTInfo, rgMemId, pcFound);
+    FIXME("(%p,%s,%lx,%p,%p,%p), stub!\n", This, debugstr_w(szNameBuf), lHashVal, ppTInfo, rgMemId, pcFound);
 
     return E_OUTOFMEMORY;
 }
@@ -3662,9 +3666,9 @@ static void WINAPI ITypeLib2_fnReleaseTLibAttr(
         ITypeLib2 * iface,
         TLIBATTR* pTLibAttr)
 {
-/*     ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface); */
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
-    FIXME("(%p,%p), stub!\n", iface, pTLibAttr);
+    FIXME("(%p,%p), stub!\n", This, pTLibAttr);
 }
 
 /******************************************************************************
@@ -3682,9 +3686,9 @@ static HRESULT WINAPI ITypeLib2_fnGetCustData(
         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
         VARIANT* pVarVal)  /* [O] The custom data. */
 {
-/*     ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface); */
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
-    FIXME("(%p,%s,%p), stub!\n", iface, debugstr_guid(guid), pVarVal);
+    FIXME("(%p,%s,%p), stub!\n", This, debugstr_guid(guid), pVarVal);
 
     return E_OUTOFMEMORY;
 }
@@ -3705,9 +3709,9 @@ static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
         ULONG* pcUniqueNames,   /* [O] The number of unique names in the type library. */
         ULONG* pcchUniqueNames) /* [O] The number of changed (?) characters in names in the type library. */
 {
-/*     ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface); */
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
-    FIXME("(%p,%p,%p), stub!\n", iface, pcUniqueNames, pcchUniqueNames);
+    FIXME("(%p,%p,%p), stub!\n", This, pcUniqueNames, pcchUniqueNames);
 
     return E_OUTOFMEMORY;
 }
@@ -3730,9 +3734,9 @@ static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
         DWORD* pdwHelpStringContext,
         BSTR* pbstrHelpStringDll)
 {
-/*     ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface); */
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
-    FIXME("(%p,%d,%ld,%p,%p,%p), stub!\n", iface, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll);
+    FIXME("(%p,%d,%ld,%p,%p,%p), stub!\n", This, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll);
 
     return E_OUTOFMEMORY;
 }
@@ -3751,9 +3755,9 @@ static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
         ITypeLib2 * iface,   /* [I] The type library in which to find the custom data. */
         CUSTDATA* pCustData) /* [O] The structure in which to place the custom data. */
 {
-/*     ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface); */
+    ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
 
-    FIXME("(%p,%p), stub!\n", iface, pCustData);
+    FIXME("(%p,%p), stub!\n", This, pCustData);
 
     return E_OUTOFMEMORY;
 }
index 9e4db05..5c04dc5 100644 (file)
@@ -1342,7 +1342,7 @@ static HRESULT VARIANT_FormatNumber(LPVARIANT pVarIn, LPOLESTR lpszFormat,
 
     case FMT_GEN_INLINE:
       pToken += 2;
-      TRACE("copy %s\n", debugstr_a(pToken));
+      TRACE("copy %s\n", debugstr_a((LPCSTR)pToken));
       while (*pToken)
         *pBuff++ = *pToken++;
       break;
index 0a80e76..775ad7b 100644 (file)
@@ -1926,6 +1926,11 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
  *  - Rounding (dropping of decimal points) occurs without error. See VarI8FromR8()
  *    for details of the rounding method.
  *  - pVarDst is not cleared before the result is stored in it.
+ *  - WinXP and Win2003 support VTBIT_I8, VTBIT_UI8 but that's buggy (by
+ *    design?): If some other VTBIT's for integers are specified together
+ *    with VTBIT_I8 and the number will fit only in a VT_I8 Windows will "cast"
+ *    the number to the smallest requested integer truncating this way the
+ *    number.  Wine dosn't implement this "feature" (yet?).
  */
 HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
                                   ULONG dwVtBits, VARIANT *pVarDst)
@@ -2893,8 +2898,12 @@ HRESULT WINAPI VarAdd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
     }
     if (resvt != tvt) {
         if ((hres = VariantChangeType(result, &tv, 0, resvt)) != S_OK) {
-            /* Overflow! Change to the vartype with the next higher priority */
-            resvt = prio2vt[coerce[resvt] + 1];
+            /* Overflow! Change to the vartype with the next higher priority.
+               With one exception: I4 ==> R8 even if it would fit in I8 */
+            if (resvt == VT_I4)
+                resvt = VT_R8;
+            else
+                resvt = prio2vt[coerce[resvt] + 1];
             hres = VariantChangeType(result, &tv, 0, resvt);
         }
     } else
@@ -3061,8 +3070,12 @@ HRESULT WINAPI VarMul(LPVARIANT left, LPVARIANT right, LPVARIANT result)
     }
     if (resvt != tvt) {
         while ((hres = VariantChangeType(result, &tv, 0, resvt)) != S_OK) {
-            /* Overflow! Change to the vartype with the next higher priority */
-            resvt = prio2vt[coerce[resvt] + 1];
+            /* Overflow! Change to the vartype with the next higher priority.
+               With one exception: I4 ==> R8 even if it would fit in I8 */
+            if (resvt == VT_I4)
+                resvt = VT_R8;
+            else
+                resvt = prio2vt[coerce[resvt] + 1];
         }
     } else
         hres = VariantCopy(result, &tv);
index 7bf6a51..5405a80 100644 (file)
@@ -92,333 +92,11 @@ extern const char* wine_vflags[];
 
 #define DEC_MAX_SCALE    28 /* Maximum scale for a decimal */
 
-/* Inline return type */
-#define RETTYP inline static HRESULT
-
-/* Simple compiler cast from one type to another */
-#define SIMPLE(dest, src, func) RETTYP _##func(src in, dest* out) { \
-  *out = in; return S_OK; }
-
-/* Compiler cast where input cannot be negative */
-#define NEGTST(dest, src, func) RETTYP _##func(src in, dest* out) { \
-  if (in < (src)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; }
-
-/* 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; }
-
-/* Conversions from IDispatch use the same code */
-HRESULT VARIANT_FromDisp(IDispatch*,LCID,void*,VARTYPE);
-/* As do conversions from BSTR to numeric types */
-HRESULT VARIANT_NumberFromBstr(OLECHAR*,LCID,ULONG,void*,VARTYPE);
-
-#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)
-
-/* I1 */
-POSTST(signed char, BYTE, VarI1FromUI1, I1_MAX);
-BOTHTST(signed char, SHORT, VarI1FromI2, I1_MIN, I1_MAX);
-BOTHTST(signed char, LONG, VarI1FromI4, I1_MIN, I1_MAX);
-#define _VarI1FromR4(flt,out) VarI1FromR8((double)flt,out)
-#define _VarI1FromR8 VarI1FromR8
-#define _VarI1FromCy VarI1FromCy
-#define _VarI1FromDate(dt,out) VarI1FromR8((double)dt,out)
-#define _VarI1FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_I1)
-#define _VarI1FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, (BYTE*)out, VT_I1)
-SIMPLE(signed char, VARIANT_BOOL, VarI1FromBool);
-POSTST(signed char, USHORT, VarI1FromUI2, I1_MAX);
-POSTST(signed char, ULONG, VarI1FromUI4, I1_MAX);
-#define _VarI1FromDec VarI1FromDec
-BOTHTST(signed char, LONG64, VarI1FromI8, I1_MIN, I1_MAX);
-POSTST(signed char, ULONG64, VarI1FromUI8, I1_MAX);
-
-/* UI1 */
-BOTHTST(BYTE, SHORT, VarUI1FromI2, UI1_MIN, UI1_MAX);
-#define _VarUI1FromR4(flt,out) VarUI1FromR8((double)flt,out)
-#define _VarUI1FromR8 VarUI1FromR8
-#define _VarUI1FromCy VarUI1FromCy
-#define _VarUI1FromDate(dt,out) VarUI1FromR8((double)dt,out)
-#define _VarUI1FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_UI1)
-#define _VarUI1FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_UI1)
-SIMPLE(BYTE, VARIANT_BOOL, VarUI1FromBool);
-NEGTST(BYTE, signed char, VarUI1FromI1);
-POSTST(BYTE, USHORT, VarUI1FromUI2, UI1_MAX);
-BOTHTST(BYTE, LONG, VarUI1FromI4, UI1_MIN, UI1_MAX);
-POSTST(BYTE, ULONG, VarUI1FromUI4, UI1_MAX);
-#define _VarUI1FromDec VarUI1FromDec
-BOTHTST(BYTE, LONG64, VarUI1FromI8, UI1_MIN, UI1_MAX);
-POSTST(BYTE, ULONG64, VarUI1FromUI8, UI1_MAX);
-
-/* I2 */
-SIMPLE(SHORT, BYTE, VarI2FromUI1);
-BOTHTST(SHORT, LONG, VarI2FromI4, I2_MIN, I2_MAX);
-#define _VarI2FromR4(flt,out) VarI2FromR8((double)flt,out)
-#define _VarI2FromR8 VarI2FromR8
-#define _VarI2FromCy VarI2FromCy
-#define _VarI2FromDate(dt,out) VarI2FromR8((double)dt,out)
-#define _VarI2FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_I2)
-#define _VarI2FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, (BYTE*)out, VT_I2)
-SIMPLE(SHORT, VARIANT_BOOL, VarI2FromBool);
-SIMPLE(SHORT, signed char, VarI2FromI1);
-POSTST(SHORT, USHORT, VarI2FromUI2, I2_MAX);
-POSTST(SHORT, ULONG, VarI2FromUI4, I2_MAX);
-#define _VarI2FromDec VarI2FromDec
-BOTHTST(SHORT, LONG64, VarI2FromI8, I2_MIN, I2_MAX);
-POSTST(SHORT, ULONG64, VarI2FromUI8, I2_MAX);
-
-/* UI2 */
-SIMPLE(USHORT, BYTE, VarUI2FromUI1);
-NEGTST(USHORT, SHORT, VarUI2FromI2);
-BOTHTST(USHORT, LONG, VarUI2FromI4, UI2_MIN, UI2_MAX);
-#define _VarUI2FromR4(flt,out) VarUI2FromR8((double)flt,out)
-#define _VarUI2FromR8 VarUI2FromR8
-#define _VarUI2FromCy VarUI2FromCy
-#define _VarUI2FromDate(dt,out) VarUI2FromR8((double)dt,out)
-#define _VarUI2FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_UI2)
-#define _VarUI2FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_UI2)
-SIMPLE(USHORT, VARIANT_BOOL, VarUI2FromBool);
-NEGTST(USHORT, signed char, VarUI2FromI1);
-POSTST(USHORT, ULONG, VarUI2FromUI4, UI2_MAX);
-#define _VarUI2FromDec VarUI2FromDec
-BOTHTST(USHORT, LONG64, VarUI2FromI8, UI2_MIN, UI2_MAX);
-POSTST(USHORT, ULONG64, VarUI2FromUI8, UI2_MAX);
-
-/* I4 */
-SIMPLE(LONG, BYTE, VarI4FromUI1);
-SIMPLE(LONG, SHORT, VarI4FromI2);
-#define _VarI4FromR4(flt,out) VarI4FromR8((double)flt,out)
-#define _VarI4FromR8 VarI4FromR8
-#define _VarI4FromCy VarI4FromCy
-#define _VarI4FromDate(dt,out) VarI4FromR8((double)dt,out)
-#define _VarI4FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_I4)
-#define _VarI4FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, (BYTE*)out, VT_I4)
-SIMPLE(LONG, VARIANT_BOOL, VarI4FromBool);
-SIMPLE(LONG, signed char, VarI4FromI1);
-SIMPLE(LONG, USHORT, VarI4FromUI2);
-POSTST(LONG, ULONG, VarI4FromUI4, I4_MAX);
-#define _VarI4FromDec VarI4FromDec
-BOTHTST(LONG, LONG64, VarI4FromI8, I4_MIN, I4_MAX);
-POSTST(LONG, ULONG64, VarI4FromUI8, I4_MAX);
-
-/* UI4 */
-SIMPLE(ULONG, BYTE, VarUI4FromUI1);
-NEGTST(ULONG, SHORT, VarUI4FromI2);
-NEGTST(ULONG, LONG, VarUI4FromI4);
-#define _VarUI4FromR4(flt,out) VarUI4FromR8((double)flt,out)
-#define _VarUI4FromR8 VarUI4FromR8
-#define _VarUI4FromCy VarUI4FromCy
-#define _VarUI4FromDate(dt,out) VarUI4FromR8((double)dt,out)
-#define _VarUI4FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_UI4)
-#define _VarUI4FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_UI4)
-SIMPLE(ULONG, VARIANT_BOOL, VarUI4FromBool);
-NEGTST(ULONG, signed char, VarUI4FromI1);
-SIMPLE(ULONG, USHORT, VarUI4FromUI2);
-#define _VarUI4FromDec VarUI4FromDec
-BOTHTST(ULONG, LONG64, VarUI4FromI8, UI4_MIN, UI4_MAX);
-POSTST(ULONG, ULONG64, VarUI4FromUI8, UI4_MAX);
-
-/* I8 */
-SIMPLE(LONG64, BYTE, VarI8FromUI1);
-SIMPLE(LONG64, SHORT, VarI8FromI2);
-#define _VarI8FromR4 VarI8FromR8
-#define _VarI8FromR8 VarI8FromR8
-#define _VarI8FromCy VarI8FromCy
-#define _VarI8FromDate(dt,out) VarI8FromR8((double)dt,out)
-#define _VarI8FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_I8)
-#define _VarI8FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_I8)
-#define _VarI8FromBool   _VarI8FromI2
-SIMPLE(LONG64, signed char, VarI8FromI1);
-SIMPLE(LONG64, USHORT, VarI8FromUI2);
-SIMPLE(LONG64, LONG, VarI8FromI4);
-SIMPLE(LONG64, ULONG, VarI8FromUI4);
-#define _VarI8FromDec VarI8FromDec
-POSTST(LONG64, ULONG64, VarI8FromUI8, I8_MAX);
-
-/* UI8 */
-SIMPLE(ULONG64, BYTE, VarUI8FromUI1);
-NEGTST(ULONG64, SHORT, VarUI8FromI2);
-#define _VarUI8FromR4 VarUI8FromR8
-#define _VarUI8FromR8 VarUI8FromR8
-#define _VarUI8FromCy VarUI8FromCy
-#define _VarUI8FromDate(dt,out) VarUI8FromR8((double)dt,out)
-#define _VarUI8FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_UI8)
-#define _VarUI8FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_UI8)
-#define _VarUI8FromBool _VarI8FromI2
-NEGTST(ULONG64, signed char, VarUI8FromI1);
-SIMPLE(ULONG64, USHORT, VarUI8FromUI2);
-NEGTST(ULONG64, LONG, VarUI8FromI4);
-SIMPLE(ULONG64, ULONG, VarUI8FromUI4);
-#define _VarUI8FromDec VarUI8FromDec
-NEGTST(ULONG64, LONG64, VarUI8FromI8);
-
-/* R4 (float) */
-SIMPLE(float, BYTE, VarR4FromUI1);
-SIMPLE(float, SHORT, VarR4FromI2);
-RETTYP _VarR4FromR8(double i, float* o) {
-  double d = i < 0.0 ? -i : i;
-  if (d > R4_MAX) return DISP_E_OVERFLOW;
-  *o = i;
-  return S_OK;
-}
-RETTYP _VarR4FromCy(CY i, float* o) { *o = (double)i.int64 / CY_MULTIPLIER_F; return S_OK; }
-#define _VarR4FromDate(dt,out) _VarR4FromR8((double)dt,out)
-#define _VarR4FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_R4)
-#define _VarR4FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_R4)
-#define _VarR4FromBool _VarR4FromI2
-SIMPLE(float, signed char, VarR4FromI1);
-SIMPLE(float, USHORT, VarR4FromUI2);
-SIMPLE(float, LONG, VarR4FromI4);
-SIMPLE(float, ULONG, VarR4FromUI4);
-#define _VarR4FromDec VarR4FromDec
-SIMPLE(float, LONG64, VarR4FromI8);
-SIMPLE(float, ULONG64, VarR4FromUI8);
-
-/* R8 (double) */
-SIMPLE(double, BYTE, VarR8FromUI1);
-SIMPLE(double, SHORT, VarR8FromI2);
-SIMPLE(double, float, VarR8FromR4);
-RETTYP _VarR8FromCy(CY i, double* o) { *o = (double)i.int64 / CY_MULTIPLIER_F; return S_OK; }
-SIMPLE(double, DATE, VarR8FromDate);
-#define _VarR8FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_R8)
-#define _VarR8FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_R8)
-#define _VarR8FromBool _VarR8FromI2
-SIMPLE(double, signed char, VarR8FromI1);
-SIMPLE(double, USHORT, VarR8FromUI2);
-SIMPLE(double, LONG, VarR8FromI4);
-SIMPLE(double, ULONG, VarR8FromUI4);
-#define _VarR8FromDec VarR8FromDec
-SIMPLE(double, LONG64, VarR8FromI8);
-SIMPLE(double, ULONG64, VarR8FromUI8);
-
-/* BOOL */
-#define BOOLFUNC(src, func) RETTYP _##func(src in, VARIANT_BOOL* out) { \
-  *out = in ? VARIANT_TRUE : VARIANT_FALSE; return S_OK; }
-
-BOOLFUNC(signed char,VarBoolFromI1);
-BOOLFUNC(BYTE,VarBoolFromUI1);
-BOOLFUNC(SHORT,VarBoolFromI2);
-BOOLFUNC(USHORT,VarBoolFromUI2);
-BOOLFUNC(LONG,VarBoolFromI4);
-BOOLFUNC(ULONG,VarBoolFromUI4);
-BOOLFUNC(LONG64,VarBoolFromI8);
-BOOLFUNC(ULONG64,VarBoolFromUI8);
-#define _VarBoolFromR4(flt,out) _VarBoolFromR8((double)flt,out)
-BOOLFUNC(double,VarBoolFromR8);
-#define _VarBoolFromCy(i,o) _VarBoolFromI8(i.int64,o)
-#define _VarBoolFromDate(dt,out) _VarBoolFromR8((double)dt,out)
-#define _VarBoolFromStr VarBoolFromStr
-#define _VarBoolFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, (BYTE*)out, VT_BOOL)
-#define _VarBoolFromDec VarBoolFromDec
-
 /* Internal flags for low level conversion functions */
 #define  VAR_BOOLONOFF 0x0400 /* Convert bool to "On"/"Off" */
 #define  VAR_BOOLYESNO 0x0800 /* Convert bool to "Yes"/"No" */
 #define  VAR_NEGATIVE  0x1000 /* Number is negative */
 
-/* DECIMAL */
-#define _VarDecFromUI1 VarDecFromUI4
-#define _VarDecFromI2 VarDecFromI4
-#define _VarDecFromR4 VarDecFromR4
-#define _VarDecFromR8 VarDecFromR8
-#define _VarDecFromCy VarDecFromCy
-#define _VarDecFromDate(dt,out) VarDecFromR8((double)dt,out)
-#define _VarDecFromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_DECIMAL)
-#define _VarDecFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_DECIMAL)
-#define _VarDecFromBool VarDecFromBool
-#define _VarDecFromI1 VarDecFromI4
-#define _VarDecFromUI2 VarDecFromUI4
-#define _VarDecFromI4 VarDecFromI4
-#define _VarDecFromUI4 VarDecFromUI4
-#define _VarDecFromI8 VarDecFromI8
-#define _VarDecFromUI8 VarDecFromUI8
-
-/* CY (Currency) */
-#define _VarCyFromUI1 VarCyFromR8
-#define _VarCyFromI2 VarCyFromR8
-#define _VarCyFromR4 VarCyFromR8
-#define _VarCyFromR8 VarCyFromR8
-#define _VarCyFromDate VarCyFromR8
-#define _VarCyFromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_CY)
-#define _VarCyFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_CY)
-#define _VarCyFromBool VarCyFromR8
-#define _VarCyFromI1 VarCyFromR8
-#define _VarCyFromUI2 VarCyFromR8
-#define _VarCyFromI4 VarCyFromR8
-#define _VarCyFromUI4 VarCyFromR8
-#define _VarCyFromDec VarCyFromDec
-RETTYP _VarCyFromI8(LONG64 i, CY* o) {
-  if (i <= (I8_MIN/CY_MULTIPLIER) || i >= (I8_MAX/CY_MULTIPLIER)) return DISP_E_OVERFLOW;
-  o->int64 = i * CY_MULTIPLIER;
-  return S_OK;
-}
-#define _VarCyFromUI8 VarCyFromR8
-
-/* DATE */
-#define _VarDateFromUI1 _VarR8FromUI1
-#define _VarDateFromI2 _VarR8FromI2
-#define _VarDateFromR4 _VarDateFromR8
-RETTYP _VarDateFromR8(double i, DATE* o) {
-  if (i <= (DATE_MIN - 1.0) || i >= (DATE_MAX + 1.0)) return DISP_E_OVERFLOW;
-  *o = (DATE)i;
-  return S_OK;
-}
-#define _VarDateFromCy _VarR8FromCy
-#define _VarDateFromStr VarDateFromStr
-#define _VarDateFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_DATE)
-#define _VarDateFromBool _VarR8FromBool
-#define _VarDateFromI1 _VarR8FromI1
-#define _VarDateFromUI2 _VarR8FromUI2
-#define _VarDateFromI4 _VarDateFromR8
-#define _VarDateFromUI4 _VarDateFromR8
-#define _VarDateFromDec _VarR8FromDec
-RETTYP _VarDateFromI8(LONG64 i, DATE* o) {
-  if (i < DATE_MIN || i > DATE_MAX) return DISP_E_OVERFLOW;
-  *o = (DATE)i;
-  return S_OK;
-}
-RETTYP _VarDateFromUI8(ULONG64 i, DATE* o) {
-  if (i > DATE_MAX) return DISP_E_OVERFLOW;
-  *o = (DATE)i;
-  return S_OK;
-}
-
-/* BSTR */
-#define _VarBstrFromUI1 VarBstrFromUI4
-#define _VarBstrFromI2 VarBstrFromI4
-#define _VarBstrFromR4 VarBstrFromR8
-#define _VarBstrFromR8 VarBstrFromR8
-#define _VarBstrFromCy VarBstrFromCy
-#define _VarBstrFromDate VarBstrFromDate
-#define _VarBstrFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_BSTR)
-#define _VarBstrFromBool VarBstrFromBool
-#define _VarBstrFromI1 VarBstrFromI4
-#define _VarBstrFromUI2 VarBstrFromUI4
-#define _VarBstrFromI4 VarBstrFromI4
-#define _VarBstrFromUI4 VarBstrFromUI4
-#define _VarBstrFromDec VarBstrFromDec
-#define _VarBstrFromI8 VarBstrFromI8
-#define _VarBstrFromUI8 VarBstrFromUI8
-
-/* Macro to inline conversion from a float or double to any integer type,
- * rounding according to the 'dutch' convention.
- */
-#define OLEAUT32_DutchRound(typ, value, res) do { \
-  double whole = (double)value < 0 ? ceil((double)value) : floor((double)value); \
-  double fract = (double)value - whole; \
-  if (fract > 0.5) res = (typ)whole + (typ)1; \
-  else if (fract == 0.5) { typ is_odd = (typ)whole & 1; res = whole + is_odd; } \
-  else if (fract >= 0.0) res = (typ)whole; \
-  else if (fract == -0.5) { typ is_odd = (typ)whole & 1; res = whole - is_odd; } \
-  else if (fract > -0.5) res = (typ)whole; \
-  else res = (typ)whole - (typ)1; \
-} while(0);
-
 /* The localised characters that make up a valid number */
 typedef struct tagVARIANT_NUMBER_CHARS
 {
index 0e1b7e8..db913ea 100644 (file)
@@ -34,6 +34,11 @@ WINE_DEFAULT_DEBUG_CHANNEL(variant);
 
 extern HMODULE OLEAUT32_hModule;
 
+#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' };
 
@@ -64,10 +69,24 @@ static inline void VARIANT_CopyData(const VARIANT *srcVar, VARTYPE vt, void *pOu
   }
 }
 
+/* Macro to inline conversion from a float or double to any integer type,
+ * rounding according to the 'dutch' convention.
+ */
+#define VARIANT_DutchRound(typ, value, res) do { \
+  double whole = value < 0 ? ceil(value) : floor(value); \
+  double fract = value - whole; \
+  if (fract > 0.5) res = (typ)whole + (typ)1; \
+  else if (fract == 0.5) { typ is_odd = (typ)whole & 1; res = whole + is_odd; } \
+  else if (fract >= 0.0) res = (typ)whole; \
+  else if (fract == -0.5) { typ is_odd = (typ)whole & 1; res = whole - is_odd; } \
+  else if (fract > -0.5) res = (typ)whole; \
+  else res = (typ)whole - (typ)1; \
+} while(0);
+
 
 /* Coerce VT_BSTR to a numeric type */
-HRESULT VARIANT_NumberFromBstr(OLECHAR* pStrIn, LCID lcid, ULONG ulFlags,
-                               void* pOut, VARTYPE vt)
+static HRESULT VARIANT_NumberFromBstr(OLECHAR* pStrIn, LCID lcid, ULONG ulFlags,
+                                      void* pOut, VARTYPE vt)
 {
   VARIANTARG dstVar;
   HRESULT hRet;
@@ -91,7 +110,7 @@ HRESULT VARIANT_NumberFromBstr(OLECHAR* pStrIn, LCID lcid, ULONG ulFlags,
 }
 
 /* Coerce VT_DISPATCH to another type */
-HRESULT VARIANT_FromDisp(IDispatch* pdispIn, LCID lcid, void* pOut, VARTYPE vt)
+static HRESULT VARIANT_FromDisp(IDispatch* pdispIn, LCID lcid, void* pOut, VARTYPE vt)
 {
   static const DISPPARAMS emptyParams = { NULL, NULL, 0, 0 };
   VARIANTARG srcVar, dstVar;
@@ -122,6 +141,128 @@ HRESULT VARIANT_FromDisp(IDispatch* pdispIn, LCID lcid, void* pOut, VARTYPE vt)
   return hRet;
 }
 
+/* Inline return type */
+#define RETTYP inline static HRESULT
+
+
+/* Simple compiler cast from one type to another */
+#define SIMPLE(dest, src, func) RETTYP _##func(src in, dest* out) { \
+  *out = in; return S_OK; }
+
+/* Compiler cast where input cannot be negative */
+#define NEGTST(dest, src, func) RETTYP _##func(src in, dest* out) { \
+  if (in < (src)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; }
+
+/* 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; }
+
+/* I1 */
+POSTST(signed char, BYTE, VarI1FromUI1, I1_MAX);
+BOTHTST(signed char, SHORT, VarI1FromI2, I1_MIN, I1_MAX);
+BOTHTST(signed char, LONG, VarI1FromI4, I1_MIN, I1_MAX);
+SIMPLE(signed char, VARIANT_BOOL, VarI1FromBool);
+POSTST(signed char, USHORT, VarI1FromUI2, I1_MAX);
+POSTST(signed char, ULONG, VarI1FromUI4, I1_MAX);
+BOTHTST(signed char, LONG64, VarI1FromI8, I1_MIN, I1_MAX);
+POSTST(signed char, ULONG64, VarI1FromUI8, I1_MAX);
+
+/* UI1 */
+BOTHTST(BYTE, SHORT, VarUI1FromI2, UI1_MIN, UI1_MAX);
+SIMPLE(BYTE, VARIANT_BOOL, VarUI1FromBool);
+NEGTST(BYTE, signed char, VarUI1FromI1);
+POSTST(BYTE, USHORT, VarUI1FromUI2, UI1_MAX);
+BOTHTST(BYTE, LONG, VarUI1FromI4, UI1_MIN, UI1_MAX);
+POSTST(BYTE, ULONG, VarUI1FromUI4, UI1_MAX);
+BOTHTST(BYTE, LONG64, VarUI1FromI8, UI1_MIN, UI1_MAX);
+POSTST(BYTE, ULONG64, VarUI1FromUI8, UI1_MAX);
+
+/* I2 */
+SIMPLE(SHORT, BYTE, VarI2FromUI1);
+BOTHTST(SHORT, LONG, VarI2FromI4, I2_MIN, I2_MAX);
+SIMPLE(SHORT, VARIANT_BOOL, VarI2FromBool);
+SIMPLE(SHORT, signed char, VarI2FromI1);
+POSTST(SHORT, USHORT, VarI2FromUI2, I2_MAX);
+POSTST(SHORT, ULONG, VarI2FromUI4, I2_MAX);
+BOTHTST(SHORT, LONG64, VarI2FromI8, I2_MIN, I2_MAX);
+POSTST(SHORT, ULONG64, VarI2FromUI8, I2_MAX);
+
+/* UI2 */
+SIMPLE(USHORT, BYTE, VarUI2FromUI1);
+NEGTST(USHORT, SHORT, VarUI2FromI2);
+BOTHTST(USHORT, LONG, VarUI2FromI4, UI2_MIN, UI2_MAX);
+SIMPLE(USHORT, VARIANT_BOOL, VarUI2FromBool);
+NEGTST(USHORT, signed char, VarUI2FromI1);
+POSTST(USHORT, ULONG, VarUI2FromUI4, UI2_MAX);
+BOTHTST(USHORT, LONG64, VarUI2FromI8, UI2_MIN, UI2_MAX);
+POSTST(USHORT, ULONG64, VarUI2FromUI8, UI2_MAX);
+
+/* I4 */
+SIMPLE(LONG, BYTE, VarI4FromUI1);
+SIMPLE(LONG, SHORT, VarI4FromI2);
+SIMPLE(LONG, VARIANT_BOOL, VarI4FromBool);
+SIMPLE(LONG, signed char, VarI4FromI1);
+SIMPLE(LONG, USHORT, VarI4FromUI2);
+POSTST(LONG, ULONG, VarI4FromUI4, I4_MAX);
+BOTHTST(LONG, LONG64, VarI4FromI8, I4_MIN, I4_MAX);
+POSTST(LONG, ULONG64, VarI4FromUI8, I4_MAX);
+
+/* UI4 */
+SIMPLE(ULONG, BYTE, VarUI4FromUI1);
+NEGTST(ULONG, SHORT, VarUI4FromI2);
+NEGTST(ULONG, LONG, VarUI4FromI4);
+SIMPLE(ULONG, VARIANT_BOOL, VarUI4FromBool);
+NEGTST(ULONG, signed char, VarUI4FromI1);
+SIMPLE(ULONG, USHORT, VarUI4FromUI2);
+BOTHTST(ULONG, LONG64, VarUI4FromI8, UI4_MIN, UI4_MAX);
+POSTST(ULONG, ULONG64, VarUI4FromUI8, UI4_MAX);
+
+/* I8 */
+SIMPLE(LONG64, BYTE, VarI8FromUI1);
+SIMPLE(LONG64, SHORT, VarI8FromI2);
+SIMPLE(LONG64, signed char, VarI8FromI1);
+SIMPLE(LONG64, USHORT, VarI8FromUI2);
+SIMPLE(LONG64, LONG, VarI8FromI4);
+SIMPLE(LONG64, ULONG, VarI8FromUI4);
+POSTST(LONG64, ULONG64, VarI8FromUI8, I8_MAX);
+
+/* UI8 */
+SIMPLE(ULONG64, BYTE, VarUI8FromUI1);
+NEGTST(ULONG64, SHORT, VarUI8FromI2);
+NEGTST(ULONG64, signed char, VarUI8FromI1);
+SIMPLE(ULONG64, USHORT, VarUI8FromUI2);
+NEGTST(ULONG64, LONG, VarUI8FromI4);
+SIMPLE(ULONG64, ULONG, VarUI8FromUI4);
+NEGTST(ULONG64, LONG64, VarUI8FromI8);
+
+/* R4 (float) */
+SIMPLE(float, BYTE, VarR4FromUI1);
+SIMPLE(float, SHORT, VarR4FromI2);
+SIMPLE(float, signed char, VarR4FromI1);
+SIMPLE(float, USHORT, VarR4FromUI2);
+SIMPLE(float, LONG, VarR4FromI4);
+SIMPLE(float, ULONG, VarR4FromUI4);
+SIMPLE(float, LONG64, VarR4FromI8);
+SIMPLE(float, ULONG64, VarR4FromUI8);
+
+/* R8 (double) */
+SIMPLE(double, BYTE, VarR8FromUI1);
+SIMPLE(double, SHORT, VarR8FromI2);
+SIMPLE(double, float, VarR8FromR4);
+RETTYP _VarR8FromCy(CY i, double* o) { *o = (double)i.int64 / CY_MULTIPLIER_F; return S_OK; }
+SIMPLE(double, DATE, VarR8FromDate);
+SIMPLE(double, signed char, VarR8FromI1);
+SIMPLE(double, USHORT, VarR8FromUI2);
+SIMPLE(double, LONG, VarR8FromI4);
+SIMPLE(double, ULONG, VarR8FromUI4);
+SIMPLE(double, LONG64, VarR8FromI8);
+SIMPLE(double, ULONG64, VarR8FromUI8);
+
+
 /* I1
  */
 
@@ -198,7 +339,7 @@ HRESULT WINAPI VarI1FromI4(LONG iIn, signed char* pcOut)
  */
 HRESULT WINAPI VarI1FromR4(FLOAT fltIn, signed char* pcOut)
 {
-  return _VarI1FromR4(fltIn, pcOut);
+  return VarI1FromR8(fltIn, pcOut);
 }
 
 /************************************************************************
@@ -222,7 +363,7 @@ HRESULT WINAPI VarI1FromR8(double dblIn, signed char* pcOut)
 {
   if (dblIn < (double)I1_MIN || dblIn > (double)I1_MAX)
     return DISP_E_OVERFLOW;
-  OLEAUT32_DutchRound(CHAR, dblIn, *pcOut);
+  VARIANT_DutchRound(CHAR, dblIn, *pcOut);
   return S_OK;
 }
 
@@ -242,7 +383,7 @@ HRESULT WINAPI VarI1FromR8(double dblIn, signed char* pcOut)
  */
 HRESULT WINAPI VarI1FromDate(DATE dateIn, signed char* pcOut)
 {
-  return _VarI1FromDate(dateIn, pcOut);
+  return VarI1FromR8(dateIn, pcOut);
 }
 
 /************************************************************************
@@ -263,7 +404,7 @@ HRESULT WINAPI VarI1FromCy(CY cyIn, signed char* pcOut)
 {
   LONG i = I1_MAX + 1;
 
-  _VarI4FromCy(cyIn, &i);
+  VarI4FromCy(cyIn, &i);
   return _VarI1FromI4(i, pcOut);
 }
 
@@ -286,7 +427,7 @@ HRESULT WINAPI VarI1FromCy(CY cyIn, signed char* pcOut)
  */
 HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, signed char* pcOut)
 {
-  return _VarI1FromStr(strIn, lcid, dwFlags, pcOut);
+  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pcOut, VT_I1);
 }
 
 /************************************************************************
@@ -307,7 +448,7 @@ HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, signed cha
  */
 HRESULT WINAPI VarI1FromDisp(IDispatch* pdispIn, LCID lcid, signed char* pcOut)
 {
-  return _VarI1FromDisp(pdispIn, lcid, pcOut);
+  return VARIANT_FromDisp(pdispIn, lcid, pcOut, VT_I1);
 }
 
 /************************************************************************
@@ -385,7 +526,7 @@ HRESULT WINAPI VarI1FromDec(DECIMAL *pdecIn, signed char* pcOut)
   LONG64 i64;
   HRESULT hRet;
 
-  hRet = _VarI8FromDec(pdecIn, &i64);
+  hRet = VarI8FromDec(pdecIn, &i64);
 
   if (SUCCEEDED(hRet))
     hRet = _VarI1FromI8(i64, pcOut);
@@ -488,7 +629,7 @@ HRESULT WINAPI VarUI1FromI4(LONG iIn, BYTE* pbOut)
  */
 HRESULT WINAPI VarUI1FromR4(FLOAT fltIn, BYTE* pbOut)
 {
-  return _VarUI1FromR4(fltIn, pbOut);
+  return VarUI1FromR8(fltIn, pbOut);
 }
 
 /************************************************************************
@@ -512,7 +653,7 @@ HRESULT WINAPI VarUI1FromR8(double dblIn, BYTE* pbOut)
 {
   if (dblIn < -0.5 || dblIn > (double)UI1_MAX)
     return DISP_E_OVERFLOW;
-  OLEAUT32_DutchRound(BYTE, dblIn, *pbOut);
+  VARIANT_DutchRound(BYTE, dblIn, *pbOut);
   return S_OK;
 }
 
@@ -537,7 +678,7 @@ HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut)
 {
   ULONG i = UI1_MAX + 1;
 
-  _VarUI4FromCy(cyIn, &i);
+  VarUI4FromCy(cyIn, &i);
   return _VarUI1FromUI4(i, pbOut);
 }
 
@@ -557,7 +698,7 @@ HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut)
  */
 HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
 {
-  return _VarUI1FromDate(dateIn, pbOut);
+  return VarUI1FromR8(dateIn, pbOut);
 }
 
 /************************************************************************
@@ -579,7 +720,7 @@ HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
  */
 HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
 {
-  return _VarUI1FromStr(strIn, lcid, dwFlags, pbOut);
+  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pbOut, VT_UI1);
 }
 
 /************************************************************************
@@ -600,7 +741,7 @@ HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbO
  */
 HRESULT WINAPI VarUI1FromDisp(IDispatch* pdispIn, LCID lcid, BYTE* pbOut)
 {
-  return _VarUI1FromDisp(pdispIn, lcid, pbOut);
+  return VARIANT_FromDisp(pdispIn, lcid, pbOut, VT_UI1);
 }
 
 /************************************************************************
@@ -696,7 +837,7 @@ HRESULT WINAPI VarUI1FromDec(DECIMAL *pdecIn, BYTE* pbOut)
   LONG64 i64;
   HRESULT hRet;
 
-  hRet = _VarI8FromDec(pdecIn, &i64);
+  hRet = VarI8FromDec(pdecIn, &i64);
 
   if (SUCCEEDED(hRet))
     hRet = _VarUI1FromI8(i64, pbOut);
@@ -795,7 +936,7 @@ HRESULT WINAPI VarI2FromI4(LONG iIn, SHORT* psOut)
  */
 HRESULT WINAPI VarI2FromR4(FLOAT fltIn, SHORT* psOut)
 {
-  return _VarI2FromR4(fltIn, psOut);
+  return VarI2FromR8(fltIn, psOut);
 }
 
 /************************************************************************
@@ -818,7 +959,7 @@ HRESULT WINAPI VarI2FromR8(double dblIn, SHORT* psOut)
 {
   if (dblIn < (double)I2_MIN || dblIn > (double)I2_MAX)
     return DISP_E_OVERFLOW;
-  OLEAUT32_DutchRound(SHORT, dblIn, *psOut);
+  VARIANT_DutchRound(SHORT, dblIn, *psOut);
   return S_OK;
 }
 
@@ -839,7 +980,7 @@ HRESULT WINAPI VarI2FromCy(CY cyIn, SHORT* psOut)
 {
   LONG i = I2_MAX + 1;
 
-  _VarI4FromCy(cyIn, &i);
+  VarI4FromCy(cyIn, &i);
   return _VarI2FromI4(i, psOut);
 }
 
@@ -858,7 +999,7 @@ HRESULT WINAPI VarI2FromCy(CY cyIn, SHORT* psOut)
  */
 HRESULT WINAPI VarI2FromDate(DATE dateIn, SHORT* psOut)
 {
-  return _VarI2FromDate(dateIn, psOut);
+  return VarI2FromR8(dateIn, psOut);
 }
 
 /************************************************************************
@@ -880,7 +1021,7 @@ HRESULT WINAPI VarI2FromDate(DATE dateIn, SHORT* psOut)
  */
 HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, SHORT* psOut)
 {
-  return _VarI2FromStr(strIn, lcid, dwFlags, psOut);
+  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, psOut, VT_I2);
 }
 
 /************************************************************************
@@ -901,7 +1042,7 @@ HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, SHORT* psO
  */
 HRESULT WINAPI VarI2FromDisp(IDispatch* pdispIn, LCID lcid, SHORT* psOut)
 {
-  return _VarI2FromDisp(pdispIn, lcid, psOut);
+  return VARIANT_FromDisp(pdispIn, lcid, psOut, VT_I2);
 }
 
 /************************************************************************
@@ -993,7 +1134,7 @@ HRESULT WINAPI VarI2FromDec(DECIMAL *pdecIn, SHORT* psOut)
   LONG64 i64;
   HRESULT hRet;
 
-  hRet = _VarI8FromDec(pdecIn, &i64);
+  hRet = VarI8FromDec(pdecIn, &i64);
 
   if (SUCCEEDED(hRet))
     hRet = _VarI2FromI8(i64, psOut);
@@ -1107,7 +1248,7 @@ HRESULT WINAPI VarUI2FromI4(LONG iIn, USHORT* pusOut)
  */
 HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* pusOut)
 {
-  return _VarUI2FromR4(fltIn, pusOut);
+  return VarUI2FromR8(fltIn, pusOut);
 }
 
 /************************************************************************
@@ -1130,7 +1271,7 @@ HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* pusOut)
 {
   if (dblIn < -0.5 || dblIn > (double)UI2_MAX)
     return DISP_E_OVERFLOW;
-  OLEAUT32_DutchRound(USHORT, dblIn, *pusOut);
+  VARIANT_DutchRound(USHORT, dblIn, *pusOut);
   return S_OK;
 }
 
@@ -1149,7 +1290,7 @@ HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* pusOut)
  */
 HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* pusOut)
 {
-  return _VarUI2FromDate(dateIn, pusOut);
+  return VarUI2FromR8(dateIn, pusOut);
 }
 
 /************************************************************************
@@ -1172,7 +1313,7 @@ HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut)
 {
   ULONG i = UI2_MAX + 1;
 
-  _VarUI4FromCy(cyIn, &i);
+  VarUI4FromCy(cyIn, &i);
   return _VarUI2FromUI4(i, pusOut);
 }
 
@@ -1194,7 +1335,7 @@ HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut)
  */
 HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* pusOut)
 {
-  return _VarUI2FromStr(strIn, lcid, dwFlags, pusOut);
+  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pusOut, VT_UI2);
 }
 
 /************************************************************************
@@ -1215,7 +1356,7 @@ HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* p
  */
 HRESULT WINAPI VarUI2FromDisp(IDispatch* pdispIn, LCID lcid, USHORT* pusOut)
 {
-  return _VarUI2FromDisp(pdispIn, lcid, pusOut);
+  return VARIANT_FromDisp(pdispIn, lcid, pusOut, VT_UI2);
 }
 
 /************************************************************************
@@ -1290,7 +1431,7 @@ HRESULT WINAPI VarUI2FromDec(DECIMAL *pdecIn, USHORT* pusOut)
   LONG64 i64;
   HRESULT hRet;
 
-  hRet = _VarI8FromDec(pdecIn, &i64);
+  hRet = VarI8FromDec(pdecIn, &i64);
 
   if (SUCCEEDED(hRet))
     hRet = _VarUI2FromI8(i64, pusOut);
@@ -1387,7 +1528,7 @@ HRESULT WINAPI VarI4FromI2(SHORT sIn, LONG *piOut)
  */
 HRESULT WINAPI VarI4FromR4(FLOAT fltIn, LONG *piOut)
 {
-  return _VarI4FromR4(fltIn, piOut);
+  return VarI4FromR8(fltIn, piOut);
 }
 
 /************************************************************************
@@ -1410,7 +1551,7 @@ HRESULT WINAPI VarI4FromR8(double dblIn, LONG *piOut)
 {
   if (dblIn < (double)I4_MIN || dblIn > (double)I4_MAX)
     return DISP_E_OVERFLOW;
-  OLEAUT32_DutchRound(LONG, dblIn, *piOut);
+  VARIANT_DutchRound(LONG, dblIn, *piOut);
   return S_OK;
 }
 
@@ -1430,7 +1571,7 @@ HRESULT WINAPI VarI4FromR8(double dblIn, LONG *piOut)
 HRESULT WINAPI VarI4FromCy(CY cyIn, LONG *piOut)
 {
   double d = cyIn.int64 / CY_MULTIPLIER_F;
-  return _VarI4FromR8(d, piOut);
+  return VarI4FromR8(d, piOut);
 }
 
 /************************************************************************
@@ -1448,7 +1589,7 @@ HRESULT WINAPI VarI4FromCy(CY cyIn, LONG *piOut)
  */
 HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG *piOut)
 {
-  return _VarI4FromDate(dateIn, piOut);
+  return VarI4FromR8(dateIn, piOut);
 }
 
 /************************************************************************
@@ -1470,7 +1611,7 @@ HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG *piOut)
  */
 HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG *piOut)
 {
-  return _VarI4FromStr(strIn, lcid, dwFlags, piOut);
+  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, piOut, VT_I4);
 }
 
 /************************************************************************
@@ -1491,7 +1632,7 @@ HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG *piOu
  */
 HRESULT WINAPI VarI4FromDisp(IDispatch* pdispIn, LCID lcid, LONG *piOut)
 {
-  return _VarI4FromDisp(pdispIn, lcid, piOut);
+  return VARIANT_FromDisp(pdispIn, lcid, piOut, VT_I4);
 }
 
 /************************************************************************
@@ -1582,7 +1723,7 @@ HRESULT WINAPI VarI4FromDec(DECIMAL *pdecIn, LONG *piOut)
   LONG64 i64;
   HRESULT hRet;
 
-  hRet = _VarI8FromDec(pdecIn, &i64);
+  hRet = VarI8FromDec(pdecIn, &i64);
 
   if (SUCCEEDED(hRet))
     hRet = _VarI4FromI8(i64, piOut);
@@ -1696,7 +1837,7 @@ HRESULT WINAPI VarUI4FromI4(LONG iIn, ULONG *pulOut)
  */
 HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG *pulOut)
 {
-  return _VarUI4FromR4(fltIn, pulOut);
+  return VarUI4FromR8(fltIn, pulOut);
 }
 
 /************************************************************************
@@ -1719,7 +1860,7 @@ HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG *pulOut)
 {
   if (dblIn < -0.5 || dblIn > (double)UI4_MAX)
     return DISP_E_OVERFLOW;
-  OLEAUT32_DutchRound(ULONG, dblIn, *pulOut);
+  VARIANT_DutchRound(ULONG, dblIn, *pulOut);
   return S_OK;
 }
 
@@ -1738,7 +1879,7 @@ HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG *pulOut)
  */
 HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG *pulOut)
 {
-  return _VarUI4FromDate(dateIn, pulOut);
+  return VarUI4FromR8(dateIn, pulOut);
 }
 
 /************************************************************************
@@ -1757,7 +1898,7 @@ HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG *pulOut)
 HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG *pulOut)
 {
   double d = cyIn.int64 / CY_MULTIPLIER_F;
-  return _VarUI4FromR8(d, pulOut);
+  return VarUI4FromR8(d, pulOut);
 }
 
 /************************************************************************
@@ -1779,7 +1920,7 @@ HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG *pulOut)
  */
 HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG *pulOut)
 {
-  return _VarUI4FromStr(strIn, lcid, dwFlags, pulOut);
+  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pulOut, VT_UI4);
 }
 
 /************************************************************************
@@ -1800,7 +1941,7 @@ HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG *pu
  */
 HRESULT WINAPI VarUI4FromDisp(IDispatch* pdispIn, LCID lcid, ULONG *pulOut)
 {
-  return _VarUI4FromDisp(pdispIn, lcid, pulOut);
+  return VARIANT_FromDisp(pdispIn, lcid, pulOut, VT_UI4);
 }
 
 /************************************************************************
@@ -1874,7 +2015,7 @@ HRESULT WINAPI VarUI4FromDec(DECIMAL *pdecIn, ULONG *pulOut)
   LONG64 i64;
   HRESULT hRet;
 
-  hRet = _VarI8FromDec(pdecIn, &i64);
+  hRet = VarI8FromDec(pdecIn, &i64);
 
   if (SUCCEEDED(hRet))
     hRet = _VarUI4FromI8(i64, pulOut);
@@ -1971,7 +2112,7 @@ HRESULT WINAPI VarI8FromI2(SHORT sIn, LONG64* pi64Out)
  */
 HRESULT WINAPI VarI8FromR4(FLOAT fltIn, LONG64* pi64Out)
 {
-  return _VarI8FromR4(fltIn, pi64Out);
+  return VarI8FromR8(fltIn, pi64Out);
 }
 
 /************************************************************************
@@ -2009,7 +2150,7 @@ HRESULT WINAPI VarI8FromR8(double dblIn, LONG64* pi64Out)
 {
   if ( dblIn < -4611686018427387904.0 || dblIn >= 4611686018427387904.0)
     return DISP_E_OVERFLOW;
-  OLEAUT32_DutchRound(LONG64, dblIn, *pi64Out);
+  VARIANT_DutchRound(LONG64, dblIn, *pi64Out);
   return S_OK;
 }
 
@@ -2064,7 +2205,7 @@ HRESULT WINAPI VarI8FromCy(CY cyIn, LONG64* pi64Out)
  */
 HRESULT WINAPI VarI8FromDate(DATE dateIn, LONG64* pi64Out)
 {
-  return _VarI8FromDate(dateIn, pi64Out);
+  return VarI8FromR8(dateIn, pi64Out);
 }
 
 /************************************************************************
@@ -2086,7 +2227,7 @@ HRESULT WINAPI VarI8FromDate(DATE dateIn, LONG64* pi64Out)
  */
 HRESULT WINAPI VarI8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG64* pi64Out)
 {
-  return _VarI8FromStr(strIn, lcid, dwFlags, pi64Out);
+  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pi64Out, VT_I8);
 }
 
 /************************************************************************
@@ -2107,7 +2248,7 @@ HRESULT WINAPI VarI8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG64* pi
  */
 HRESULT WINAPI VarI8FromDisp(IDispatch* pdispIn, LCID lcid, LONG64* pi64Out)
 {
-  return _VarI8FromDisp(pdispIn, lcid, pi64Out);
+  return VARIANT_FromDisp(pdispIn, lcid, pi64Out, VT_I8);
 }
 
 /************************************************************************
@@ -2124,7 +2265,7 @@ HRESULT WINAPI VarI8FromDisp(IDispatch* pdispIn, LCID lcid, LONG64* pi64Out)
  */
 HRESULT WINAPI VarI8FromBool(VARIANT_BOOL boolIn, LONG64* pi64Out)
 {
-  return _VarI8FromBool(boolIn, pi64Out);
+  return VarI8FromI2(boolIn, pi64Out);
 }
 
 /************************************************************************
@@ -2215,7 +2356,7 @@ HRESULT WINAPI VarI8FromDec(DECIMAL *pdecIn, LONG64* pi64Out)
     HRESULT hRet;
     double dbl;
 
-    hRet = _VarR8FromDec(pdecIn, &dbl);
+    hRet = VarR8FromDec(pdecIn, &dbl);
     if (SUCCEEDED(hRet))
       hRet = VarI8FromR8(dbl, pi64Out);
     return hRet;
@@ -2310,7 +2451,7 @@ HRESULT WINAPI VarUI8FromI2(SHORT sIn, ULONG64* pui64Out)
  */
 HRESULT WINAPI VarUI8FromR4(FLOAT fltIn, ULONG64* pui64Out)
 {
-  return _VarUI8FromR4(fltIn, pui64Out);
+  return VarUI8FromR8(fltIn, pui64Out);
 }
 
 /************************************************************************
@@ -2334,7 +2475,7 @@ HRESULT WINAPI VarUI8FromR8(double dblIn, ULONG64* pui64Out)
 {
   if (dblIn < -0.5 || dblIn > 1.844674407370955e19)
     return DISP_E_OVERFLOW;
-  OLEAUT32_DutchRound(ULONG64, dblIn, *pui64Out);
+  VARIANT_DutchRound(ULONG64, dblIn, *pui64Out);
   return S_OK;
 }
 
@@ -2392,7 +2533,7 @@ HRESULT WINAPI VarUI8FromCy(CY cyIn, ULONG64* pui64Out)
  */
 HRESULT WINAPI VarUI8FromDate(DATE dateIn, ULONG64* pui64Out)
 {
-  return _VarUI8FromDate(dateIn, pui64Out);
+  return VarUI8FromR8(dateIn, pui64Out);
 }
 
 /************************************************************************
@@ -2414,7 +2555,7 @@ HRESULT WINAPI VarUI8FromDate(DATE dateIn, ULONG64* pui64Out)
  */
 HRESULT WINAPI VarUI8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG64* pui64Out)
 {
-  return _VarUI8FromStr(strIn, lcid, dwFlags, pui64Out);
+  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pui64Out, VT_UI8);
 }
 
 /************************************************************************
@@ -2435,7 +2576,7 @@ HRESULT WINAPI VarUI8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG64*
  */
 HRESULT WINAPI VarUI8FromDisp(IDispatch* pdispIn, LCID lcid, ULONG64* pui64Out)
 {
-  return _VarUI8FromDisp(pdispIn, lcid, pui64Out);
+  return VARIANT_FromDisp(pdispIn, lcid, pui64Out, VT_UI8);
 }
 
 /************************************************************************
@@ -2453,7 +2594,7 @@ HRESULT WINAPI VarUI8FromDisp(IDispatch* pdispIn, LCID lcid, ULONG64* pui64Out)
  */
 HRESULT WINAPI VarUI8FromBool(VARIANT_BOOL boolIn, ULONG64* pui64Out)
 {
-  return _VarUI8FromBool(boolIn, pui64Out);
+  return VarI8FromI2(boolIn, (LONG64 *)pui64Out);
 }
 /************************************************************************
  * VarUI8FromI1 (OLEAUT32.438)
@@ -2553,7 +2694,7 @@ HRESULT WINAPI VarUI8FromDec(DECIMAL *pdecIn, ULONG64* pui64Out)
     HRESULT hRet;
     double dbl;
 
-    hRet = _VarR8FromDec(pdecIn, &dbl);
+    hRet = VarR8FromDec(pdecIn, &dbl);
     if (SUCCEEDED(hRet))
       hRet = VarUI8FromR8(dbl, pui64Out);
     return hRet;
@@ -2629,7 +2770,10 @@ HRESULT WINAPI VarR4FromI4(LONG lIn, float *pFltOut)
  */
 HRESULT WINAPI VarR4FromR8(double dblIn, float *pFltOut)
 {
-  return _VarR4FromR8(dblIn, pFltOut);
+  double d = dblIn < 0.0 ? -dblIn : dblIn;
+  if (d > R4_MAX) return DISP_E_OVERFLOW;
+  *pFltOut = dblIn;
+  return S_OK;
 }
 
 /************************************************************************
@@ -2646,7 +2790,8 @@ HRESULT WINAPI VarR4FromR8(double dblIn, float *pFltOut)
  */
 HRESULT WINAPI VarR4FromCy(CY cyIn, float *pFltOut)
 {
-  return _VarR4FromCy(cyIn, pFltOut);
+  *pFltOut = (double)cyIn.int64 / CY_MULTIPLIER_F;
+  return S_OK;
 }
 
 /************************************************************************
@@ -2664,7 +2809,7 @@ HRESULT WINAPI VarR4FromCy(CY cyIn, float *pFltOut)
  */
 HRESULT WINAPI VarR4FromDate(DATE dateIn, float *pFltOut)
 {
-  return _VarR4FromDate(dateIn, pFltOut);
+  return VarR4FromR8(dateIn, pFltOut);
 }
 
 /************************************************************************
@@ -2685,7 +2830,7 @@ HRESULT WINAPI VarR4FromDate(DATE dateIn, float *pFltOut)
  */
 HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, float *pFltOut)
 {
-  return _VarR4FromStr(strIn, lcid, dwFlags, pFltOut);
+  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pFltOut, VT_R4);
 }
 
 /************************************************************************
@@ -2706,7 +2851,7 @@ HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, float *pFl
  */
 HRESULT WINAPI VarR4FromDisp(IDispatch* pdispIn, LCID lcid, float *pFltOut)
 {
-  return _VarR4FromDisp(pdispIn, lcid, pFltOut);
+  return VARIANT_FromDisp(pdispIn, lcid, pFltOut, VT_R4);
 }
 
 /************************************************************************
@@ -2723,7 +2868,7 @@ HRESULT WINAPI VarR4FromDisp(IDispatch* pdispIn, LCID lcid, float *pFltOut)
  */
 HRESULT WINAPI VarR4FromBool(VARIANT_BOOL boolIn, float *pFltOut)
 {
-  return _VarR4FromBool(boolIn, pFltOut);
+  return VarR4FromI2(boolIn, pFltOut);
 }
 
 /************************************************************************
@@ -3005,7 +3150,7 @@ HRESULT WINAPI VarR8FromDate(DATE dateIn, double *pDblOut)
  */
 HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double *pDblOut)
 {
-  return _VarR8FromStr(strIn, lcid, dwFlags, pDblOut);
+  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pDblOut, VT_R8);
 }
 
 /************************************************************************
@@ -3026,7 +3171,7 @@ HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double *pD
  */
 HRESULT WINAPI VarR8FromDisp(IDispatch* pdispIn, LCID lcid, double *pDblOut)
 {
-  return _VarR8FromDisp(pdispIn, lcid, pDblOut);
+  return VARIANT_FromDisp(pdispIn, lcid, pDblOut, VT_R8);
 }
 
 /************************************************************************
@@ -3043,7 +3188,7 @@ HRESULT WINAPI VarR8FromDisp(IDispatch* pdispIn, LCID lcid, double *pDblOut)
  */
 HRESULT WINAPI VarR8FromBool(VARIANT_BOOL boolIn, double *pDblOut)
 {
-  return _VarR8FromBool(boolIn, pDblOut);
+  return VarR8FromI2(boolIn, pDblOut);
 }
 
 /************************************************************************
@@ -3273,7 +3418,7 @@ static const int CY_Divisors[5] = { CY_MULTIPLIER/10000, CY_MULTIPLIER/1000,
  */
 HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pCyOut)
 {
-  return _VarCyFromUI1(bIn, pCyOut);
+  return VarCyFromR8(bIn, pCyOut);
 }
 
 /************************************************************************
@@ -3293,7 +3438,7 @@ HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pCyOut)
  */
 HRESULT WINAPI VarCyFromI2(SHORT sIn, CY* pCyOut)
 {
-  return _VarCyFromI2(sIn, pCyOut);
+  return VarCyFromR8(sIn, pCyOut);
 }
 
 /************************************************************************
@@ -3313,7 +3458,7 @@ HRESULT WINAPI VarCyFromI2(SHORT sIn, CY* pCyOut)
  */
 HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pCyOut)
 {
-  return _VarCyFromI4(lIn, pCyOut);
+  return VarCyFromR8(lIn, pCyOut);
 }
 
 /************************************************************************
@@ -3333,7 +3478,7 @@ HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pCyOut)
  */
 HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pCyOut)
 {
-  return _VarCyFromR4(fltIn, pCyOut);
+  return VarCyFromR8(fltIn, pCyOut);
 }
 
 /************************************************************************
@@ -3382,7 +3527,7 @@ HRESULT WINAPI VarCyFromR8(double dblIn, CY* pCyOut)
   if (dblIn < -922337203685477.5807 || dblIn >= 922337203685477.5807)
     return DISP_E_OVERFLOW;
   dblIn *= CY_MULTIPLIER_F;
-  OLEAUT32_DutchRound(LONG64, dblIn, pCyOut->int64);
+  VARIANT_DutchRound(LONG64, dblIn, pCyOut->int64);
 #endif
   return S_OK;
 }
@@ -3404,7 +3549,7 @@ HRESULT WINAPI VarCyFromR8(double dblIn, CY* pCyOut)
  */
 HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pCyOut)
 {
-  return _VarCyFromDate(dateIn, pCyOut);
+  return VarCyFromR8(dateIn, pCyOut);
 }
 
 /************************************************************************
@@ -3426,7 +3571,7 @@ HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pCyOut)
  */
 HRESULT WINAPI VarCyFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, CY* pCyOut)
 {
-  return _VarCyFromStr(strIn, lcid, dwFlags, pCyOut);
+  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pCyOut, VT_CY);
 }
 
 /************************************************************************
@@ -3447,7 +3592,7 @@ HRESULT WINAPI VarCyFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, CY* pCyOut
  */
 HRESULT WINAPI VarCyFromDisp(IDispatch* pdispIn, LCID lcid, CY* pCyOut)
 {
-  return _VarCyFromDisp(pdispIn, lcid, pCyOut);
+  return VARIANT_FromDisp(pdispIn, lcid, pCyOut, VT_CY);
 }
 
 /************************************************************************
@@ -3471,7 +3616,7 @@ HRESULT WINAPI VarCyFromDisp(IDispatch* pdispIn, LCID lcid, CY* pCyOut)
  */
 HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pCyOut)
 {
-  return _VarCyFromBool(boolIn, pCyOut);
+  return VarCyFromR8(boolIn, pCyOut);
 }
 
 /************************************************************************
@@ -3491,7 +3636,7 @@ HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pCyOut)
  */
 HRESULT WINAPI VarCyFromI1(signed char cIn, CY* pCyOut)
 {
-  return _VarCyFromI1(cIn, pCyOut);
+  return VarCyFromR8(cIn, pCyOut);
 }
 
 /************************************************************************
@@ -3511,7 +3656,7 @@ HRESULT WINAPI VarCyFromI1(signed char cIn, CY* pCyOut)
  */
 HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pCyOut)
 {
-  return _VarCyFromUI2(usIn, pCyOut);
+  return VarCyFromR8(usIn, pCyOut);
 }
 
 /************************************************************************
@@ -3531,7 +3676,7 @@ HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pCyOut)
  */
 HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pCyOut)
 {
-  return _VarCyFromUI4(ulIn, pCyOut);
+  return VarCyFromR8(ulIn, pCyOut);
 }
 
 /************************************************************************
@@ -3567,7 +3712,7 @@ HRESULT WINAPI VarCyFromDec(DECIMAL* pdecIn, CY* pCyOut)
     d = (double)DEC_LO64(&rounded) / (double)CY_Divisors[DEC_SCALE(&rounded)];
     if (DEC_SIGN(&rounded))
       d = -d;
-    return _VarCyFromR8(d, pCyOut);
+    return VarCyFromR8(d, pCyOut);
   }
   return hRet;
 }
@@ -3589,7 +3734,9 @@ HRESULT WINAPI VarCyFromDec(DECIMAL* pdecIn, CY* pCyOut)
  */
 HRESULT WINAPI VarCyFromI8(LONG64 llIn, CY* pCyOut)
 {
-  return _VarCyFromI8(llIn, pCyOut);
+  if (llIn <= (I8_MIN/CY_MULTIPLIER) || llIn >= (I8_MAX/CY_MULTIPLIER)) return DISP_E_OVERFLOW;
+  pCyOut->int64 = llIn * CY_MULTIPLIER;
+  return S_OK;
 }
 
 /************************************************************************
@@ -3609,7 +3756,7 @@ HRESULT WINAPI VarCyFromI8(LONG64 llIn, CY* pCyOut)
  */
 HRESULT WINAPI VarCyFromUI8(ULONG64 ullIn, CY* pCyOut)
 {
-  return _VarCyFromUI8(ullIn, pCyOut);
+  return VarCyFromR8(ullIn, pCyOut);
 }
 
 /************************************************************************
@@ -3632,7 +3779,7 @@ HRESULT WINAPI VarCyAdd(const CY cyLeft, const CY cyRight, CY* pCyOut)
   _VarR8FromCy(cyLeft, &l);
   _VarR8FromCy(cyRight, &r);
   l = l + r;
-  return _VarCyFromR8(l, pCyOut);
+  return VarCyFromR8(l, pCyOut);
 }
 
 /************************************************************************
@@ -3655,7 +3802,7 @@ HRESULT WINAPI VarCyMul(const CY cyLeft, const CY cyRight, CY* pCyOut)
   _VarR8FromCy(cyLeft, &l);
   _VarR8FromCy(cyRight, &r);
   l = l * r;
-  return _VarCyFromR8(l, pCyOut);
+  return VarCyFromR8(l, pCyOut);
 }
 
 /************************************************************************
@@ -3678,7 +3825,7 @@ HRESULT WINAPI VarCyMulI4(const CY cyLeft, LONG lRight, CY* pCyOut)
 
   _VarR8FromCy(cyLeft, &d);
   d = d * lRight;
-  return _VarCyFromR8(d, pCyOut);
+  return VarCyFromR8(d, pCyOut);
 }
 
 /************************************************************************
@@ -3701,7 +3848,7 @@ HRESULT WINAPI VarCySub(const CY cyLeft, const CY cyRight, CY* pCyOut)
   _VarR8FromCy(cyLeft, &l);
   _VarR8FromCy(cyRight, &r);
   l = l - r;
-  return _VarCyFromR8(l, pCyOut);
+  return VarCyFromR8(l, pCyOut);
 }
 
 /************************************************************************
@@ -3832,9 +3979,9 @@ HRESULT WINAPI VarCyRound(const CY cyIn, int cDecimals, CY* pCyOut)
 
     _VarR8FromCy(cyIn, &d);
     d = d * div;
-    OLEAUT32_DutchRound(LONGLONG, d, pCyOut->int64)
+    VARIANT_DutchRound(LONGLONG, d, pCyOut->int64)
     d = (double)pCyOut->int64 / div * CY_MULTIPLIER_F;
-    OLEAUT32_DutchRound(LONGLONG, d, pCyOut->int64)
+    VARIANT_DutchRound(LONGLONG, d, pCyOut->int64)
     return S_OK;
   }
 }
@@ -3892,7 +4039,7 @@ HRESULT WINAPI VarCyCmpR8(const CY cyLeft, double dblRight)
   HRESULT hRet;
   CY cyRight;
 
-  hRet = _VarCyFromR8(dblRight, &cyRight);
+  hRet = VarCyFromR8(dblRight, &cyRight);
 
   if (SUCCEEDED(hRet))
     hRet = VarCyCmp(cyLeft, cyRight);
@@ -3920,7 +4067,7 @@ HRESULT WINAPI VarCyMulI8(const CY cyLeft, LONG64 llRight, CY* pCyOut)
 
   _VarR8FromCy(cyLeft, &d);
   d = d  * (double)llRight;
-  return _VarCyFromR8(d, pCyOut);
+  return VarCyFromR8(d, pCyOut);
 }
 
 /* DECIMAL
@@ -3940,7 +4087,7 @@ HRESULT WINAPI VarCyMulI8(const CY cyLeft, LONG64 llRight, CY* pCyOut)
  */
 HRESULT WINAPI VarDecFromUI1(BYTE bIn, DECIMAL* pDecOut)
 {
-  return _VarDecFromUI1(bIn, pDecOut);
+  return VarDecFromUI4(bIn, pDecOut);
 }
 
 /************************************************************************
@@ -3957,7 +4104,7 @@ HRESULT WINAPI VarDecFromUI1(BYTE bIn, DECIMAL* pDecOut)
  */
 HRESULT WINAPI VarDecFromI2(SHORT sIn, DECIMAL* pDecOut)
 {
-  return _VarDecFromI2(sIn, pDecOut);
+  return VarDecFromI4(sIn, pDecOut);
 }
 
 /************************************************************************
@@ -4009,7 +4156,7 @@ HRESULT WINAPI VarDecFromR4(FLOAT fltIn, DECIMAL* pDecOut)
   WCHAR buff[256];
 
   sprintfW( buff, szFloatFormatW, fltIn );
-  return _VarDecFromStr(buff, LOCALE_EN_US, 0, pDecOut);
+  return VarDecFromStr(buff, LOCALE_EN_US, 0, pDecOut);
 }
 
 /************************************************************************
@@ -4029,7 +4176,7 @@ HRESULT WINAPI VarDecFromR8(double dblIn, DECIMAL* pDecOut)
   WCHAR buff[256];
 
   sprintfW( buff, szDoubleFormatW, dblIn );
-  return _VarDecFromStr(buff, LOCALE_EN_US, 0, pDecOut);
+  return VarDecFromStr(buff, LOCALE_EN_US, 0, pDecOut);
 }
 
 /************************************************************************
@@ -4046,7 +4193,7 @@ HRESULT WINAPI VarDecFromR8(double dblIn, DECIMAL* pDecOut)
  */
 HRESULT WINAPI VarDecFromDate(DATE dateIn, DECIMAL* pDecOut)
 {
-  return _VarDecFromDate(dateIn, pDecOut);
+  return VarDecFromR8(dateIn, pDecOut);
 }
 
 /************************************************************************
@@ -4097,7 +4244,7 @@ HRESULT WINAPI VarDecFromCy(CY cyIn, DECIMAL* pDecOut)
  */
 HRESULT WINAPI VarDecFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DECIMAL* pDecOut)
 {
-  return _VarDecFromStr(strIn, lcid, dwFlags, pDecOut);
+  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pDecOut, VT_DECIMAL);
 }
 
 /************************************************************************
@@ -4116,7 +4263,7 @@ HRESULT WINAPI VarDecFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DECIMAL*
  */
 HRESULT WINAPI VarDecFromDisp(IDispatch* pdispIn, LCID lcid, DECIMAL* pDecOut)
 {
-  return _VarDecFromDisp(pdispIn, lcid, pDecOut);
+  return VARIANT_FromDisp(pdispIn, lcid, pDecOut, VT_DECIMAL);
 }
 
 /************************************************************************
@@ -4165,7 +4312,7 @@ HRESULT WINAPI VarDecFromBool(VARIANT_BOOL bIn, DECIMAL* pDecOut)
  */
 HRESULT WINAPI VarDecFromI1(signed char cIn, DECIMAL* pDecOut)
 {
-  return _VarDecFromI1(cIn, pDecOut);
+  return VarDecFromI4(cIn, pDecOut);
 }
 
 /************************************************************************
@@ -4182,7 +4329,7 @@ HRESULT WINAPI VarDecFromI1(signed char cIn, DECIMAL* pDecOut)
  */
 HRESULT WINAPI VarDecFromUI2(USHORT usIn, DECIMAL* pDecOut)
 {
-  return _VarDecFromUI2(usIn, pDecOut);
+  return VarDecFromUI4(usIn, pDecOut);
 }
 
 /************************************************************************
@@ -4750,7 +4897,8 @@ HRESULT WINAPI VarDecCmpR8(const DECIMAL* pDecLeft, double dblRight)
  */
 HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromUI1(bIn, pBoolOut);
+  *pBoolOut = bIn ? VARIANT_TRUE : VARIANT_FALSE;
+  return S_OK;
 }
 
 /************************************************************************
@@ -4767,7 +4915,8 @@ HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL *pBoolOut)
  */
 HRESULT WINAPI VarBoolFromI2(SHORT sIn, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromI2(sIn, pBoolOut);
+  *pBoolOut = sIn ? VARIANT_TRUE : VARIANT_FALSE;
+  return S_OK;
 }
 
 /************************************************************************
@@ -4784,7 +4933,8 @@ HRESULT WINAPI VarBoolFromI2(SHORT sIn, VARIANT_BOOL *pBoolOut)
  */
 HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromI4(lIn, pBoolOut);
+  *pBoolOut = lIn ? VARIANT_TRUE : VARIANT_FALSE;
+  return S_OK;
 }
 
 /************************************************************************
@@ -4801,7 +4951,8 @@ HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL *pBoolOut)
  */
 HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromR4(fltIn, pBoolOut);
+  *pBoolOut = fltIn ? VARIANT_TRUE : VARIANT_FALSE;
+  return S_OK;
 }
 
 /************************************************************************
@@ -4818,7 +4969,8 @@ HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL *pBoolOut)
  */
 HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromR8(dblIn, pBoolOut);
+  *pBoolOut = dblIn ? VARIANT_TRUE : VARIANT_FALSE;
+  return S_OK;
 }
 
 /************************************************************************
@@ -4835,7 +4987,8 @@ HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL *pBoolOut)
  */
 HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromDate(dateIn, pBoolOut);
+  *pBoolOut = dateIn ? VARIANT_TRUE : VARIANT_FALSE;
+  return S_OK;
 }
 
 /************************************************************************
@@ -4852,7 +5005,8 @@ HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL *pBoolOut)
  */
 HRESULT WINAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromCy(cyIn, pBoolOut);
+  *pBoolOut = cyIn.int64 ? VARIANT_TRUE : VARIANT_FALSE;
+  return S_OK;
 }
 
 static BOOL VARIANT_GetLocalisedText(LANGID langId, DWORD dwId, WCHAR *lpszDest)
@@ -4979,9 +5133,8 @@ VarBoolFromStr_CheckLocalised:
     double d;
 
     /* If this string is a number, convert it as one */
-    hRes = _VarR8FromStr(strIn, lcid, dwFlags, &d);
-    if (SUCCEEDED(hRes))
-      hRes = _VarBoolFromR8(d, pBoolOut);
+    hRes = VarR8FromStr(strIn, lcid, dwFlags, &d);
+    if (SUCCEEDED(hRes)) *pBoolOut = d ? VARIANT_TRUE : VARIANT_FALSE;
   }
   return hRes;
 }
@@ -5004,7 +5157,7 @@ VarBoolFromStr_CheckLocalised:
  */
 HRESULT WINAPI VarBoolFromDisp(IDispatch* pdispIn, LCID lcid, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromDisp(pdispIn, lcid, pBoolOut);
+  return VARIANT_FromDisp(pdispIn, lcid, pBoolOut, VT_BOOL);
 }
 
 /************************************************************************
@@ -5021,7 +5174,8 @@ HRESULT WINAPI VarBoolFromDisp(IDispatch* pdispIn, LCID lcid, VARIANT_BOOL *pBoo
  */
 HRESULT WINAPI VarBoolFromI1(signed char cIn, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromI1(cIn, pBoolOut);
+  *pBoolOut = cIn ? VARIANT_TRUE : VARIANT_FALSE;
+  return S_OK;
 }
 
 /************************************************************************
@@ -5038,7 +5192,8 @@ HRESULT WINAPI VarBoolFromI1(signed char cIn, VARIANT_BOOL *pBoolOut)
  */
 HRESULT WINAPI VarBoolFromUI2(USHORT usIn, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromUI2(usIn, pBoolOut);
+  *pBoolOut = usIn ? VARIANT_TRUE : VARIANT_FALSE;
+  return S_OK;
 }
 
 /************************************************************************
@@ -5055,7 +5210,8 @@ HRESULT WINAPI VarBoolFromUI2(USHORT usIn, VARIANT_BOOL *pBoolOut)
  */
 HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromUI4(ulIn, pBoolOut);
+  *pBoolOut = ulIn ? VARIANT_TRUE : VARIANT_FALSE;
+  return S_OK;
 }
 
 /************************************************************************
@@ -5097,7 +5253,8 @@ HRESULT WINAPI VarBoolFromDec(DECIMAL* pDecIn, VARIANT_BOOL *pBoolOut)
  */
 HRESULT WINAPI VarBoolFromI8(LONG64 llIn, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromI8(llIn, pBoolOut);
+  *pBoolOut = llIn ? VARIANT_TRUE : VARIANT_FALSE;
+  return S_OK;
 }
 
 /************************************************************************
@@ -5114,7 +5271,8 @@ HRESULT WINAPI VarBoolFromI8(LONG64 llIn, VARIANT_BOOL *pBoolOut)
  */
 HRESULT WINAPI VarBoolFromUI8(ULONG64 ullIn, VARIANT_BOOL *pBoolOut)
 {
-  return _VarBoolFromUI8(ullIn, pBoolOut);
+  *pBoolOut = ullIn ? VARIANT_TRUE : VARIANT_FALSE;
+  return S_OK;
 }
 
 /* BSTR
@@ -5769,7 +5927,7 @@ HRESULT WINAPI VarBstrCmp(BSTR pbstrLeft, BSTR pbstrRight, LCID lcid, DWORD dwFl
  */
 HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut)
 {
-  return _VarDateFromUI1(bIn, pdateOut);
+  return VarR8FromUI1(bIn, pdateOut);
 }
 
 /******************************************************************************
@@ -5786,7 +5944,7 @@ HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut)
  */
 HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut)
 {
-  return _VarDateFromI2(sIn, pdateOut);
+  return VarR8FromI2(sIn, pdateOut);
 }
 
 /******************************************************************************
@@ -5803,7 +5961,7 @@ HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut)
  */
 HRESULT WINAPI VarDateFromI4(LONG lIn, DATE* pdateOut)
 {
-  return _VarDateFromI4(lIn, pdateOut);
+  return VarDateFromR8(lIn, pdateOut);
 }
 
 /******************************************************************************
@@ -5820,7 +5978,7 @@ HRESULT WINAPI VarDateFromI4(LONG lIn, DATE* pdateOut)
  */
 HRESULT WINAPI VarDateFromR4(FLOAT fltIn, DATE* pdateOut)
 {
-  return _VarDateFromR4(fltIn, pdateOut);
+  return VarR8FromR4(fltIn, pdateOut);
 }
 
 /******************************************************************************
@@ -5837,7 +5995,9 @@ HRESULT WINAPI VarDateFromR4(FLOAT fltIn, DATE* pdateOut)
  */
 HRESULT WINAPI VarDateFromR8(double dblIn, DATE* pdateOut)
 {
-  return _VarDateFromR8(dblIn, pdateOut);
+  if (dblIn <= (DATE_MIN - 1.0) || dblIn >= (DATE_MAX + 1.0)) return DISP_E_OVERFLOW;
+  *pdateOut = (DATE)dblIn;
+  return S_OK;
 }
 
 /**********************************************************************
@@ -5858,7 +6018,7 @@ HRESULT WINAPI VarDateFromR8(double dblIn, DATE* pdateOut)
  */
 HRESULT WINAPI VarDateFromDisp(IDispatch* pdispIn, LCID lcid, DATE* pdateOut)
 {
-  return _VarDateFromDisp(pdispIn, lcid, pdateOut);
+  return VARIANT_FromDisp(pdispIn, lcid, pdateOut, VT_DATE);
 }
 
 /******************************************************************************
@@ -5875,7 +6035,7 @@ HRESULT WINAPI VarDateFromDisp(IDispatch* pdispIn, LCID lcid, DATE* pdateOut)
  */
 HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut)
 {
-  return _VarDateFromBool(boolIn, pdateOut);
+  return VarR8FromBool(boolIn, pdateOut);
 }
 
 /**********************************************************************
@@ -5892,7 +6052,7 @@ HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut)
  */
 HRESULT WINAPI VarDateFromCy(CY cyIn, DATE* pdateOut)
 {
-  return _VarDateFromCy(cyIn, pdateOut);
+  return VarR8FromCy(cyIn, pdateOut);
 }
 
 /* Date string parsing */
@@ -6480,7 +6640,7 @@ HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pd
  */
 HRESULT WINAPI VarDateFromI1(signed char cIn, DATE* pdateOut)
 {
-  return _VarDateFromI1(cIn, pdateOut);
+  return VarR8FromI1(cIn, pdateOut);
 }
 
 /******************************************************************************
@@ -6497,7 +6657,7 @@ HRESULT WINAPI VarDateFromI1(signed char cIn, DATE* pdateOut)
  */
 HRESULT WINAPI VarDateFromUI2(USHORT uiIn, DATE* pdateOut)
 {
-  return _VarDateFromUI2(uiIn, pdateOut);
+  return VarR8FromUI2(uiIn, pdateOut);
 }
 
 /******************************************************************************
@@ -6514,7 +6674,7 @@ HRESULT WINAPI VarDateFromUI2(USHORT uiIn, DATE* pdateOut)
  */
 HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut)
 {
-  return _VarDateFromUI4(ulIn, pdateOut);
+  return VarDateFromR8(ulIn, pdateOut);
 }
 
 /**********************************************************************
@@ -6531,7 +6691,7 @@ HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut)
  */
 HRESULT WINAPI VarDateFromDec(DECIMAL *pdecIn, DATE* pdateOut)
 {
-  return _VarDateFromDec(pdecIn, pdateOut);
+  return VarR8FromDec(pdecIn, pdateOut);
 }
 
 /******************************************************************************
@@ -6549,7 +6709,9 @@ HRESULT WINAPI VarDateFromDec(DECIMAL *pdecIn, DATE* pdateOut)
  */
 HRESULT WINAPI VarDateFromI8(LONG64 llIn, DATE* pdateOut)
 {
-  return _VarDateFromI8(llIn, pdateOut);
+  if (llIn < DATE_MIN || llIn > DATE_MAX) return DISP_E_OVERFLOW;
+  *pdateOut = (DATE)llIn;
+  return S_OK;
 }
 
 /******************************************************************************
@@ -6567,5 +6729,7 @@ HRESULT WINAPI VarDateFromI8(LONG64 llIn, DATE* pdateOut)
  */
 HRESULT WINAPI VarDateFromUI8(ULONG64 ullIn, DATE* pdateOut)
 {
-  return _VarDateFromUI8(ullIn, pdateOut);
+  if (ullIn > DATE_MAX) return DISP_E_OVERFLOW;
+  *pdateOut = (DATE)ullIn;
+  return S_OK;
 }