-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
#include "ole2.h"
#include "olectl.h"
#include "oleauto.h"
-
-#include "tmarshal.h"
+#include "typelib.h"
#include "wine/debug.h"
extern void _get_STDPIC_CF(LPVOID);
/***********************************************************************
- * DllGetClassObject (OLEAUT32.1)
+ * DllGetClassObject (OLEAUT32.@)
*/
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*/
}
}
/***********************************************************************
- * DllCanUnloadNow (OLEAUT32.410)
+ * DllCanUnloadNow (OLEAUT32.@)
*
* Determine if this dll can be unloaded from the callers address space.
*
*/
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:
-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()
* 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.
*/
* 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));
+}
/***********************************************************************
/*
* 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
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.
*/
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));
/* 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));
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);
}
/************************************************************************
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);
}
/************************************************************************
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);
}
/************************************************************************
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;
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;
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
);
EXCEPINFO* pExepInfo,
UINT* puArgErr)
{
- _ICOM_THIS_From_IDispatch(IFont, iface);
+ OLEFontImpl *this = impl_from_IDispatch(iface);
OLEFontImpl *xthis = (OLEFontImpl*)this;
switch (dispIdMember) {
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;
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]));
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]));
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]));
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]));
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:
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;
}
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);
}
/************************************************************************
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);
}
/************************************************************************
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);
}
/************************************************************************
BYTE bStringSize;
INT len;
- _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
+ OLEFontImpl *this = impl_from_IPersistStream(iface);
/*
* Read the version byte
BYTE bAttributes;
BYTE bStringSize;
- _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
+ OLEFontImpl *this = impl_from_IPersistStream(iface);
/*
* Read the version byte
IPersistStream* iface,
ULARGE_INTEGER* pcbSize)
{
- _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
+ OLEFontImpl *this = impl_from_IPersistStream(iface);
if (pcbSize==NULL)
return E_POINTER;
REFIID riid,
VOID** ppvoid)
{
- _ICOM_THIS_From_IConnectionPointContainer(OLEFontImpl, iface);
+ OLEFontImpl *this = impl_from_IConnectionPointContainer(iface);
return IFont_QueryInterface((IFont*)this, riid, ppvoid);
}
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);
}
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);
}
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;
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) {
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(
VARIANT rawAttr;
VARIANT valueAttr;
HRESULT iRes = S_OK;
- _ICOM_THIS_From_IPersistPropertyBag(IFont, iface);
+ OLEFontImpl *this = impl_from_IPersistPropertyBag(iface);
VariantInit(&rawAttr);
VariantInit(&valueAttr);
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
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(
* 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;
/*
* 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.
/*
* 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);
}
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.
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;
}
/************************************************************************
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;
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;
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);
}
/************************************************************************
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);
}
/************************************************************************
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);
}
/************************************************************************
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;
}
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;
}
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);
ULONG dummy;
int iSerializeResult = 0;
- ICOM_THIS_From_IPersistStream(OLEPictureImpl, iface);
+ OLEPictureImpl *This = impl_from_IPersistStream(iface);
switch (This->desc.picType) {
case PICTYPE_ICON:
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;
}
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);
}
/************************************************************************
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);
}
/************************************************************************
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);
}
/************************************************************************
};
/***********************************************************************
- * DllRegisterServer (OLEAUT32.320)
+ * DllRegisterServer (OLEAUT32.@)
*/
HRESULT WINAPI DllRegisterServer(void)
{
}
/***********************************************************************
- * DllUnregisterServer (OLEAUT32.321)
+ * DllUnregisterServer (OLEAUT32.@)
*/
HRESULT WINAPI DllUnregisterServer(void)
{
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;
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;
static HRESULT
_marshal_interface(marshal_state *buf, REFIID riid, LPUNKNOWN pUnk) {
- LPUNKNOWN newiface = NULL;
LPBYTE tempbuf = NULL;
IStream *pStm = NULL;
STATSTG ststg;
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) {
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;
hres = xbuf_add(buf,tempbuf,ststg.cbSize.u.LowPart);
HeapFree(GetProcessHeap(),0,tempbuf);
- IUnknown_Release(newiface);
IStream_Release(pStm);
return hres;
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;
}
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;
}
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;
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 {
ULONG status;
BSTR fname,iname;
BSTR names[10];
- int nrofnames;
+ UINT nrofnames;
int is_idispatch_getidsofnames = 0;
DWORD remoteresult = 0;
ITypeInfo *tinfo;
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;
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
TMStubImpl_CountRefs(LPRPCSTUBBUFFER iface) {
TMStubImpl *This = (TMStubImpl *)iface;
+ FIXME("()\n");
return This->ref; /*FIXME? */
}
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;
while (hr != S_OK)
{
- DWORD dwPathLen = sizeof(Path);
+ LONG dwPathLen = sizeof(Path);
get_lcid_subkey( myLCID, SYS_WIN32, buffer );
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);
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;
paramName = NULL;
HaveOffs = TRUE;
}
- else if(!isalnum(*(paramName-1)))
+ else if(paramName[-1] && !isalnum(paramName[-1]))
HaveOffs = TRUE;
pArg++;
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;
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",
}
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);
(*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);
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(
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 */
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;
}
}
return S_OK;
}
}
+ WARN("member %ld not found\n", memid);
return TYPE_E_ELEMENTNOTFOUND;
}
ITypeLib *pTLib = NULL;
if(pRefType->pImpTLInfo == TLB_REF_INTERNAL) {
- int Index;
+ UINT Index;
result = ITypeInfo_GetContainingTypeLib(iface, &pTLib, &Index);
} else {
if(pRefType->pImpTLInfo->pImpTypeLib) {
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);
}
DESCKIND * pDescKind,
BINDPTR * pBindPtr)
{
- ICOM_THIS_From_ITypeComp(ITypeInfoImpl, iface);
+ ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
TLBFuncDesc * pFDesc;
TLBVarDesc * pVDesc;
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
-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
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
{
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);
ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
ITypeLib *container;
- int index;
+ UINT index;
HRESULT res;
TRACE("(%p,%p,%p)\n", iface, pTInfo, phRefType);
*/
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);
}
*/
static ULONG WINAPI ITypeInfo2_fnAddRef(ITypeInfo2 * iface)
{
- ICOM_THIS_From_ITypeInfo2(ICreateTypeInfo2Impl, iface);
+ ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
return ICreateTypeInfo2_AddRef((ICreateTypeInfo2 *)This);
}
*/
static ULONG WINAPI ITypeInfo2_fnRelease(ITypeInfo2 * iface)
{
- ICOM_THIS_From_ITypeInfo2(ICreateTypeInfo2Impl, iface);
+ ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
return ICreateTypeInfo2_Release((ICreateTypeInfo2 *)This);
}
ITypeLib** ppTLib,
UINT* pIndex)
{
- ICOM_THIS_From_ITypeInfo2(ICreateTypeInfo2Impl, iface);
+ ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
TRACE("(%p,%p,%p)\n", iface, ppTLib, pIndex);
*/
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);
}
*/
static ULONG WINAPI ITypeLib2_fnAddRef(ITypeLib2 * iface)
{
- ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+ ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
return ICreateTypeLib2_AddRef((ICreateTypeLib2 *)This);
}
*/
static ULONG WINAPI ITypeLib2_fnRelease(ITypeLib2 * iface)
{
- ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+ ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
return ICreateTypeLib2_Release((ICreateTypeLib2 *)This);
}
static UINT WINAPI ITypeLib2_fnGetTypeInfoCount(
ITypeLib2 * iface)
{
- ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+ ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
TRACE("(%p)\n", iface);
UINT index,
ITypeInfo** ppTInfo)
{
- ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+ ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
TRACE("(%p,%d,%p)\n", iface, index, ppTInfo);
UINT index,
TYPEKIND* pTKind)
{
- ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+ ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
TRACE("(%p,%d,%p)\n", iface, index, pTKind);
REFGUID guid,
ITypeInfo** ppTinfo)
{
- ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+ ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
int guidoffset;
int typeinfo;
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;
}
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;
}
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;
}
ULONG lHashVal,
BOOL* pfName)
{
- ICOM_THIS_From_ITypeLib2(ICreateTypeLib2Impl, iface);
+ ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
char *encoded_name;
int nameoffset;
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;
}
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);
}
/******************************************************************************
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;
}
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;
}
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;
}
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;
}
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;
* - 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)
}
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
}
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);
#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
{
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' };
}
}
+/* 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;
}
/* 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;
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
*/
*/
HRESULT WINAPI VarI1FromR4(FLOAT fltIn, signed char* pcOut)
{
- return _VarI1FromR4(fltIn, pcOut);
+ return VarI1FromR8(fltIn, 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;
}
*/
HRESULT WINAPI VarI1FromDate(DATE dateIn, signed char* pcOut)
{
- return _VarI1FromDate(dateIn, pcOut);
+ return VarI1FromR8(dateIn, pcOut);
}
/************************************************************************
{
LONG i = I1_MAX + 1;
- _VarI4FromCy(cyIn, &i);
+ VarI4FromCy(cyIn, &i);
return _VarI1FromI4(i, 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);
}
/************************************************************************
*/
HRESULT WINAPI VarI1FromDisp(IDispatch* pdispIn, LCID lcid, signed char* pcOut)
{
- return _VarI1FromDisp(pdispIn, lcid, pcOut);
+ return VARIANT_FromDisp(pdispIn, lcid, pcOut, VT_I1);
}
/************************************************************************
LONG64 i64;
HRESULT hRet;
- hRet = _VarI8FromDec(pdecIn, &i64);
+ hRet = VarI8FromDec(pdecIn, &i64);
if (SUCCEEDED(hRet))
hRet = _VarI1FromI8(i64, pcOut);
*/
HRESULT WINAPI VarUI1FromR4(FLOAT fltIn, BYTE* pbOut)
{
- return _VarUI1FromR4(fltIn, pbOut);
+ return VarUI1FromR8(fltIn, 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;
}
{
ULONG i = UI1_MAX + 1;
- _VarUI4FromCy(cyIn, &i);
+ VarUI4FromCy(cyIn, &i);
return _VarUI1FromUI4(i, pbOut);
}
*/
HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
{
- return _VarUI1FromDate(dateIn, pbOut);
+ return VarUI1FromR8(dateIn, 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);
}
/************************************************************************
*/
HRESULT WINAPI VarUI1FromDisp(IDispatch* pdispIn, LCID lcid, BYTE* pbOut)
{
- return _VarUI1FromDisp(pdispIn, lcid, pbOut);
+ return VARIANT_FromDisp(pdispIn, lcid, pbOut, VT_UI1);
}
/************************************************************************
LONG64 i64;
HRESULT hRet;
- hRet = _VarI8FromDec(pdecIn, &i64);
+ hRet = VarI8FromDec(pdecIn, &i64);
if (SUCCEEDED(hRet))
hRet = _VarUI1FromI8(i64, pbOut);
*/
HRESULT WINAPI VarI2FromR4(FLOAT fltIn, SHORT* psOut)
{
- return _VarI2FromR4(fltIn, psOut);
+ return VarI2FromR8(fltIn, 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;
}
{
LONG i = I2_MAX + 1;
- _VarI4FromCy(cyIn, &i);
+ VarI4FromCy(cyIn, &i);
return _VarI2FromI4(i, psOut);
}
*/
HRESULT WINAPI VarI2FromDate(DATE dateIn, SHORT* psOut)
{
- return _VarI2FromDate(dateIn, psOut);
+ return VarI2FromR8(dateIn, 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);
}
/************************************************************************
*/
HRESULT WINAPI VarI2FromDisp(IDispatch* pdispIn, LCID lcid, SHORT* psOut)
{
- return _VarI2FromDisp(pdispIn, lcid, psOut);
+ return VARIANT_FromDisp(pdispIn, lcid, psOut, VT_I2);
}
/************************************************************************
LONG64 i64;
HRESULT hRet;
- hRet = _VarI8FromDec(pdecIn, &i64);
+ hRet = VarI8FromDec(pdecIn, &i64);
if (SUCCEEDED(hRet))
hRet = _VarI2FromI8(i64, psOut);
*/
HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* pusOut)
{
- return _VarUI2FromR4(fltIn, pusOut);
+ return VarUI2FromR8(fltIn, 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;
}
*/
HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* pusOut)
{
- return _VarUI2FromDate(dateIn, pusOut);
+ return VarUI2FromR8(dateIn, pusOut);
}
/************************************************************************
{
ULONG i = UI2_MAX + 1;
- _VarUI4FromCy(cyIn, &i);
+ VarUI4FromCy(cyIn, &i);
return _VarUI2FromUI4(i, 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);
}
/************************************************************************
*/
HRESULT WINAPI VarUI2FromDisp(IDispatch* pdispIn, LCID lcid, USHORT* pusOut)
{
- return _VarUI2FromDisp(pdispIn, lcid, pusOut);
+ return VARIANT_FromDisp(pdispIn, lcid, pusOut, VT_UI2);
}
/************************************************************************
LONG64 i64;
HRESULT hRet;
- hRet = _VarI8FromDec(pdecIn, &i64);
+ hRet = VarI8FromDec(pdecIn, &i64);
if (SUCCEEDED(hRet))
hRet = _VarUI2FromI8(i64, pusOut);
*/
HRESULT WINAPI VarI4FromR4(FLOAT fltIn, LONG *piOut)
{
- return _VarI4FromR4(fltIn, piOut);
+ return VarI4FromR8(fltIn, 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;
}
HRESULT WINAPI VarI4FromCy(CY cyIn, LONG *piOut)
{
double d = cyIn.int64 / CY_MULTIPLIER_F;
- return _VarI4FromR8(d, piOut);
+ return VarI4FromR8(d, piOut);
}
/************************************************************************
*/
HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG *piOut)
{
- return _VarI4FromDate(dateIn, piOut);
+ return VarI4FromR8(dateIn, 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);
}
/************************************************************************
*/
HRESULT WINAPI VarI4FromDisp(IDispatch* pdispIn, LCID lcid, LONG *piOut)
{
- return _VarI4FromDisp(pdispIn, lcid, piOut);
+ return VARIANT_FromDisp(pdispIn, lcid, piOut, VT_I4);
}
/************************************************************************
LONG64 i64;
HRESULT hRet;
- hRet = _VarI8FromDec(pdecIn, &i64);
+ hRet = VarI8FromDec(pdecIn, &i64);
if (SUCCEEDED(hRet))
hRet = _VarI4FromI8(i64, piOut);
*/
HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG *pulOut)
{
- return _VarUI4FromR4(fltIn, pulOut);
+ return VarUI4FromR8(fltIn, 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;
}
*/
HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG *pulOut)
{
- return _VarUI4FromDate(dateIn, pulOut);
+ return VarUI4FromR8(dateIn, pulOut);
}
/************************************************************************
HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG *pulOut)
{
double d = cyIn.int64 / CY_MULTIPLIER_F;
- return _VarUI4FromR8(d, pulOut);
+ return VarUI4FromR8(d, 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);
}
/************************************************************************
*/
HRESULT WINAPI VarUI4FromDisp(IDispatch* pdispIn, LCID lcid, ULONG *pulOut)
{
- return _VarUI4FromDisp(pdispIn, lcid, pulOut);
+ return VARIANT_FromDisp(pdispIn, lcid, pulOut, VT_UI4);
}
/************************************************************************
LONG64 i64;
HRESULT hRet;
- hRet = _VarI8FromDec(pdecIn, &i64);
+ hRet = VarI8FromDec(pdecIn, &i64);
if (SUCCEEDED(hRet))
hRet = _VarUI4FromI8(i64, pulOut);
*/
HRESULT WINAPI VarI8FromR4(FLOAT fltIn, LONG64* pi64Out)
{
- return _VarI8FromR4(fltIn, pi64Out);
+ return VarI8FromR8(fltIn, 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;
}
*/
HRESULT WINAPI VarI8FromDate(DATE dateIn, LONG64* pi64Out)
{
- return _VarI8FromDate(dateIn, pi64Out);
+ return VarI8FromR8(dateIn, 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);
}
/************************************************************************
*/
HRESULT WINAPI VarI8FromDisp(IDispatch* pdispIn, LCID lcid, LONG64* pi64Out)
{
- return _VarI8FromDisp(pdispIn, lcid, pi64Out);
+ return VARIANT_FromDisp(pdispIn, lcid, pi64Out, VT_I8);
}
/************************************************************************
*/
HRESULT WINAPI VarI8FromBool(VARIANT_BOOL boolIn, LONG64* pi64Out)
{
- return _VarI8FromBool(boolIn, pi64Out);
+ return VarI8FromI2(boolIn, pi64Out);
}
/************************************************************************
HRESULT hRet;
double dbl;
- hRet = _VarR8FromDec(pdecIn, &dbl);
+ hRet = VarR8FromDec(pdecIn, &dbl);
if (SUCCEEDED(hRet))
hRet = VarI8FromR8(dbl, pi64Out);
return hRet;
*/
HRESULT WINAPI VarUI8FromR4(FLOAT fltIn, ULONG64* pui64Out)
{
- return _VarUI8FromR4(fltIn, pui64Out);
+ return VarUI8FromR8(fltIn, 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;
}
*/
HRESULT WINAPI VarUI8FromDate(DATE dateIn, ULONG64* pui64Out)
{
- return _VarUI8FromDate(dateIn, pui64Out);
+ return VarUI8FromR8(dateIn, 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);
}
/************************************************************************
*/
HRESULT WINAPI VarUI8FromDisp(IDispatch* pdispIn, LCID lcid, ULONG64* pui64Out)
{
- return _VarUI8FromDisp(pdispIn, lcid, pui64Out);
+ return VARIANT_FromDisp(pdispIn, lcid, pui64Out, VT_UI8);
}
/************************************************************************
*/
HRESULT WINAPI VarUI8FromBool(VARIANT_BOOL boolIn, ULONG64* pui64Out)
{
- return _VarUI8FromBool(boolIn, pui64Out);
+ return VarI8FromI2(boolIn, (LONG64 *)pui64Out);
}
/************************************************************************
* VarUI8FromI1 (OLEAUT32.438)
HRESULT hRet;
double dbl;
- hRet = _VarR8FromDec(pdecIn, &dbl);
+ hRet = VarR8FromDec(pdecIn, &dbl);
if (SUCCEEDED(hRet))
hRet = VarUI8FromR8(dbl, pui64Out);
return hRet;
*/
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;
}
/************************************************************************
*/
HRESULT WINAPI VarR4FromCy(CY cyIn, float *pFltOut)
{
- return _VarR4FromCy(cyIn, pFltOut);
+ *pFltOut = (double)cyIn.int64 / CY_MULTIPLIER_F;
+ return S_OK;
}
/************************************************************************
*/
HRESULT WINAPI VarR4FromDate(DATE dateIn, float *pFltOut)
{
- return _VarR4FromDate(dateIn, pFltOut);
+ return VarR4FromR8(dateIn, 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);
}
/************************************************************************
*/
HRESULT WINAPI VarR4FromDisp(IDispatch* pdispIn, LCID lcid, float *pFltOut)
{
- return _VarR4FromDisp(pdispIn, lcid, pFltOut);
+ return VARIANT_FromDisp(pdispIn, lcid, pFltOut, VT_R4);
}
/************************************************************************
*/
HRESULT WINAPI VarR4FromBool(VARIANT_BOOL boolIn, float *pFltOut)
{
- return _VarR4FromBool(boolIn, pFltOut);
+ return VarR4FromI2(boolIn, pFltOut);
}
/************************************************************************
*/
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);
}
/************************************************************************
*/
HRESULT WINAPI VarR8FromDisp(IDispatch* pdispIn, LCID lcid, double *pDblOut)
{
- return _VarR8FromDisp(pdispIn, lcid, pDblOut);
+ return VARIANT_FromDisp(pdispIn, lcid, pDblOut, VT_R8);
}
/************************************************************************
*/
HRESULT WINAPI VarR8FromBool(VARIANT_BOOL boolIn, double *pDblOut)
{
- return _VarR8FromBool(boolIn, pDblOut);
+ return VarR8FromI2(boolIn, pDblOut);
}
/************************************************************************
*/
HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pCyOut)
{
- return _VarCyFromUI1(bIn, pCyOut);
+ return VarCyFromR8(bIn, pCyOut);
}
/************************************************************************
*/
HRESULT WINAPI VarCyFromI2(SHORT sIn, CY* pCyOut)
{
- return _VarCyFromI2(sIn, pCyOut);
+ return VarCyFromR8(sIn, pCyOut);
}
/************************************************************************
*/
HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pCyOut)
{
- return _VarCyFromI4(lIn, pCyOut);
+ return VarCyFromR8(lIn, pCyOut);
}
/************************************************************************
*/
HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pCyOut)
{
- return _VarCyFromR4(fltIn, pCyOut);
+ return VarCyFromR8(fltIn, 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;
}
*/
HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pCyOut)
{
- return _VarCyFromDate(dateIn, pCyOut);
+ return VarCyFromR8(dateIn, 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);
}
/************************************************************************
*/
HRESULT WINAPI VarCyFromDisp(IDispatch* pdispIn, LCID lcid, CY* pCyOut)
{
- return _VarCyFromDisp(pdispIn, lcid, pCyOut);
+ return VARIANT_FromDisp(pdispIn, lcid, pCyOut, VT_CY);
}
/************************************************************************
*/
HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pCyOut)
{
- return _VarCyFromBool(boolIn, pCyOut);
+ return VarCyFromR8(boolIn, pCyOut);
}
/************************************************************************
*/
HRESULT WINAPI VarCyFromI1(signed char cIn, CY* pCyOut)
{
- return _VarCyFromI1(cIn, pCyOut);
+ return VarCyFromR8(cIn, pCyOut);
}
/************************************************************************
*/
HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pCyOut)
{
- return _VarCyFromUI2(usIn, pCyOut);
+ return VarCyFromR8(usIn, pCyOut);
}
/************************************************************************
*/
HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pCyOut)
{
- return _VarCyFromUI4(ulIn, pCyOut);
+ return VarCyFromR8(ulIn, 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;
}
*/
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;
}
/************************************************************************
*/
HRESULT WINAPI VarCyFromUI8(ULONG64 ullIn, CY* pCyOut)
{
- return _VarCyFromUI8(ullIn, pCyOut);
+ return VarCyFromR8(ullIn, pCyOut);
}
/************************************************************************
_VarR8FromCy(cyLeft, &l);
_VarR8FromCy(cyRight, &r);
l = l + r;
- return _VarCyFromR8(l, pCyOut);
+ return VarCyFromR8(l, pCyOut);
}
/************************************************************************
_VarR8FromCy(cyLeft, &l);
_VarR8FromCy(cyRight, &r);
l = l * r;
- return _VarCyFromR8(l, pCyOut);
+ return VarCyFromR8(l, pCyOut);
}
/************************************************************************
_VarR8FromCy(cyLeft, &d);
d = d * lRight;
- return _VarCyFromR8(d, pCyOut);
+ return VarCyFromR8(d, pCyOut);
}
/************************************************************************
_VarR8FromCy(cyLeft, &l);
_VarR8FromCy(cyRight, &r);
l = l - r;
- return _VarCyFromR8(l, pCyOut);
+ return VarCyFromR8(l, 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;
}
}
HRESULT hRet;
CY cyRight;
- hRet = _VarCyFromR8(dblRight, &cyRight);
+ hRet = VarCyFromR8(dblRight, &cyRight);
if (SUCCEEDED(hRet))
hRet = VarCyCmp(cyLeft, cyRight);
_VarR8FromCy(cyLeft, &d);
d = d * (double)llRight;
- return _VarCyFromR8(d, pCyOut);
+ return VarCyFromR8(d, pCyOut);
}
/* DECIMAL
*/
HRESULT WINAPI VarDecFromUI1(BYTE bIn, DECIMAL* pDecOut)
{
- return _VarDecFromUI1(bIn, pDecOut);
+ return VarDecFromUI4(bIn, pDecOut);
}
/************************************************************************
*/
HRESULT WINAPI VarDecFromI2(SHORT sIn, DECIMAL* pDecOut)
{
- return _VarDecFromI2(sIn, pDecOut);
+ return VarDecFromI4(sIn, pDecOut);
}
/************************************************************************
WCHAR buff[256];
sprintfW( buff, szFloatFormatW, fltIn );
- return _VarDecFromStr(buff, LOCALE_EN_US, 0, pDecOut);
+ return VarDecFromStr(buff, LOCALE_EN_US, 0, pDecOut);
}
/************************************************************************
WCHAR buff[256];
sprintfW( buff, szDoubleFormatW, dblIn );
- return _VarDecFromStr(buff, LOCALE_EN_US, 0, pDecOut);
+ return VarDecFromStr(buff, LOCALE_EN_US, 0, pDecOut);
}
/************************************************************************
*/
HRESULT WINAPI VarDecFromDate(DATE dateIn, DECIMAL* pDecOut)
{
- return _VarDecFromDate(dateIn, pDecOut);
+ return VarDecFromR8(dateIn, 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);
}
/************************************************************************
*/
HRESULT WINAPI VarDecFromDisp(IDispatch* pdispIn, LCID lcid, DECIMAL* pDecOut)
{
- return _VarDecFromDisp(pdispIn, lcid, pDecOut);
+ return VARIANT_FromDisp(pdispIn, lcid, pDecOut, VT_DECIMAL);
}
/************************************************************************
*/
HRESULT WINAPI VarDecFromI1(signed char cIn, DECIMAL* pDecOut)
{
- return _VarDecFromI1(cIn, pDecOut);
+ return VarDecFromI4(cIn, pDecOut);
}
/************************************************************************
*/
HRESULT WINAPI VarDecFromUI2(USHORT usIn, DECIMAL* pDecOut)
{
- return _VarDecFromUI2(usIn, pDecOut);
+ return VarDecFromUI4(usIn, pDecOut);
}
/************************************************************************
*/
HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL *pBoolOut)
{
- return _VarBoolFromUI1(bIn, pBoolOut);
+ *pBoolOut = bIn ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
}
/************************************************************************
*/
HRESULT WINAPI VarBoolFromI2(SHORT sIn, VARIANT_BOOL *pBoolOut)
{
- return _VarBoolFromI2(sIn, pBoolOut);
+ *pBoolOut = sIn ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
}
/************************************************************************
*/
HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL *pBoolOut)
{
- return _VarBoolFromI4(lIn, pBoolOut);
+ *pBoolOut = lIn ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
}
/************************************************************************
*/
HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL *pBoolOut)
{
- return _VarBoolFromR4(fltIn, pBoolOut);
+ *pBoolOut = fltIn ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
}
/************************************************************************
*/
HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL *pBoolOut)
{
- return _VarBoolFromR8(dblIn, pBoolOut);
+ *pBoolOut = dblIn ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
}
/************************************************************************
*/
HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL *pBoolOut)
{
- return _VarBoolFromDate(dateIn, pBoolOut);
+ *pBoolOut = dateIn ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
}
/************************************************************************
*/
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)
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;
}
*/
HRESULT WINAPI VarBoolFromDisp(IDispatch* pdispIn, LCID lcid, VARIANT_BOOL *pBoolOut)
{
- return _VarBoolFromDisp(pdispIn, lcid, pBoolOut);
+ return VARIANT_FromDisp(pdispIn, lcid, pBoolOut, VT_BOOL);
}
/************************************************************************
*/
HRESULT WINAPI VarBoolFromI1(signed char cIn, VARIANT_BOOL *pBoolOut)
{
- return _VarBoolFromI1(cIn, pBoolOut);
+ *pBoolOut = cIn ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
}
/************************************************************************
*/
HRESULT WINAPI VarBoolFromUI2(USHORT usIn, VARIANT_BOOL *pBoolOut)
{
- return _VarBoolFromUI2(usIn, pBoolOut);
+ *pBoolOut = usIn ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
}
/************************************************************************
*/
HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL *pBoolOut)
{
- return _VarBoolFromUI4(ulIn, pBoolOut);
+ *pBoolOut = ulIn ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
}
/************************************************************************
*/
HRESULT WINAPI VarBoolFromI8(LONG64 llIn, VARIANT_BOOL *pBoolOut)
{
- return _VarBoolFromI8(llIn, pBoolOut);
+ *pBoolOut = llIn ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
}
/************************************************************************
*/
HRESULT WINAPI VarBoolFromUI8(ULONG64 ullIn, VARIANT_BOOL *pBoolOut)
{
- return _VarBoolFromUI8(ullIn, pBoolOut);
+ *pBoolOut = ullIn ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
}
/* BSTR
*/
HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut)
{
- return _VarDateFromUI1(bIn, pdateOut);
+ return VarR8FromUI1(bIn, pdateOut);
}
/******************************************************************************
*/
HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut)
{
- return _VarDateFromI2(sIn, pdateOut);
+ return VarR8FromI2(sIn, pdateOut);
}
/******************************************************************************
*/
HRESULT WINAPI VarDateFromI4(LONG lIn, DATE* pdateOut)
{
- return _VarDateFromI4(lIn, pdateOut);
+ return VarDateFromR8(lIn, pdateOut);
}
/******************************************************************************
*/
HRESULT WINAPI VarDateFromR4(FLOAT fltIn, DATE* pdateOut)
{
- return _VarDateFromR4(fltIn, pdateOut);
+ return VarR8FromR4(fltIn, 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;
}
/**********************************************************************
*/
HRESULT WINAPI VarDateFromDisp(IDispatch* pdispIn, LCID lcid, DATE* pdateOut)
{
- return _VarDateFromDisp(pdispIn, lcid, pdateOut);
+ return VARIANT_FromDisp(pdispIn, lcid, pdateOut, VT_DATE);
}
/******************************************************************************
*/
HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut)
{
- return _VarDateFromBool(boolIn, pdateOut);
+ return VarR8FromBool(boolIn, pdateOut);
}
/**********************************************************************
*/
HRESULT WINAPI VarDateFromCy(CY cyIn, DATE* pdateOut)
{
- return _VarDateFromCy(cyIn, pdateOut);
+ return VarR8FromCy(cyIn, pdateOut);
}
/* Date string parsing */
*/
HRESULT WINAPI VarDateFromI1(signed char cIn, DATE* pdateOut)
{
- return _VarDateFromI1(cIn, pdateOut);
+ return VarR8FromI1(cIn, pdateOut);
}
/******************************************************************************
*/
HRESULT WINAPI VarDateFromUI2(USHORT uiIn, DATE* pdateOut)
{
- return _VarDateFromUI2(uiIn, pdateOut);
+ return VarR8FromUI2(uiIn, pdateOut);
}
/******************************************************************************
*/
HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut)
{
- return _VarDateFromUI4(ulIn, pdateOut);
+ return VarDateFromR8(ulIn, pdateOut);
}
/**********************************************************************
*/
HRESULT WINAPI VarDateFromDec(DECIMAL *pdecIn, DATE* pdateOut)
{
- return _VarDateFromDec(pdecIn, pdateOut);
+ return VarR8FromDec(pdecIn, 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;
}
/******************************************************************************
*/
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;
}
projects / reactos.git / commitdiff