From ae24453e12d84c0e480253f3b4c258a4fdaaf261 Mon Sep 17 00:00:00 2001 From: Amine Khaldi Date: Sat, 23 Nov 2019 12:05:03 +0100 Subject: [PATCH] [OLEAUT32] Sync with Wine Staging 4.18. CORE-16441 --- dll/win32/oleaut32/dispatch.c | 2 - dll/win32/oleaut32/oleaut.c | 160 ++--- dll/win32/oleaut32/olefont.c | 13 +- dll/win32/oleaut32/olepicture.c | 10 +- dll/win32/oleaut32/precomp.h | 4 +- dll/win32/oleaut32/recinfo.c | 9 +- dll/win32/oleaut32/safearray.c | 18 +- dll/win32/oleaut32/typelib.c | 1131 +++++++++++++++++-------------- dll/win32/oleaut32/varformat.c | 53 +- dll/win32/oleaut32/variant.c | 23 +- dll/win32/oleaut32/vartype.c | 35 +- media/doc/README.WINE | 2 +- 12 files changed, 776 insertions(+), 684 deletions(-) diff --git a/dll/win32/oleaut32/dispatch.c b/dll/win32/oleaut32/dispatch.c index a666d3dba1c..7e6398a1621 100644 --- a/dll/win32/oleaut32/dispatch.c +++ b/dll/win32/oleaut32/dispatch.c @@ -19,8 +19,6 @@ * */ -#include "config.h" - #include #include #include diff --git a/dll/win32/oleaut32/oleaut.c b/dll/win32/oleaut32/oleaut.c index ae76d245d24..87606bbf344 100644 --- a/dll/win32/oleaut32/oleaut.c +++ b/dll/win32/oleaut32/oleaut.c @@ -18,8 +18,6 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ -#include "config.h" - #include #include #include @@ -41,7 +39,6 @@ #include "oleaut32_oaidl.h" #include "wine/debug.h" -#include "wine/unicode.h" WINE_DEFAULT_DEBUG_CHANNEL(ole); WINE_DECLARE_DEBUG_CHANNEL(heap); @@ -877,7 +874,7 @@ static HRESULT reg_get_typelib_module(REFIID iid, WCHAR *module, DWORD len) sprintf(typelibkey, "Typelib\\%s\\%s\\0\\win%u", tlguid, ver, sizeof(void *) == 8 ? 64 : 32); #else snprintf(typelibkey, sizeof(typelibkey), "Typelib\\%s\\%s\\0\\win%u", tlguid, ver, sizeof(void *) == 8 ? 64 : 32); -#endif // __REACTOS__ +#endif /* __REACTOS__ */ tlfnlen = sizeof(tlfn); if (RegQueryValueA(HKEY_CLASSES_ROOT, typelibkey, tlfn, &tlfnlen)) { @@ -927,7 +924,7 @@ static HRESULT get_typeinfo_for_iid(REFIID iid, ITypeInfo **typeinfo) return hr; } -static HRESULT WINAPI typelib_ps_QueryInterface(IPSFactoryBuffer *iface, REFIID iid, void **out) +static HRESULT WINAPI dispatch_typelib_ps_QueryInterface(IPSFactoryBuffer *iface, REFIID iid, void **out) { if (IsEqualIID(iid, &IID_IPSFactoryBuffer) || IsEqualIID(iid, &IID_IUnknown)) { @@ -940,135 +937,121 @@ static HRESULT WINAPI typelib_ps_QueryInterface(IPSFactoryBuffer *iface, REFIID return E_NOINTERFACE; } -static ULONG WINAPI typelib_ps_AddRef(IPSFactoryBuffer *iface) +static ULONG WINAPI dispatch_typelib_ps_AddRef(IPSFactoryBuffer *iface) { return 2; } -static ULONG WINAPI typelib_ps_Release(IPSFactoryBuffer *iface) +static ULONG WINAPI dispatch_typelib_ps_Release(IPSFactoryBuffer *iface) { return 1; } -static HRESULT WINAPI typelib_ps_CreateProxy(IPSFactoryBuffer *iface, - IUnknown *outer, REFIID iid, IRpcProxyBuffer **proxy, void **out) +static HRESULT dispatch_create_proxy(IUnknown *outer, IRpcProxyBuffer **proxy, void **out) { - ITypeInfo *typeinfo; + IPSFactoryBuffer *factory; HRESULT hr; - hr = get_typeinfo_for_iid(iid, &typeinfo); + hr = OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, &IID_IPSFactoryBuffer, (void **)&factory); if (FAILED(hr)) return hr; - hr = CreateProxyFromTypeInfo(typeinfo, outer, iid, proxy, out); - if (FAILED(hr)) - ERR("Failed to create proxy, hr %#x.\n", hr); - - ITypeInfo_Release(typeinfo); + hr = IPSFactoryBuffer_CreateProxy(factory, outer, &IID_IDispatch, proxy, out); + IPSFactoryBuffer_Release(factory); return hr; } -static HRESULT WINAPI typelib_ps_CreateStub(IPSFactoryBuffer *iface, REFIID iid, - IUnknown *server, IRpcStubBuffer **stub) +static HRESULT WINAPI dispatch_typelib_ps_CreateProxy(IPSFactoryBuffer *iface, + IUnknown *outer, REFIID iid, IRpcProxyBuffer **proxy, void **out) { ITypeInfo *typeinfo; + TYPEATTR *attr; HRESULT hr; + if (IsEqualGUID(iid, &IID_IDispatch)) + return dispatch_create_proxy(outer, proxy, out); + hr = get_typeinfo_for_iid(iid, &typeinfo); if (FAILED(hr)) return hr; - hr = CreateStubFromTypeInfo(typeinfo, iid, server, stub); + hr = ITypeInfo_GetTypeAttr(typeinfo, &attr); if (FAILED(hr)) - ERR("Failed to create stub, hr %#x.\n", hr); - - ITypeInfo_Release(typeinfo); - return hr; -} - -static const IPSFactoryBufferVtbl typelib_ps_vtbl = -{ - typelib_ps_QueryInterface, - typelib_ps_AddRef, - typelib_ps_Release, - typelib_ps_CreateProxy, - typelib_ps_CreateStub, -}; - -static IPSFactoryBuffer typelib_ps = { &typelib_ps_vtbl }; - -extern void _get_STDFONT_CF(LPVOID *); -extern void _get_STDPIC_CF(LPVOID *); - -static HRESULT WINAPI PSDispatchFacBuf_QueryInterface(IPSFactoryBuffer *iface, REFIID riid, void **ppv) -{ - if (IsEqualIID(riid, &IID_IUnknown) || - IsEqualIID(riid, &IID_IPSFactoryBuffer)) { - IPSFactoryBuffer_AddRef(iface); - *ppv = iface; - return S_OK; + ITypeInfo_Release(typeinfo); + return hr; } - return E_NOINTERFACE; -} -static ULONG WINAPI PSDispatchFacBuf_AddRef(IPSFactoryBuffer *iface) -{ - return 2; -} + if (attr->typekind == TKIND_INTERFACE || (attr->wTypeFlags & TYPEFLAG_FDUAL)) + hr = CreateProxyFromTypeInfo(typeinfo, outer, iid, proxy, out); + else + hr = dispatch_create_proxy(outer, proxy, out); -static ULONG WINAPI PSDispatchFacBuf_Release(IPSFactoryBuffer *iface) -{ - return 1; + if (FAILED(hr)) + ERR("Failed to create proxy, hr %#x.\n", hr); + + ITypeInfo_ReleaseTypeAttr(typeinfo, attr); + ITypeInfo_Release(typeinfo); + return hr; } -static HRESULT WINAPI PSDispatchFacBuf_CreateProxy(IPSFactoryBuffer *iface, - IUnknown *outer, REFIID iid, IRpcProxyBuffer **proxy, void **obj) +static HRESULT dispatch_create_stub(IUnknown *server, IRpcStubBuffer **stub) { IPSFactoryBuffer *factory; HRESULT hr; - if (IsEqualIID(iid, &IID_IDispatch)) - { - hr = OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, &IID_IPSFactoryBuffer, (void **)&factory); - if (FAILED(hr)) return hr; + hr = OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, &IID_IPSFactoryBuffer, (void **)&factory); + if (FAILED(hr)) return hr; - hr = IPSFactoryBuffer_CreateProxy(factory, outer, iid, proxy, obj); - IPSFactoryBuffer_Release(factory); - return hr; - } - else - return IPSFactoryBuffer_CreateProxy(&typelib_ps, outer, iid, proxy, obj); + hr = IPSFactoryBuffer_CreateStub(factory, &IID_IDispatch, server, stub); + IPSFactoryBuffer_Release(factory); + return hr; } -static HRESULT WINAPI PSDispatchFacBuf_CreateStub(IPSFactoryBuffer *iface, +static HRESULT WINAPI dispatch_typelib_ps_CreateStub(IPSFactoryBuffer *iface, REFIID iid, IUnknown *server, IRpcStubBuffer **stub) { - IPSFactoryBuffer *factory; + ITypeInfo *typeinfo; + TYPEATTR *attr; HRESULT hr; - if (IsEqualIID(iid, &IID_IDispatch)) - { - hr = OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, &IID_IPSFactoryBuffer, (void **)&factory); - if (FAILED(hr)) return hr; + if (IsEqualGUID(iid, &IID_IDispatch)) + return dispatch_create_stub(server, stub); + + hr = get_typeinfo_for_iid(iid, &typeinfo); + if (FAILED(hr)) return hr; - hr = IPSFactoryBuffer_CreateStub(factory, iid, server, stub); - IPSFactoryBuffer_Release(factory); + hr = ITypeInfo_GetTypeAttr(typeinfo, &attr); + if (FAILED(hr)) + { + ITypeInfo_Release(typeinfo); return hr; } + + if (attr->typekind == TKIND_INTERFACE || (attr->wTypeFlags & TYPEFLAG_FDUAL)) + hr = CreateStubFromTypeInfo(typeinfo, iid, server, stub); else - return IPSFactoryBuffer_CreateStub(&typelib_ps, iid, server, stub); + hr = dispatch_create_stub(server, stub); + + if (FAILED(hr)) + ERR("Failed to create proxy, hr %#x.\n", hr); + + ITypeInfo_ReleaseTypeAttr(typeinfo, attr); + ITypeInfo_Release(typeinfo); + return hr; } -static const IPSFactoryBufferVtbl PSDispatchFacBuf_Vtbl = +static const IPSFactoryBufferVtbl dispatch_typelib_ps_vtbl = { - PSDispatchFacBuf_QueryInterface, - PSDispatchFacBuf_AddRef, - PSDispatchFacBuf_Release, - PSDispatchFacBuf_CreateProxy, - PSDispatchFacBuf_CreateStub + dispatch_typelib_ps_QueryInterface, + dispatch_typelib_ps_AddRef, + dispatch_typelib_ps_Release, + dispatch_typelib_ps_CreateProxy, + dispatch_typelib_ps_CreateStub, }; -/* This is the whole PSFactoryBuffer object, just the vtableptr */ -static const IPSFactoryBufferVtbl *pPSDispatchFacBuf = &PSDispatchFacBuf_Vtbl; +static IPSFactoryBuffer dispatch_typelib_ps = { &dispatch_typelib_ps_vtbl }; + +extern void _get_STDFONT_CF(LPVOID *); +extern void _get_STDPIC_CF(LPVOID *); /*********************************************************************** * DllGetClassObject (OLEAUT32.@) @@ -1090,14 +1073,9 @@ HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv) return S_OK; } } - if (IsEqualCLSID(rclsid, &CLSID_PSDispatch) && IsEqualIID(iid, &IID_IPSFactoryBuffer)) { - *ppv = &pPSDispatchFacBuf; - IPSFactoryBuffer_AddRef((IPSFactoryBuffer *)*ppv); - return S_OK; - } - if (IsEqualGUID(rclsid, &CLSID_PSOAInterface)) - return IPSFactoryBuffer_QueryInterface(&typelib_ps, iid, ppv); + if (IsEqualGUID(rclsid, &CLSID_PSDispatch) || IsEqualGUID(rclsid, &CLSID_PSOAInterface)) + return IPSFactoryBuffer_QueryInterface(&dispatch_typelib_ps, iid, ppv); if (IsEqualCLSID(rclsid, &CLSID_PSTypeComp) || IsEqualCLSID(rclsid, &CLSID_PSTypeInfo) || diff --git a/dll/win32/oleaut32/olefont.c b/dll/win32/oleaut32/olefont.c index 9628dc091e9..b82ffbf1b54 100644 --- a/dll/win32/oleaut32/olefont.c +++ b/dll/win32/oleaut32/olefont.c @@ -35,7 +35,6 @@ #include "wingdi.h" #include "winuser.h" #include "wine/list.h" -#include "wine/unicode.h" #include "objbase.h" #include "oleauto.h" /* for SysAllocString(....) */ #include "ole2.h" @@ -230,7 +229,7 @@ static HRESULT dec_ext_ref(HFONT hfont) static WCHAR *strdupW(const WCHAR* str) { WCHAR *ret; - DWORD size = (strlenW(str) + 1) * sizeof(WCHAR); + DWORD size = (lstrlenW(str) + 1) * sizeof(WCHAR); ret = HeapAlloc(GetProcessHeap(), 0, size); if(ret) @@ -1063,8 +1062,8 @@ static HRESULT WINAPI OLEFontImpl_IsEqual( return S_FALSE; /* Check from string */ - left_len = strlenW(left->description.lpstrName); - right_len = strlenW(right->description.lpstrName); + left_len = lstrlenW(left->description.lpstrName); + right_len = lstrlenW(right->description.lpstrName); ret = CompareStringW(0,0,left->description.lpstrName, left_len, right->description.lpstrName, right_len); if (ret != CSTR_EQUAL) @@ -1727,7 +1726,7 @@ static HRESULT WINAPI OLEFontImpl_Save( /* FontName */ if (this->description.lpstrName) string_size = WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName, - strlenW(this->description.lpstrName), NULL, 0, NULL, NULL ); + lstrlenW(this->description.lpstrName), NULL, 0, NULL, NULL ); else string_size = 0; @@ -1738,7 +1737,7 @@ static HRESULT WINAPI OLEFontImpl_Save( { if (!(writeBuffer = HeapAlloc( GetProcessHeap(), 0, string_size ))) return E_OUTOFMEMORY; WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName, - strlenW(this->description.lpstrName), + lstrlenW(this->description.lpstrName), writeBuffer, string_size, NULL, NULL ); IStream_Write(pOutStream, writeBuffer, string_size, &written); @@ -1774,7 +1773,7 @@ static HRESULT WINAPI OLEFontImpl_GetSizeMax( if (this->description.lpstrName!=0) pcbSize->u.LowPart += WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName, - strlenW(this->description.lpstrName), + lstrlenW(this->description.lpstrName), NULL, 0, NULL, NULL ); return S_OK; diff --git a/dll/win32/oleaut32/olepicture.c b/dll/win32/oleaut32/olepicture.c index 702fcde86de..05dd10b13c4 100644 --- a/dll/win32/oleaut32/olepicture.c +++ b/dll/win32/oleaut32/olepicture.c @@ -36,12 +36,6 @@ * */ -#include "config.h" -#include "wine/port.h" - -#ifdef HAVE_UNISTD_H -# include -#endif #include #include #include @@ -62,8 +56,6 @@ #include "initguid.h" #include "wincodec.h" #include "wine/debug.h" -#include "wine/unicode.h" -#include "wine/library.h" WINE_DEFAULT_DEBUG_CHANNEL(olepicture); @@ -2522,7 +2514,7 @@ HRESULT WINAPI OleLoadPicturePath( LPOLESTR szURLorPath, LPUNKNOWN punkCaller, *ppvRet = NULL; /* Convert file URLs to DOS paths. */ - if (strncmpW(szURLorPath, file, 5) == 0) { + if (wcsncmp(szURLorPath, file, 5) == 0) { DWORD size; hRes = CoInternetParseUrl(szURLorPath, PARSE_PATH_FROM_URL, 0, path_buf, ARRAY_SIZE(path_buf), &size, 0); diff --git a/dll/win32/oleaut32/precomp.h b/dll/win32/oleaut32/precomp.h index c5d3cb15e17..4e80f66694e 100644 --- a/dll/win32/oleaut32/precomp.h +++ b/dll/win32/oleaut32/precomp.h @@ -2,8 +2,6 @@ #ifndef _OLEAUT32_PCH_ #define _OLEAUT32_PCH_ -#include - #include #include @@ -18,12 +16,12 @@ #include #include #include +#include #include #include #include #include -#include #include "connpt.h" #include "variant.h" diff --git a/dll/win32/oleaut32/recinfo.c b/dll/win32/oleaut32/recinfo.c index ec65a523e38..44d46595e85 100644 --- a/dll/win32/oleaut32/recinfo.c +++ b/dll/win32/oleaut32/recinfo.c @@ -28,7 +28,6 @@ #include "oleauto.h" #include "variant.h" -#include "wine/unicode.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(ole); @@ -402,7 +401,7 @@ static HRESULT WINAPI IRecordInfoImpl_GetField(IRecordInfo *iface, PVOID pvData, return E_INVALIDARG; for(i=0; in_vars; i++) - if(!strcmpW(This->fields[i].name, szFieldName)) + if(!wcscmp(This->fields[i].name, szFieldName)) break; if(i == This->n_vars) return TYPE_E_FIELDNOTFOUND; @@ -424,7 +423,7 @@ static HRESULT WINAPI IRecordInfoImpl_GetFieldNoCopy(IRecordInfo *iface, PVOID p return E_INVALIDARG; for(i=0; in_vars; i++) - if(!strcmpW(This->fields[i].name, szFieldName)) + if(!wcscmp(This->fields[i].name, szFieldName)) break; if(i == This->n_vars) return TYPE_E_FIELDNOTFOUND; @@ -455,7 +454,7 @@ static HRESULT WINAPI IRecordInfoImpl_PutField(IRecordInfo *iface, ULONG wFlags, } for(i=0; in_vars; i++) - if(!strcmpW(This->fields[i].name, szFieldName)) + if(!wcscmp(This->fields[i].name, szFieldName)) break; if(i == This->n_vars) return TYPE_E_FIELDNOTFOUND; @@ -477,7 +476,7 @@ static HRESULT WINAPI IRecordInfoImpl_PutFieldNoCopy(IRecordInfo *iface, ULONG w return E_INVALIDARG; for(i=0; in_vars; i++) - if(!strcmpW(This->fields[i].name, szFieldName)) + if(!wcscmp(This->fields[i].name, szFieldName)) break; if(i == This->n_vars) return TYPE_E_FIELDNOTFOUND; diff --git a/dll/win32/oleaut32/safearray.c b/dll/win32/oleaut32/safearray.c index 64a5ab94d5d..0b769358f65 100644 --- a/dll/win32/oleaut32/safearray.c +++ b/dll/win32/oleaut32/safearray.c @@ -31,8 +31,6 @@ * 0x10: SAFEARRAYBOUNDS[0...] */ -#include "config.h" - #include #include #include @@ -525,8 +523,8 @@ HRESULT WINAPI SafeArrayAllocDescriptorEx(VARTYPE vt, UINT cDims, SAFEARRAY **pp ULONG cbElements; HRESULT hRet; - TRACE("(%d->%s,%d,%p)\n", vt, debugstr_vt(vt), cDims, ppsaOut); - + TRACE("(%s,%u,%p)\n", debugstr_vt(vt), cDims, ppsaOut); + cbElements = SAFEARRAY_GetVTSize(vt); if (!cbElements) WARN("Creating a descriptor with an invalid VARTYPE!\n"); @@ -601,7 +599,7 @@ HRESULT WINAPI SafeArrayAllocData(SAFEARRAY *psa) */ SAFEARRAY* WINAPI SafeArrayCreate(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound) { - TRACE("(%d->%s,%d,%p)\n", vt, debugstr_vt(vt), cDims, rgsabound); + TRACE("(%s,%u,%p)\n", debugstr_vt(vt), cDims, rgsabound); if (vt == VT_RECORD) return NULL; @@ -633,7 +631,7 @@ SAFEARRAY* WINAPI SafeArrayCreateEx(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsa IRecordInfo* iRecInfo = pvExtra; SAFEARRAY* psa; - TRACE("(%d->%s,%d,%p,%p)\n", vt, debugstr_vt(vt), cDims, rgsabound, pvExtra); + TRACE("(%s,%u,%p,%p)\n", debugstr_vt(vt), cDims, rgsabound, pvExtra); if (vt == VT_RECORD) { @@ -678,8 +676,8 @@ SAFEARRAY* WINAPI SafeArrayCreateEx(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsa */ SAFEARRAY* WINAPI SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements) { - TRACE("(%d->%s,%d,%d\n", vt, debugstr_vt(vt), lLbound, cElements); - + TRACE("(%s,%d,%u)\n", debugstr_vt(vt), lLbound, cElements); + if (vt == VT_RECORD) return NULL; @@ -710,8 +708,8 @@ SAFEARRAY* WINAPI SafeArrayCreateVectorEx(VARTYPE vt, LONG lLbound, ULONG cEleme IRecordInfo* iRecInfo = pvExtra; SAFEARRAY* psa; - TRACE("(%d->%s,%d,%d,%p\n", vt, debugstr_vt(vt), lLbound, cElements, pvExtra); - + TRACE("(%s,%d,%u,%p)\n", debugstr_vt(vt), lLbound, cElements, pvExtra); + if (vt == VT_RECORD) { if (!iRecInfo) diff --git a/dll/win32/oleaut32/typelib.c b/dll/win32/oleaut32/typelib.c index 6ed9ce9eb73..76e5e7f64db 100644 --- a/dll/win32/oleaut32/typelib.c +++ b/dll/win32/oleaut32/typelib.c @@ -47,9 +47,6 @@ * */ -#include "config.h" -#include "wine/port.h" - #include #include #include @@ -68,11 +65,11 @@ #include "winternl.h" #include "lzexpand.h" -#include "wine/unicode.h" #include "objbase.h" #include "typelib.h" #include "wine/debug.h" #include "variant.h" +#include "wine/asm.h" #include "wine/heap.h" #include "wine/list.h" @@ -182,7 +179,7 @@ static BOOL find_typelib_key( REFGUID guid, WORD *wMaj, WORD *wMin ) HKEY hkey; memcpy( buffer, typelibW, sizeof(typelibW) ); - StringFromGUID2( guid, buffer + strlenW(buffer), 40 ); + StringFromGUID2( guid, buffer + lstrlenW(buffer), 40 ); if (RegOpenKeyExW( HKEY_CLASSES_ROOT, buffer, 0, KEY_READ, &hkey ) != ERROR_SUCCESS) return FALSE; @@ -246,8 +243,8 @@ static WCHAR *get_typelib_key( REFGUID guid, WORD wMaj, WORD wMin, WCHAR *buffer static const WCHAR VersionFormatW[] = {'\\','%','x','.','%','x',0}; memcpy( buffer, TypelibW, sizeof(TypelibW) ); - StringFromGUID2( guid, buffer + strlenW(buffer), 40 ); - sprintfW( buffer + strlenW(buffer), VersionFormatW, wMaj, wMin ); + StringFromGUID2( guid, buffer + lstrlenW(buffer), 40 ); + swprintf( buffer + lstrlenW(buffer), VersionFormatW, wMaj, wMin ); return buffer; } @@ -258,7 +255,7 @@ static WCHAR *get_interface_key( REFGUID guid, WCHAR *buffer ) static const WCHAR InterfaceW[] = {'I','n','t','e','r','f','a','c','e','\\',0}; memcpy( buffer, InterfaceW, sizeof(InterfaceW) ); - StringFromGUID2( guid, buffer + strlenW(buffer), 40 ); + StringFromGUID2( guid, buffer + lstrlenW(buffer), 40 ); return buffer; } @@ -271,12 +268,12 @@ static WCHAR *get_lcid_subkey( LCID lcid, SYSKIND syskind, WCHAR *buffer ) static const WCHAR win32W[] = {'w','i','n','3','2',0}; static const WCHAR win64W[] = {'w','i','n','6','4',0}; - sprintfW( buffer, LcidFormatW, lcid ); + swprintf( buffer, LcidFormatW, lcid ); switch(syskind) { - case SYS_WIN16: strcatW( buffer, win16W ); break; - case SYS_WIN32: strcatW( buffer, win32W ); break; - case SYS_WIN64: strcatW( buffer, win64W ); break; + case SYS_WIN16: lstrcatW( buffer, win16W ); break; + case SYS_WIN32: lstrcatW( buffer, win32W ); break; + case SYS_WIN64: lstrcatW( buffer, win64W ); break; default: TRACE("Typelib is for unsupported syskind %i\n", syskind); return NULL; @@ -588,29 +585,39 @@ static void TLB_register_interface(TLIBATTR *libattr, LPOLESTR name, TYPEATTR *t WCHAR keyName[60]; HKEY key, subKey; - static const WCHAR PSOA[] = {'{','0','0','0','2','0','4','2','4','-', - '0','0','0','0','-','0','0','0','0','-','C','0','0','0','-', - '0','0','0','0','0','0','0','0','0','0','4','6','}',0}; + static const WCHAR typelib_proxy_clsid[] = {'{','0','0','0','2','0','4','2','4','-', + '0','0','0','0','-','0','0','0','0','-','C','0','0','0','-', + '0','0','0','0','0','0','0','0','0','0','4','6','}',0}; + static const WCHAR dispatch_proxy_clsid[] = {'{','0','0','0','2','0','4','2','0','-', + '0','0','0','0','-','0','0','0','0','-','C','0','0','0','-', + '0','0','0','0','0','0','0','0','0','0','4','6','}',0}; get_interface_key( &tattr->guid, keyName ); if (RegCreateKeyExW(HKEY_CLASSES_ROOT, keyName, 0, NULL, 0, KEY_WRITE | flag, NULL, &key, NULL) == ERROR_SUCCESS) { + const WCHAR *proxy_clsid; + + if (tattr->typekind == TKIND_INTERFACE || (tattr->wTypeFlags & TYPEFLAG_FDUAL)) + proxy_clsid = typelib_proxy_clsid; + else + proxy_clsid = dispatch_proxy_clsid; + if (name) RegSetValueExW(key, NULL, 0, REG_SZ, - (BYTE *)name, (strlenW(name)+1) * sizeof(OLECHAR)); + (BYTE *)name, (lstrlenW(name)+1) * sizeof(OLECHAR)); if (RegCreateKeyExW(key, ProxyStubClsidW, 0, NULL, 0, KEY_WRITE | flag, NULL, &subKey, NULL) == ERROR_SUCCESS) { RegSetValueExW(subKey, NULL, 0, REG_SZ, - (const BYTE *)PSOA, sizeof PSOA); + (const BYTE *)proxy_clsid, sizeof(typelib_proxy_clsid)); RegCloseKey(subKey); } if (RegCreateKeyExW(key, ProxyStubClsid32W, 0, NULL, 0, KEY_WRITE | flag, NULL, &subKey, NULL) == ERROR_SUCCESS) { RegSetValueExW(subKey, NULL, 0, REG_SZ, - (const BYTE *)PSOA, sizeof PSOA); + (const BYTE *)proxy_clsid, sizeof(typelib_proxy_clsid)); RegCloseKey(subKey); } @@ -623,10 +630,10 @@ static void TLB_register_interface(TLIBATTR *libattr, LPOLESTR name, TYPEATTR *t StringFromGUID2(&libattr->guid, buffer, 40); RegSetValueExW(subKey, NULL, 0, REG_SZ, - (BYTE *)buffer, (strlenW(buffer)+1) * sizeof(WCHAR)); - sprintfW(buffer, fmtver, libattr->wMajorVerNum, libattr->wMinorVerNum); + (BYTE *)buffer, (lstrlenW(buffer)+1) * sizeof(WCHAR)); + swprintf(buffer, fmtver, libattr->wMajorVerNum, libattr->wMinorVerNum); RegSetValueExW(subKey, VersionW, 0, REG_SZ, - (BYTE*)buffer, (strlenW(buffer)+1) * sizeof(WCHAR)); + (BYTE*)buffer, (lstrlenW(buffer)+1) * sizeof(WCHAR)); RegCloseKey(subKey); } @@ -646,11 +653,7 @@ static void TLB_register_interface(TLIBATTR *libattr, LPOLESTR name, TYPEATTR *t * Success: S_OK * Failure: Status */ -HRESULT WINAPI RegisterTypeLib( - ITypeLib * ptlib, /* [in] Pointer to the library*/ - OLECHAR * szFullPath, /* [in] full Path of the library*/ - OLECHAR * szHelpDir) /* [in] dir to the helpfile for the library, - may be NULL*/ +HRESULT WINAPI RegisterTypeLib(ITypeLib *ptlib, const WCHAR *szFullPath, const WCHAR *szHelpDir) { HRESULT res; TLIBATTR *attr; @@ -714,9 +717,9 @@ HRESULT WINAPI RegisterTypeLib( /* FIXME: is %u correct? */ static const WCHAR formatW[] = {'%','u',0}; WCHAR buf[20]; - sprintfW(buf, formatW, attr->wLibFlags); + swprintf(buf, formatW, attr->wLibFlags); if (RegSetValueExW(subKey, NULL, 0, REG_SZ, - (BYTE *)buf, (strlenW(buf) + 1)*sizeof(WCHAR) ) != ERROR_SUCCESS) + (BYTE *)buf, (lstrlenW(buf) + 1)*sizeof(WCHAR) ) != ERROR_SUCCESS) res = E_FAIL; RegCloseKey(subKey); @@ -728,19 +731,18 @@ HRESULT WINAPI RegisterTypeLib( if (res == S_OK && RegCreateKeyExW(key, HELPDIRW, 0, NULL, 0, KEY_WRITE, NULL, &subKey, &disposition) == ERROR_SUCCESS) { - BOOL freeHelpDir = FALSE; + BSTR freeHelpDir = NULL; OLECHAR* pIndexStr; /* if we created a new key, and helpDir was null, set the helpdir to the directory which contains the typelib. However, if we just opened an existing key, we leave the helpdir alone */ if ((disposition == REG_CREATED_NEW_KEY) && (szHelpDir == NULL)) { - szHelpDir = SysAllocString(szFullPath); - pIndexStr = strrchrW(szHelpDir, '\\'); + szHelpDir = freeHelpDir = SysAllocString(szFullPath); + pIndexStr = wcsrchr(szHelpDir, '\\'); if (pIndexStr) { *pIndexStr = 0; } - freeHelpDir = TRUE; } /* if we have an szHelpDir, set it! */ @@ -751,10 +753,8 @@ HRESULT WINAPI RegisterTypeLib( } } - /* tidy up */ - if (freeHelpDir) SysFreeString(szHelpDir); + SysFreeString(freeHelpDir); RegCloseKey(subKey); - } else { res = E_FAIL; } @@ -974,7 +974,7 @@ enddeleteloop: /* Now, delete the type library path subkey */ get_lcid_subkey( lcid, syskind, subKeyName ); RegDeleteKeyW(key, subKeyName); - *strrchrW( subKeyName, '\\' ) = 0; /* remove last path component */ + *wcsrchr( subKeyName, '\\' ) = 0; /* remove last path component */ RegDeleteKeyW(key, subKeyName); /* check if there is anything besides the FLAGS/HELPDIR keys. @@ -986,8 +986,8 @@ enddeleteloop: tmpLength = ARRAY_SIZE(subKeyName); /* if its not FLAGS or HELPDIR, then we must keep the rest of the key */ - if (!strcmpW(subKeyName, FLAGSW)) continue; - if (!strcmpW(subKeyName, HELPDIRW)) continue; + if (!wcscmp(subKeyName, FLAGSW)) continue; + if (!wcscmp(subKeyName, HELPDIRW)) continue; deleteOtherStuff = FALSE; break; } @@ -1000,7 +1000,7 @@ enddeleteloop: key = NULL; RegDeleteKeyW(HKEY_CLASSES_ROOT, keyName); - *strrchrW( keyName, '\\' ) = 0; /* remove last path component */ + *wcsrchr( keyName, '\\' ) = 0; /* remove last path component */ RegDeleteKeyW(HKEY_CLASSES_ROOT, keyName); } @@ -1889,7 +1889,7 @@ static TLBString *TLB_append_str(struct list *string_list, BSTR new_str) return NULL; LIST_FOR_EACH_ENTRY(str, string_list, TLBString, entry) { - if (strcmpW(str->str, new_str) == 0) + if (wcscmp(str->str, new_str) == 0) return str; } @@ -3090,7 +3090,7 @@ static BOOL find_ne_resource( HFILE lzfd, LPCSTR typeid, LPCSTR resid, if (!(typeInfo->type_id & 0x8000)) { BYTE *p = resTab + typeInfo->type_id; - if ((*p == len) && !strncasecmp( (char*)p+1, typeid, len )) goto found_type; + if ((*p == len) && !_strnicmp( (char*)p+1, typeid, len )) goto found_type; } typeInfo = (NE_TYPEINFO *)((char *)(typeInfo + 1) + typeInfo->count * sizeof(NE_NAMEINFO)); @@ -3120,7 +3120,7 @@ static BOOL find_ne_resource( HFILE lzfd, LPCSTR typeid, LPCSTR resid, { BYTE *p = resTab + nameInfo->id; if (nameInfo->id & 0x8000) continue; - if ((*p == len) && !strncasecmp( (char*)p+1, resid, len )) goto found_name; + if ((*p == len) && !_strnicmp( (char*)p+1, resid, len )) goto found_name; } } else /* numeric resource id */ @@ -3296,11 +3296,11 @@ static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath *ppTypeLib = NULL; - index_str = strrchrW(pszFileName, '\\'); + index_str = wcsrchr(pszFileName, '\\'); if(index_str && *++index_str != '\0') { LPWSTR end_ptr; - LONG idx = strtolW(index_str, &end_ptr, 10); + LONG idx = wcstol(index_str, &end_ptr, 10); if(*end_ptr == '\0') { int str_len = index_str - pszFileName - 1; @@ -3313,7 +3313,7 @@ static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath if(!SearchPathW(NULL, file, NULL, cchPath, pszPath, NULL)) { - if(strchrW(file, '\\')) + if(wcschr(file, '\\')) { lstrcpyW(pszPath, file); } @@ -3321,7 +3321,7 @@ static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath { int len = GetSystemDirectoryW(pszPath, cchPath); pszPath[len] = '\\'; - memcpy(pszPath + len + 1, file, (strlenW(file) + 1) * sizeof(WCHAR)); + memcpy(pszPath + len + 1, file, (lstrlenW(file) + 1) * sizeof(WCHAR)); } } @@ -3359,7 +3359,7 @@ static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath EnterCriticalSection(&cache_section); LIST_FOR_EACH_ENTRY(entry, &tlb_cache, ITypeLibImpl, entry) { - if (!strcmpiW(entry->path, pszPath) && entry->index == index) + if (!wcsicmp(entry->path, pszPath) && entry->index == index) { TRACE("cache hit\n"); *ppTypeLib = &entry->ITypeLib2_iface; @@ -3401,7 +3401,7 @@ static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath ITypeLibImpl *impl = impl_from_ITypeLib2(*ppTypeLib); TRACE("adding to cache\n"); - impl->path = heap_alloc((strlenW(pszPath)+1) * sizeof(WCHAR)); + impl->path = heap_alloc((lstrlenW(pszPath)+1) * sizeof(WCHAR)); lstrcpyW(impl->path, pszPath); /* We should really canonicalise the path here. */ impl->index = index; @@ -3764,8 +3764,8 @@ static const TLBString *decode_string(const BYTE *table, const char *stream, DWO while ((p = lookup_code(table, table_size, &bits))) { static const WCHAR spaceW[] = { ' ',0 }; - if (buf[0]) strcatW(buf, spaceW); - MultiByteToWideChar(CP_ACP, 0, p, -1, buf + strlenW(buf), buf_size - strlenW(buf)); + if (buf[0]) lstrcatW(buf, spaceW); + MultiByteToWideChar(CP_ACP, 0, p, -1, buf + lstrlenW(buf), buf_size - lstrlenW(buf)); } tlbstr = TLB_append_str(&lib->string_list, buf); @@ -5468,7 +5468,7 @@ static HRESULT WINAPI ITypeLibComp_fnBind( if ((pTypeInfo->typeattr.typekind == TKIND_ENUM) || (pTypeInfo->typeattr.typekind == TKIND_MODULE)) { - if (pTypeInfo->Name && !strcmpW(pTypeInfo->Name->str, szName)) + if (pTypeInfo->Name && !wcscmp(pTypeInfo->Name->str, szName)) { *pDescKind = DESCKIND_TYPECOMP; pBindPtr->lptcomp = &pTypeInfo->ITypeComp_iface; @@ -6114,7 +6114,7 @@ static HRESULT TLB_AllocAndInitVarDesc( const VARDESC *src, VARDESC **dest_ptr ) SIZE_T size = sizeof(*src); HRESULT hr; - if (src->lpstrSchema) size += (strlenW(src->lpstrSchema) + 1) * sizeof(WCHAR); + if (src->lpstrSchema) size += (lstrlenW(src->lpstrSchema) + 1) * sizeof(WCHAR); if (src->varkind == VAR_CONST) size += sizeof(VARIANT); size += TLB_SizeElemDesc(&src->elemdescVar); @@ -6128,7 +6128,7 @@ static HRESULT TLB_AllocAndInitVarDesc( const VARDESC *src, VARDESC **dest_ptr ) { int len; dest->lpstrSchema = (LPOLESTR)buffer; - len = strlenW(src->lpstrSchema); + len = lstrlenW(src->lpstrSchema); memcpy(dest->lpstrSchema, src->lpstrSchema, (len + 1) * sizeof(WCHAR)); buffer += (len + 1) * sizeof(WCHAR); } @@ -6443,20 +6443,133 @@ __ASM_GLOBAL_FUNC( call_method, __ASM_GLOBAL_FUNC( call_double_method, "jmp " __ASM_NAME("call_method") ) +HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, + UINT cActuals, VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult ) +{ + int argspos = 0, stack_offset; + void *func; + UINT i; + DWORD *args; + + TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n", + pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, + pvargResult, V_VT(pvargResult)); + + if (cc != CC_STDCALL && cc != CC_CDECL) + { + FIXME("unsupported calling convention %d\n",cc); + return E_INVALIDARG; + } + + /* maximum size for an argument is sizeof(VARIANT) */ + args = heap_alloc(sizeof(VARIANT) * cActuals + sizeof(DWORD) * 2 ); + + if (pvInstance) + { + const FARPROC *vtable = *(FARPROC **)pvInstance; + func = vtable[oVft/sizeof(void *)]; + args[argspos++] = (DWORD)pvInstance; /* the This pointer is always the first parameter */ + } + else func = (void *)oVft; + + switch (vtReturn) + { + case VT_DECIMAL: + case VT_VARIANT: + args[argspos++] = (DWORD)pvargResult; /* arg 0 is a pointer to the result */ + break; + case VT_HRESULT: + WARN("invalid return type %u\n", vtReturn); + heap_free( args ); + return E_INVALIDARG; + default: + break; + } + + for (i = 0; i < cActuals; i++) + { + VARIANT *arg = prgpvarg[i]; + + switch (prgvt[i]) + { + case VT_EMPTY: + break; + case VT_I8: + case VT_UI8: + case VT_R8: + case VT_DATE: + case VT_CY: + memcpy( &args[argspos], &V_I8(arg), sizeof(V_I8(arg)) ); + argspos += sizeof(V_I8(arg)) / sizeof(DWORD); + break; + case VT_DECIMAL: + case VT_VARIANT: + memcpy( &args[argspos], arg, sizeof(*arg) ); + argspos += sizeof(*arg) / sizeof(DWORD); + break; + case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */ + args[argspos++] = V_BOOL(arg); + break; + default: + args[argspos++] = V_UI4(arg); + break; + } + TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg)); + } + + switch (vtReturn) + { + case VT_EMPTY: + case VT_DECIMAL: + case VT_VARIANT: + call_method( func, argspos, args, &stack_offset ); + break; + case VT_R4: + V_R4(pvargResult) = call_double_method( func, argspos, args, &stack_offset ); + break; + case VT_R8: + case VT_DATE: + V_R8(pvargResult) = call_double_method( func, argspos, args, &stack_offset ); + break; + case VT_I8: + case VT_UI8: + case VT_CY: + V_UI8(pvargResult) = call_method( func, argspos, args, &stack_offset ); + break; + default: + V_UI4(pvargResult) = call_method( func, argspos, args, &stack_offset ); + break; + } + heap_free( args ); + if (stack_offset && cc == CC_STDCALL) + { + WARN( "stack pointer off by %d\n", stack_offset ); + return DISP_E_BADCALLEE; + } + if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn; + TRACE("retval: %s\n", debugstr_variant(pvargResult)); + return S_OK; +} + #elif defined(__x86_64__) extern DWORD_PTR CDECL call_method( void *func, int nb_args, const DWORD_PTR *args ); extern double CDECL call_double_method( void *func, int nb_args, const DWORD_PTR *args ); __ASM_GLOBAL_FUNC( call_method, "pushq %rbp\n\t" + __ASM_SEH(".seh_pushreg %rbp\n\t") __ASM_CFI(".cfi_adjust_cfa_offset 8\n\t") __ASM_CFI(".cfi_rel_offset %rbp,0\n\t") "movq %rsp,%rbp\n\t" + __ASM_SEH(".seh_setframe %rbp,0\n\t") __ASM_CFI(".cfi_def_cfa_register %rbp\n\t") "pushq %rsi\n\t" + __ASM_SEH(".seh_pushreg %rsi\n\t") __ASM_CFI(".cfi_rel_offset %rsi,-8\n\t") "pushq %rdi\n\t" + __ASM_SEH(".seh_pushreg %rdi\n\t") __ASM_CFI(".cfi_rel_offset %rdi,-16\n\t") + __ASM_SEH(".seh_endprologue\n\t") "movq %rcx,%rax\n\t" "movq $4,%rcx\n\t" "cmp %rcx,%rdx\n\t" @@ -6489,6 +6602,92 @@ __ASM_GLOBAL_FUNC( call_method, __ASM_GLOBAL_FUNC( call_double_method, "jmp " __ASM_NAME("call_method") ) +HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, + UINT cActuals, VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult ) +{ + int argspos = 0; + UINT i; + DWORD_PTR *args; + void *func; + + TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n", + pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, + pvargResult, V_VT(pvargResult)); + + if (cc != CC_STDCALL && cc != CC_CDECL) + { + FIXME("unsupported calling convention %d\n",cc); + return E_INVALIDARG; + } + + /* maximum size for an argument is sizeof(DWORD_PTR) */ + args = heap_alloc( sizeof(DWORD_PTR) * (cActuals + 2) ); + + if (pvInstance) + { + const FARPROC *vtable = *(FARPROC **)pvInstance; + func = vtable[oVft/sizeof(void *)]; + args[argspos++] = (DWORD_PTR)pvInstance; /* the This pointer is always the first parameter */ + } + else func = (void *)oVft; + + switch (vtReturn) + { + case VT_DECIMAL: + case VT_VARIANT: + args[argspos++] = (DWORD_PTR)pvargResult; /* arg 0 is a pointer to the result */ + break; + case VT_HRESULT: + WARN("invalid return type %u\n", vtReturn); + heap_free( args ); + return E_INVALIDARG; + default: + break; + } + + for (i = 0; i < cActuals; i++) + { + VARIANT *arg = prgpvarg[i]; + + switch (prgvt[i]) + { + case VT_DECIMAL: + case VT_VARIANT: + args[argspos++] = (ULONG_PTR)arg; + break; + case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */ + args[argspos++] = V_BOOL(arg); + break; + default: + args[argspos++] = V_UI8(arg); + break; + } + TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg)); + } + + switch (vtReturn) + { + case VT_R4: + V_R4(pvargResult) = call_double_method( func, argspos, args ); + break; + case VT_R8: + case VT_DATE: + V_R8(pvargResult) = call_double_method( func, argspos, args ); + break; + case VT_DECIMAL: + case VT_VARIANT: + call_method( func, argspos, args ); + break; + default: + V_UI8(pvargResult) = call_method( func, argspos, args ); + break; + } + heap_free( args ); + if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn; + TRACE("retval: %s\n", debugstr_variant(pvargResult)); + return S_OK; +} + #elif defined(__arm__) extern LONGLONG CDECL call_method( void *func, int nb_stk_args, const DWORD *stk_args, const DWORD *reg_args ); @@ -6529,36 +6728,384 @@ __ASM_GLOBAL_FUNC( call_float_method, __ASM_GLOBAL_FUNC( call_double_method, "b " __ASM_NAME("call_method") ) -#endif /* __arm__ */ - -static HRESULT userdefined_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt) +HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, + UINT cActuals, VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult ) { - HRESULT hr = S_OK; - ITypeInfo *tinfo2 = NULL; - TYPEATTR *tattr = NULL; + int argspos; + void *func; + UINT i; + DWORD *args; + struct { +#ifndef __SOFTFP__ + union { + float s[16]; + double d[8]; + } sd; +#endif + DWORD r[4]; + } regs; + int rcount; /* 32-bit register index count */ +#ifndef __SOFTFP__ + int scount = 0; /* single-precision float register index count */ + int dcount = 0; /* double-precision float register index count */ +#endif - hr = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2); - if (hr) + TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n", + pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult)); + + if (cc != CC_STDCALL && cc != CC_CDECL) { - ERR("Could not get typeinfo of hreftype %x for VT_USERDEFINED, " - "hr = 0x%08x\n", - tdesc->u.hreftype, hr); - return hr; + FIXME("unsupported calling convention %d\n",cc); + return E_INVALIDARG; } - hr = ITypeInfo_GetTypeAttr(tinfo2, &tattr); - if (hr) + + argspos = 0; + rcount = 0; + + if (pvInstance) { - ERR("ITypeInfo_GetTypeAttr failed, hr = 0x%08x\n", hr); - ITypeInfo_Release(tinfo2); - return hr; + const FARPROC *vtable = *(FARPROC **)pvInstance; + func = vtable[oVft/sizeof(void *)]; + regs.r[rcount++] = (DWORD)pvInstance; /* the This pointer is always the first parameter */ } + else func = (void *)oVft; - switch (tattr->typekind) + /* Determine if we need to pass a pointer for the return value as arg 0. If so, do that */ + /* first as it will need to be in the 'r' registers: */ + switch (vtReturn) { - case TKIND_ENUM: - *vt |= VT_I4; - break; - + case VT_DECIMAL: + case VT_VARIANT: + regs.r[rcount++] = (DWORD)pvargResult; /* arg 0 is a pointer to the result */ + break; + case VT_HRESULT: + WARN("invalid return type %u\n", vtReturn); + return E_INVALIDARG; + default: /* And all others are in 'r', 's', or 'd' registers or have no return value */ + break; + } + + /* maximum size for an argument is sizeof(VARIANT). Also allow for return pointer and stack alignment. */ + args = heap_alloc( sizeof(VARIANT) * cActuals + sizeof(DWORD) * 4 ); + + for (i = 0; i < cActuals; i++) + { + VARIANT *arg = prgpvarg[i]; + DWORD *pdwarg = (DWORD *)(arg); /* a reinterpret_cast of the variant, used for copying structures when they are split between registers and stack */ + int ntemp; /* Used for counting words split between registers and stack */ + + switch (prgvt[i]) + { + case VT_EMPTY: + break; + case VT_R8: /* these must be 8-byte aligned, and put in 'd' regs or stack, as they are double-floats */ + case VT_DATE: +#ifndef __SOFTFP__ + dcount = max( (scount + 1) / 2, dcount ); + if (dcount < 8) + { + regs.sd.d[dcount++] = V_R8(arg); + } + else + { + argspos += (argspos % 2); /* align argspos to 8-bytes */ + memcpy( &args[argspos], &V_R8(arg), sizeof(V_R8(arg)) ); + argspos += sizeof(V_R8(arg)) / sizeof(DWORD); + } + break; +#endif + case VT_I8: /* these must be 8-byte aligned, and put in 'r' regs or stack, as they are long-longs */ + case VT_UI8: + case VT_CY: + if (rcount < 3) + { + rcount += (rcount % 2); /* align rcount to 8-byte register pair */ + memcpy( ®s.r[rcount], &V_UI8(arg), sizeof(V_UI8(arg)) ); + rcount += sizeof(V_UI8(arg)) / sizeof(DWORD); + } + else + { + rcount = 4; /* Make sure we flag that all 'r' regs are full */ + argspos += (argspos % 2); /* align argspos to 8-bytes */ + memcpy( &args[argspos], &V_UI8(arg), sizeof(V_UI8(arg)) ); + argspos += sizeof(V_UI8(arg)) / sizeof(DWORD); + } + break; + case VT_DECIMAL: /* these structures are 8-byte aligned, and put in 'r' regs or stack, can be split between the two */ + case VT_VARIANT: + /* 8-byte align 'r' and/or stack: */ + if (rcount < 3) + rcount += (rcount % 2); + else + { + rcount = 4; + argspos += (argspos % 2); + } + ntemp = sizeof(*arg) / sizeof(DWORD); + while (ntemp > 0) + { + if (rcount < 4) + regs.r[rcount++] = *pdwarg++; + else + args[argspos++] = *pdwarg++; + --ntemp; + } + break; + case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */ + if (rcount < 4) + regs.r[rcount++] = V_BOOL(arg); + else + args[argspos++] = V_BOOL(arg); + break; + case VT_R4: /* these must be 4-byte aligned, and put in 's' regs or stack, as they are single-floats */ +#ifndef __SOFTFP__ + if (!(scount % 2)) scount = max( scount, dcount * 2 ); + if (scount < 16) + regs.sd.s[scount++] = V_R4(arg); + else + args[argspos++] = V_UI4(arg); + break; +#endif + default: + if (rcount < 4) + regs.r[rcount++] = V_UI4(arg); + else + args[argspos++] = V_UI4(arg); + break; + } + TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg)); + } + + argspos += (argspos % 2); /* Make sure stack function alignment is 8-byte */ + + switch (vtReturn) + { + case VT_EMPTY: /* EMPTY = no return value */ + case VT_DECIMAL: /* DECIMAL and VARIANT already have a pointer argument passed (see above) */ + case VT_VARIANT: + call_method( func, argspos, args, (DWORD*)®s ); + break; + case VT_R4: + V_R4(pvargResult) = call_float_method( func, argspos, args, (DWORD*)®s ); + break; + case VT_R8: + case VT_DATE: + V_R8(pvargResult) = call_double_method( func, argspos, args, (DWORD*)®s ); + break; + case VT_I8: + case VT_UI8: + case VT_CY: + V_UI8(pvargResult) = call_method( func, argspos, args, (DWORD*)®s ); + break; + default: + V_UI4(pvargResult) = call_method( func, argspos, args, (DWORD*)®s ); + break; + } + heap_free( args ); + if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn; + TRACE("retval: %s\n", debugstr_variant(pvargResult)); + return S_OK; +} + +#elif defined(__aarch64__) + +extern DWORD_PTR CDECL call_method( void *func, int nb_stk_args, const DWORD_PTR *stk_args, const DWORD_PTR *reg_args ); +extern float CDECL call_float_method( void *func, int nb_stk_args, const DWORD_PTR *stk_args, const DWORD_PTR *reg_args ); +extern double CDECL call_double_method( void *func, int nb_stk_args, const DWORD_PTR *stk_args, const DWORD_PTR *reg_args ); +__ASM_GLOBAL_FUNC( call_method, + "stp x29, x30, [sp, #-16]!\n\t" + "mov x29, sp\n\t" + "sub sp, sp, x1, lsl #3\n\t" + "cbz x1, 2f\n" + "1:\tsub x1, x1, #1\n\t" + "ldr x4, [x2, x1, lsl #3]\n\t" + "str x4, [sp, x1, lsl #3]\n\t" + "cbnz x1, 1b\n" + "2:\tmov x16, x0\n\t" + "mov x9, x3\n\t" + "ldp d0, d1, [x9]\n\t" + "ldp d2, d3, [x9, #0x10]\n\t" + "ldp d4, d5, [x9, #0x20]\n\t" + "ldp d6, d7, [x9, #0x30]\n\t" + "ldp x0, x1, [x9, #0x40]\n\t" + "ldp x2, x3, [x9, #0x50]\n\t" + "ldp x4, x5, [x9, #0x60]\n\t" + "ldp x6, x7, [x9, #0x70]\n\t" + "ldr x8, [x9, #0x80]\n\t" + "blr x16\n\t" + "mov sp, x29\n\t" + "ldp x29, x30, [sp], #16\n\t" + "ret" ) +__ASM_GLOBAL_FUNC( call_float_method, + "b " __ASM_NAME("call_method") ) +__ASM_GLOBAL_FUNC( call_double_method, + "b " __ASM_NAME("call_method") ) + +HRESULT WINAPI DispCallFunc( void *instance, ULONG_PTR offset, CALLCONV cc, VARTYPE ret_type, UINT count, + VARTYPE *types, VARIANTARG **vargs, VARIANT *result ) +{ + int argspos; + void *func; + UINT i; + DWORD_PTR *args; + struct + { + union + { + float f; + double d; + } fp[8]; + DWORD_PTR x[9]; + } regs; + int rcount; /* 64-bit register index count */ + int fpcount = 0; /* float register index count */ + + TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n", + instance, offset, cc, ret_type, count, types, vargs, result, V_VT(result)); + + if (cc != CC_STDCALL && cc != CC_CDECL) + { + FIXME("unsupported calling convention %d\n",cc); + return E_INVALIDARG; + } + + argspos = 0; + rcount = 0; + + if (instance) + { + const FARPROC *vtable = *(FARPROC **)instance; + func = vtable[offset/sizeof(void *)]; + regs.x[rcount++] = (DWORD_PTR)instance; /* the This pointer is always the first parameter */ + } + else func = (void *)offset; + + /* Determine if we need to pass a pointer for the return value as arg 0. If so, do that */ + /* first as it will need to be in the 'x' registers: */ + switch (ret_type) + { + case VT_DECIMAL: + case VT_VARIANT: + regs.x[8] = (DWORD_PTR)result; /* x8 is a pointer to the result */ + break; + case VT_HRESULT: + WARN("invalid return type %u\n", ret_type); + return E_INVALIDARG; + default: + break; + } + + /* maximum size for an argument is sizeof(VARIANT). Also allow for return pointer and stack alignment. */ + args = heap_alloc( sizeof(VARIANT) * count + sizeof(DWORD_PTR) * 4 ); + + for (i = 0; i < count; i++) + { + VARIANT *arg = vargs[i]; + + switch (types[i]) + { + case VT_EMPTY: + break; + case VT_R4: + if (fpcount < 8) regs.fp[fpcount++].f = V_R4(arg); + else *(float *)&args[argspos++] = V_R4(arg); + break; + case VT_R8: + case VT_DATE: + if (fpcount < 8) regs.fp[fpcount++].d = V_R8(arg); + else *(double *)&args[argspos++] = V_R8(arg); + break; + case VT_DECIMAL: + case VT_VARIANT: + if (rcount < 7) + { + memcpy( ®s.x[rcount], arg, sizeof(*arg) ); + rcount += 2; + } + else + { + memcpy( &args[argspos], arg, sizeof(*arg) ); + argspos += 2; + } + break; + case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */ + if (rcount < 8) regs.x[rcount++] = V_BOOL(arg); + else args[argspos++] = V_BOOL(arg); + break; + default: + if (rcount < 8) regs.x[rcount++] = V_UI8(arg); + else args[argspos++] = V_UI8(arg); + break; + } + TRACE("arg %u: type %s %s\n", i, debugstr_vt(types[i]), debugstr_variant(arg)); + } + + argspos += (argspos % 2); /* Make sure stack function alignment is 16-byte */ + + switch (ret_type) + { + case VT_EMPTY: /* EMPTY = no return value */ + case VT_DECIMAL: /* DECIMAL and VARIANT already have a pointer argument passed (see above) */ + case VT_VARIANT: + call_method( func, argspos, args, (DWORD_PTR *)®s ); + break; + case VT_R4: + V_R4(result) = call_float_method( func, argspos, args, (DWORD_PTR *)®s ); + break; + case VT_R8: + case VT_DATE: + V_R8(result) = call_double_method( func, argspos, args, (DWORD_PTR *)®s ); + break; + default: + V_UI8(result) = call_method( func, argspos, args, (DWORD_PTR *)®s ); + break; + } + heap_free( args ); + if (ret_type != VT_VARIANT) V_VT(result) = ret_type; + TRACE("retval: %s\n", debugstr_variant(result)); + return S_OK; +} + +#else /* __aarch64__ */ + +HRESULT WINAPI DispCallFunc( void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, + UINT cActuals, VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult ) +{ + FIXME( "(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d)): not implemented for this CPU\n", + pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult)); + return E_NOTIMPL; +} + +#endif + +static HRESULT userdefined_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt) +{ + HRESULT hr = S_OK; + ITypeInfo *tinfo2 = NULL; + TYPEATTR *tattr = NULL; + + hr = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2); + if (hr) + { + ERR("Could not get typeinfo of hreftype %x for VT_USERDEFINED, " + "hr = 0x%08x\n", + tdesc->u.hreftype, hr); + return hr; + } + hr = ITypeInfo_GetTypeAttr(tinfo2, &tattr); + if (hr) + { + ERR("ITypeInfo_GetTypeAttr failed, hr = 0x%08x\n", hr); + ITypeInfo_Release(tinfo2); + return hr; + } + + switch (tattr->typekind) + { + case TKIND_ENUM: + *vt |= VT_I4; + break; + case TKIND_ALIAS: hr = typedescvt_to_variantvt(tinfo2, &tattr->tdescAlias, vt); break; @@ -6718,420 +7265,6 @@ static HRESULT get_iface_guid(ITypeInfo *tinfo, HREFTYPE href, GUID *guid) return hres; } -/*********************************************************************** - * DispCallFunc (OLEAUT32.@) - * - * Invokes a function of the specified calling convention, passing the - * specified arguments and returns the result. - * - * PARAMS - * pvInstance [I] Optional pointer to the instance whose function to invoke. - * oVft [I] The offset in the vtable. See notes. - * cc [I] Calling convention of the function to call. - * vtReturn [I] The return type of the function. - * cActuals [I] Number of parameters. - * prgvt [I] The types of the parameters to pass. This is used for sizing only. - * prgpvarg [I] The arguments to pass. - * pvargResult [O] The return value of the function. Can be NULL. - * - * RETURNS - * Success: S_OK. - * Failure: HRESULT code. - * - * NOTES - * The HRESULT return value of this function is not affected by the return - * value of the user supplied function, which is returned in pvargResult. - * - * If pvInstance is NULL then a non-object function is to be called and oVft - * is the address of the function to call. - * - * The cc parameter can be one of the following values: - *|CC_FASTCALL - *|CC_CDECL - *|CC_PASCAL - *|CC_STDCALL - *|CC_FPFASTCALL - *|CC_SYSCALL - *|CC_MPWCDECL - *|CC_MPWPASCAL - * - */ -HRESULT WINAPI -DispCallFunc( - void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, UINT cActuals, - VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult) -{ -#ifdef __i386__ - int argspos = 0, stack_offset; - void *func; - UINT i; - DWORD *args; - - TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n", - pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, - pvargResult, V_VT(pvargResult)); - - if (cc != CC_STDCALL && cc != CC_CDECL) - { - FIXME("unsupported calling convention %d\n",cc); - return E_INVALIDARG; - } - - /* maximum size for an argument is sizeof(VARIANT) */ - args = heap_alloc(sizeof(VARIANT) * cActuals + sizeof(DWORD) * 2 ); - - if (pvInstance) - { - const FARPROC *vtable = *(FARPROC **)pvInstance; - func = vtable[oVft/sizeof(void *)]; - args[argspos++] = (DWORD)pvInstance; /* the This pointer is always the first parameter */ - } - else func = (void *)oVft; - - switch (vtReturn) - { - case VT_DECIMAL: - case VT_VARIANT: - args[argspos++] = (DWORD)pvargResult; /* arg 0 is a pointer to the result */ - break; - case VT_HRESULT: - WARN("invalid return type %u\n", vtReturn); - heap_free( args ); - return E_INVALIDARG; - default: - break; - } - - for (i = 0; i < cActuals; i++) - { - VARIANT *arg = prgpvarg[i]; - - switch (prgvt[i]) - { - case VT_EMPTY: - break; - case VT_I8: - case VT_UI8: - case VT_R8: - case VT_DATE: - case VT_CY: - memcpy( &args[argspos], &V_I8(arg), sizeof(V_I8(arg)) ); - argspos += sizeof(V_I8(arg)) / sizeof(DWORD); - break; - case VT_DECIMAL: - case VT_VARIANT: - memcpy( &args[argspos], arg, sizeof(*arg) ); - argspos += sizeof(*arg) / sizeof(DWORD); - break; - case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */ - args[argspos++] = V_BOOL(arg); - break; - default: - args[argspos++] = V_UI4(arg); - break; - } - TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg)); - } - - switch (vtReturn) - { - case VT_EMPTY: - case VT_DECIMAL: - case VT_VARIANT: - call_method( func, argspos, args, &stack_offset ); - break; - case VT_R4: - V_R4(pvargResult) = call_double_method( func, argspos, args, &stack_offset ); - break; - case VT_R8: - case VT_DATE: - V_R8(pvargResult) = call_double_method( func, argspos, args, &stack_offset ); - break; - case VT_I8: - case VT_UI8: - case VT_CY: - V_UI8(pvargResult) = call_method( func, argspos, args, &stack_offset ); - break; - default: - V_UI4(pvargResult) = call_method( func, argspos, args, &stack_offset ); - break; - } - heap_free( args ); - if (stack_offset && cc == CC_STDCALL) - { - WARN( "stack pointer off by %d\n", stack_offset ); - return DISP_E_BADCALLEE; - } - if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn; - TRACE("retval: %s\n", debugstr_variant(pvargResult)); - return S_OK; - -#elif defined(__x86_64__) - int argspos = 0; - UINT i; - DWORD_PTR *args; - void *func; - - TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n", - pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, - pvargResult, V_VT(pvargResult)); - - if (cc != CC_STDCALL && cc != CC_CDECL) - { - FIXME("unsupported calling convention %d\n",cc); - return E_INVALIDARG; - } - - /* maximum size for an argument is sizeof(DWORD_PTR) */ - args = heap_alloc( sizeof(DWORD_PTR) * (cActuals + 2) ); - - if (pvInstance) - { - const FARPROC *vtable = *(FARPROC **)pvInstance; - func = vtable[oVft/sizeof(void *)]; - args[argspos++] = (DWORD_PTR)pvInstance; /* the This pointer is always the first parameter */ - } - else func = (void *)oVft; - - switch (vtReturn) - { - case VT_DECIMAL: - case VT_VARIANT: - args[argspos++] = (DWORD_PTR)pvargResult; /* arg 0 is a pointer to the result */ - break; - case VT_HRESULT: - WARN("invalid return type %u\n", vtReturn); - heap_free( args ); - return E_INVALIDARG; - default: - break; - } - - for (i = 0; i < cActuals; i++) - { - VARIANT *arg = prgpvarg[i]; - - switch (prgvt[i]) - { - case VT_DECIMAL: - case VT_VARIANT: - args[argspos++] = (ULONG_PTR)arg; - break; - case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */ - args[argspos++] = V_BOOL(arg); - break; - default: - args[argspos++] = V_UI8(arg); - break; - } - TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg)); - } - - switch (vtReturn) - { - case VT_R4: - V_R4(pvargResult) = call_double_method( func, argspos, args ); - break; - case VT_R8: - case VT_DATE: - V_R8(pvargResult) = call_double_method( func, argspos, args ); - break; - case VT_DECIMAL: - case VT_VARIANT: - call_method( func, argspos, args ); - break; - default: - V_UI8(pvargResult) = call_method( func, argspos, args ); - break; - } - heap_free( args ); - if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn; - TRACE("retval: %s\n", debugstr_variant(pvargResult)); - return S_OK; - -#elif defined(__arm__) - int argspos; - void *func; - UINT i; - DWORD *args; - struct { -#ifndef __SOFTFP__ - union { - float s[16]; - double d[8]; - } sd; -#endif - DWORD r[4]; - } regs; - int rcount; /* 32-bit register index count */ -#ifndef __SOFTFP__ - int scount = 0; /* single-precision float register index count */ - int dcount = 0; /* double-precision float register index count */ -#endif - - TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n", - pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult)); - - if (cc != CC_STDCALL && cc != CC_CDECL) - { - FIXME("unsupported calling convention %d\n",cc); - return E_INVALIDARG; - } - - argspos = 0; - rcount = 0; - - if (pvInstance) - { - const FARPROC *vtable = *(FARPROC **)pvInstance; - func = vtable[oVft/sizeof(void *)]; - regs.r[rcount++] = (DWORD)pvInstance; /* the This pointer is always the first parameter */ - } - else func = (void *)oVft; - - /* Determine if we need to pass a pointer for the return value as arg 0. If so, do that */ - /* first as it will need to be in the 'r' registers: */ - switch (vtReturn) - { - case VT_DECIMAL: - case VT_VARIANT: - regs.r[rcount++] = (DWORD)pvargResult; /* arg 0 is a pointer to the result */ - break; - case VT_HRESULT: - WARN("invalid return type %u\n", vtReturn); - return E_INVALIDARG; - default: /* And all others are in 'r', 's', or 'd' registers or have no return value */ - break; - } - - /* maximum size for an argument is sizeof(VARIANT). Also allow for return pointer and stack alignment. */ - args = heap_alloc( sizeof(VARIANT) * cActuals + sizeof(DWORD) * 4 ); - - for (i = 0; i < cActuals; i++) - { - VARIANT *arg = prgpvarg[i]; - DWORD *pdwarg = (DWORD *)(arg); /* a reinterpret_cast of the variant, used for copying structures when they are split between registers and stack */ - int ntemp; /* Used for counting words split between registers and stack */ - - switch (prgvt[i]) - { - case VT_EMPTY: - break; - case VT_R8: /* these must be 8-byte aligned, and put in 'd' regs or stack, as they are double-floats */ - case VT_DATE: -#ifndef __SOFTFP__ - dcount = max( (scount + 1) / 2, dcount ); - if (dcount < 8) - { - regs.sd.d[dcount++] = V_R8(arg); - } - else - { - argspos += (argspos % 2); /* align argspos to 8-bytes */ - memcpy( &args[argspos], &V_R8(arg), sizeof(V_R8(arg)) ); - argspos += sizeof(V_R8(arg)) / sizeof(DWORD); - } - break; -#endif - case VT_I8: /* these must be 8-byte aligned, and put in 'r' regs or stack, as they are long-longs */ - case VT_UI8: - case VT_CY: - if (rcount < 3) - { - rcount += (rcount % 2); /* align rcount to 8-byte register pair */ - memcpy( ®s.r[rcount], &V_UI8(arg), sizeof(V_UI8(arg)) ); - rcount += sizeof(V_UI8(arg)) / sizeof(DWORD); - } - else - { - rcount = 4; /* Make sure we flag that all 'r' regs are full */ - argspos += (argspos % 2); /* align argspos to 8-bytes */ - memcpy( &args[argspos], &V_UI8(arg), sizeof(V_UI8(arg)) ); - argspos += sizeof(V_UI8(arg)) / sizeof(DWORD); - } - break; - case VT_DECIMAL: /* these structures are 8-byte aligned, and put in 'r' regs or stack, can be split between the two */ - case VT_VARIANT: - /* 8-byte align 'r' and/or stack: */ - if (rcount < 3) - rcount += (rcount % 2); - else - { - rcount = 4; - argspos += (argspos % 2); - } - ntemp = sizeof(*arg) / sizeof(DWORD); - while (ntemp > 0) - { - if (rcount < 4) - regs.r[rcount++] = *pdwarg++; - else - args[argspos++] = *pdwarg++; - --ntemp; - } - break; - case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */ - if (rcount < 4) - regs.r[rcount++] = V_BOOL(arg); - else - args[argspos++] = V_BOOL(arg); - break; - case VT_R4: /* these must be 4-byte aligned, and put in 's' regs or stack, as they are single-floats */ -#ifndef __SOFTFP__ - if (!(scount % 2)) scount = max( scount, dcount * 2 ); - if (scount < 16) - regs.sd.s[scount++] = V_R4(arg); - else - args[argspos++] = V_UI4(arg); - break; -#endif - default: - if (rcount < 4) - regs.r[rcount++] = V_UI4(arg); - else - args[argspos++] = V_UI4(arg); - break; - } - TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg)); - } - - argspos += (argspos % 2); /* Make sure stack function alignment is 8-byte */ - - switch (vtReturn) - { - case VT_EMPTY: /* EMPTY = no return value */ - case VT_DECIMAL: /* DECIMAL and VARIANT already have a pointer argument passed (see above) */ - case VT_VARIANT: - call_method( func, argspos, args, (DWORD*)®s ); - break; - case VT_R4: - V_R4(pvargResult) = call_float_method( func, argspos, args, (DWORD*)®s ); - break; - case VT_R8: - case VT_DATE: - V_R8(pvargResult) = call_double_method( func, argspos, args, (DWORD*)®s ); - break; - case VT_I8: - case VT_UI8: - case VT_CY: - V_UI8(pvargResult) = call_method( func, argspos, args, (DWORD*)®s ); - break; - default: - V_UI4(pvargResult) = call_method( func, argspos, args, (DWORD*)®s ); - break; - } - heap_free( args ); - if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn; - TRACE("retval: %s\n", debugstr_variant(pvargResult)); - return S_OK; - -#else - FIXME( "(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d)): not implemented for this CPU\n", - pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult)); - return E_NOTIMPL; -#endif -} - static inline BOOL func_restricted( const FUNCDESC *desc ) { return (desc->wFuncFlags & FUNCFLAG_FRESTRICTED) && (desc->memid >= 0); @@ -7850,7 +7983,7 @@ static BOOL CALLBACK search_res_tlb(HMODULE hModule, LPCWSTR lpszType, LPWSTR lp if (!(len = GetModuleFileNameW(hModule, szPath, MAX_PATH))) return TRUE; - if (snprintfW(szPath + len, ARRAY_SIZE(szPath) - len, formatW, LOWORD(lpszName)) < 0) + if (swprintf(szPath + len, formatW, LOWORD(lpszName)) < 0) return TRUE; ret = LoadTypeLibEx(szPath, REGKIND_NONE, &pTLib); @@ -9167,7 +9300,7 @@ static HRESULT WMSFT_compile_strings(ITypeLibImpl *This, LIST_FOR_EACH_ENTRY(str, &This->string_list, TLBString, entry) { int size; - size = WideCharToMultiByte(CP_ACP, 0, str->str, strlenW(str->str), NULL, 0, NULL, NULL); + size = WideCharToMultiByte(CP_ACP, 0, str->str, lstrlenW(str->str), NULL, 0, NULL, NULL); if (size == 0) return E_UNEXPECTED; @@ -9190,7 +9323,7 @@ static HRESULT WMSFT_compile_strings(ITypeLibImpl *This, LIST_FOR_EACH_ENTRY(str, &This->string_list, TLBString, entry) { int size; - size = WideCharToMultiByte(CP_ACP, 0, str->str, strlenW(str->str), + size = WideCharToMultiByte(CP_ACP, 0, str->str, lstrlenW(str->str), data + sizeof(INT16), file->string_seg.len - last_offs - sizeof(INT16), NULL, NULL); if (size == 0) { heap_free(file->string_seg.data); @@ -9225,7 +9358,7 @@ static HRESULT WMSFT_compile_names(ITypeLibImpl *This, LIST_FOR_EACH_ENTRY(str, &This->name_list, TLBString, entry) { int size; - size = strlenW(str->str); + size = lstrlenW(str->str); file->header.nametablechars += size; file->header.nametablecount++; @@ -9254,7 +9387,7 @@ static HRESULT WMSFT_compile_names(ITypeLibImpl *This, int size, hash; MSFT_NameIntro *intro = (MSFT_NameIntro*)data; - size = WideCharToMultiByte(CP_ACP, 0, str->str, strlenW(str->str), + size = WideCharToMultiByte(CP_ACP, 0, str->str, lstrlenW(str->str), data + sizeof(MSFT_NameIntro), file->name_seg.len - last_offs - sizeof(MSFT_NameIntro), NULL, NULL); if (size == 0) { @@ -10019,12 +10152,12 @@ static void WMSFT_compile_impfile(ITypeLibImpl *This, WMSFT_TLBFile *file) int size = 0; if(implib->name){ - WCHAR *path = strrchrW(implib->name, '\\'); + WCHAR *path = wcsrchr(implib->name, '\\'); if(path) ++path; else path = implib->name; - size = WideCharToMultiByte(CP_ACP, 0, path, strlenW(path), NULL, 0, NULL, NULL); + size = WideCharToMultiByte(CP_ACP, 0, path, lstrlenW(path), NULL, 0, NULL, NULL); if (size == 0) ERR("failed to convert wide string: %s\n", debugstr_w(path)); } @@ -10051,12 +10184,12 @@ static void WMSFT_compile_impfile(ITypeLibImpl *This, WMSFT_TLBFile *file) data += sizeof(WMSFT_ImpFile); if(implib->name){ - WCHAR *path= strrchrW(implib->name, '\\'); + WCHAR *path= wcsrchr(implib->name, '\\'); if(path) ++path; else path = implib->name; - strlen = WideCharToMultiByte(CP_ACP, 0, path, strlenW(path), + strlen = WideCharToMultiByte(CP_ACP, 0, path, lstrlenW(path), data + sizeof(INT16), file->impfile_seg.len - last_offs - sizeof(INT16), NULL, NULL); if (strlen == 0) ERR("failed to convert wide string: %s\n", debugstr_w(path)); @@ -10999,7 +11132,7 @@ static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncAndParamNames(ICreateTypeInfo2 * for(i = 0; i < This->typeattr.cFuncs; ++i) { TLBFuncDesc *iter = &This->funcdescs[i]; - if (iter->Name && !strcmpW(TLB_get_bstr(iter->Name), *names)) { + if (iter->Name && !wcscmp(TLB_get_bstr(iter->Name), *names)) { if (iter->funcdesc.invkind & (INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF | INVOKE_PROPERTYGET) && func_desc->funcdesc.invkind & (INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF | INVOKE_PROPERTYGET) && func_desc->funcdesc.invkind != iter->funcdesc.invkind) diff --git a/dll/win32/oleaut32/varformat.c b/dll/win32/oleaut32/varformat.c index 470ea4e01b7..591093dbc52 100644 --- a/dll/win32/oleaut32/varformat.c +++ b/dll/win32/oleaut32/varformat.c @@ -25,8 +25,6 @@ * Please submit a test case if you find a difference. */ -#include "config.h" - #include #include #include @@ -34,7 +32,6 @@ #include "windef.h" #include "winbase.h" -#include "wine/unicode.h" #include "winerror.h" #include "variant.h" #include "wine/debug.h" @@ -438,9 +435,9 @@ static const NAMED_FORMAT VARIANT_NamedFormats[] = }; typedef const NAMED_FORMAT *LPCNAMED_FORMAT; -static int FormatCompareFn(const void *l, const void *r) +static int __cdecl FormatCompareFn(const void *l, const void *r) { - return strcmpiW(((LPCNAMED_FORMAT)l)->name, ((LPCNAMED_FORMAT)r)->name); + return wcsicmp(((LPCNAMED_FORMAT)l)->name, ((LPCNAMED_FORMAT)r)->name); } static inline const BYTE *VARIANT_GetNamedFormat(LPCWSTR lpszFormat) @@ -763,7 +760,7 @@ HRESULT WINAPI VarTokenizeFormatString(LPOLESTR lpszFormat, LPBYTE rgbTok, TRACE("time sep\n"); } else if ((*pFormat == 'a' || *pFormat == 'A') && - !strncmpiW(pFormat, szAMPM, ARRAY_SIZE(szAMPM))) + !_wcsnicmp(pFormat, szAMPM, ARRAY_SIZE(szAMPM))) { /* Date formats: System AM/PM designation * Other formats: Literal @@ -772,7 +769,7 @@ HRESULT WINAPI VarTokenizeFormatString(LPOLESTR lpszFormat, LPBYTE rgbTok, header->type = FMT_TYPE_DATE; NEED_SPACE(sizeof(BYTE)); pFormat += ARRAY_SIZE(szAMPM); - if (!strncmpW(pFormat, szampm, ARRAY_SIZE(szampm))) + if (!wcsncmp(pFormat, szampm, ARRAY_SIZE(szampm))) *pOut++ = FMT_DATE_AMPM_SYS2; else *pOut++ = FMT_DATE_AMPM_SYS1; @@ -810,7 +807,7 @@ HRESULT WINAPI VarTokenizeFormatString(LPOLESTR lpszFormat, LPBYTE rgbTok, *pLastHours = *pLastHours + 2; TRACE("A/P\n"); } - else if (*pFormat == 'a' && !strncmpW(pFormat, szamSlashpm, ARRAY_SIZE(szamSlashpm))) + else if (*pFormat == 'a' && !wcsncmp(pFormat, szamSlashpm, ARRAY_SIZE(szamSlashpm))) { /* Date formats: lowercase AM or PM designation * Other formats: Literal @@ -824,7 +821,7 @@ HRESULT WINAPI VarTokenizeFormatString(LPOLESTR lpszFormat, LPBYTE rgbTok, *pLastHours = *pLastHours + 2; TRACE("AM/PM\n"); } - else if (*pFormat == 'A' && !strncmpW(pFormat, szAMSlashPM, ARRAY_SIZE(szAMSlashPM))) + else if (*pFormat == 'A' && !wcsncmp(pFormat, szAMSlashPM, ARRAY_SIZE(szAMSlashPM))) { /* Date formats: Uppercase AM or PM designation * Other formats: Literal @@ -986,7 +983,7 @@ HRESULT WINAPI VarTokenizeFormatString(LPOLESTR lpszFormat, LPBYTE rgbTok, fmt_state &= ~FMT_STATE_OPEN_COPY; } else if ((*pFormat == 't' || *pFormat == 'T') && - !strncmpiW(pFormat, szTTTTT, ARRAY_SIZE(szTTTTT))) + !_wcsnicmp(pFormat, szTTTTT, ARRAY_SIZE(szTTTTT))) { /* Date formats: System time specifier * Other formats: Literal @@ -1376,7 +1373,7 @@ VARIANT_FormatNumber_Bool: hRes = VarBstrFromBool(V_BOOL(&vBool), lcid, boolFlag, &boolStr); if (SUCCEEDED(hRes)) { - strcpyW(pBuff, boolStr); + lstrcpyW(pBuff, boolStr); SysFreeString(boolStr); while (*pBuff) pBuff++; @@ -1418,13 +1415,13 @@ VARIANT_FormatNumber_Bool: if (exponent < 0) { *pBuff++ = '-'; - sprintfW(pBuff, szPercentZeroStar_d, pToken[1], -exponent); + swprintf(pBuff, szPercentZeroStar_d, pToken[1], -exponent); } else { if (*pToken == FMT_NUM_EXP_POS_L || *pToken == FMT_NUM_EXP_POS_U) *pBuff++ = '+'; - sprintfW(pBuff, szPercentZeroStar_d, pToken[1], exponent); + swprintf(pBuff, szPercentZeroStar_d, pToken[1], exponent); } while (*pBuff) pBuff++; @@ -1897,7 +1894,7 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat, } else if (szPrintFmt) { - sprintfW(pBuff, szPrintFmt, dwVal); + swprintf(pBuff, szPrintFmt, dwVal); while (*pBuff) pBuff++; } @@ -1956,7 +1953,7 @@ static HRESULT VARIANT_FormatString(LPVARIANT pVarIn, LPOLESTR lpszFormat, pSrc = V_BSTR(&vStr); if ((strHeader->flags & (FMT_FLAG_LT|FMT_FLAG_GT)) == FMT_FLAG_GT) bUpper = TRUE; - blanks_first = strHeader->copy_chars - strlenW(pSrc); + blanks_first = strHeader->copy_chars - lstrlenW(pSrc); pToken = (const BYTE*)strHeader + sizeof(FMT_DATE_HEADER); while (*pToken != FMT_GEN_END) @@ -1997,9 +1994,9 @@ static HRESULT VARIANT_FormatString(LPVARIANT pVarIn, LPOLESTR lpszFormat, while (dwCount > 0 && *pSrc) { if (bUpper) - *pBuff++ = toupperW(*pSrc); + *pBuff++ = towupper(*pSrc); else - *pBuff++ = tolowerW(*pSrc); + *pBuff++ = towlower(*pSrc); dwCount--; pSrc++; } @@ -2025,9 +2022,9 @@ VARIANT_FormatString_Exit: while (*pSrc) { if (bUpper) - *pBuff++ = toupperW(*pSrc); + *pBuff++ = towupper(*pSrc); else - *pBuff++ = tolowerW(*pSrc); + *pBuff++ = towlower(*pSrc); pSrc++; } VariantClear(&vStr); @@ -2284,9 +2281,9 @@ HRESULT WINAPI VarFormatNumber(LPVARIANT pVarIn, INT nDigits, INT nLeading, INT if (nGrouping == -2) { - WCHAR grouping[16]; + WCHAR grouping[10]; grouping[2] = '\0'; - GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, grouping, ARRAY_SIZE(grouping)); + GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SGROUPING, grouping, ARRAY_SIZE(grouping)); numfmt.Grouping = grouping[2] == '2' ? 32 : grouping[0] - '0'; } else if (nGrouping == -1) @@ -2380,12 +2377,12 @@ HRESULT WINAPI VarFormatPercent(LPVARIANT pVarIn, INT nDigits, INT nLeading, INT if (SUCCEEDED(hRet)) { - DWORD dwLen = strlenW(*pbstrOut); + DWORD dwLen = lstrlenW(*pbstrOut); BOOL bBracket = (*pbstrOut)[dwLen] == ')'; dwLen -= bBracket; memcpy(buff, *pbstrOut, dwLen * sizeof(WCHAR)); - strcpyW(buff + dwLen, bBracket ? szPercentBracket : szPercent); + lstrcpyW(buff + dwLen, bBracket ? szPercentBracket : szPercent); SysFreeString(*pbstrOut); *pbstrOut = SysAllocString(buff); if (!*pbstrOut) @@ -2443,7 +2440,7 @@ HRESULT WINAPI VarFormatCurrency(LPVARIANT pVarIn, INT nDigits, INT nLeading, if (SUCCEEDED(hRet)) { - WCHAR buff[256], decimal[8], thousands[8], currency[8]; + WCHAR buff[256], decimal[8], thousands[4], currency[13]; CURRENCYFMTW numfmt; if (nDigits < 0) @@ -2460,9 +2457,9 @@ HRESULT WINAPI VarFormatCurrency(LPVARIANT pVarIn, INT nDigits, INT nLeading, if (nGrouping == -2) { - WCHAR grouping[16]; + WCHAR grouping[10]; grouping[2] = '\0'; - GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, grouping, ARRAY_SIZE(grouping)); + GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SGROUPING, grouping, ARRAY_SIZE(grouping)); numfmt.Grouping = grouping[2] == '2' ? 32 : grouping[0] - '0'; } else if (nGrouping == -1) @@ -2482,9 +2479,9 @@ HRESULT WINAPI VarFormatCurrency(LPVARIANT pVarIn, INT nDigits, INT nLeading, numfmt.lpDecimalSep = decimal; GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, decimal, ARRAY_SIZE(decimal)); numfmt.lpThousandSep = thousands; - GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, thousands, ARRAY_SIZE(thousands)); + GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, thousands, ARRAY_SIZE(thousands)); numfmt.lpCurrencySymbol = currency; - GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, currency, ARRAY_SIZE(currency)); + GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SCURRENCY, currency, ARRAY_SIZE(currency)); /* use NLS as per VarFormatNumber() */ if (GetCurrencyFormatW(LOCALE_USER_DEFAULT, 0, V_BSTR(&vStr), &numfmt, buff, ARRAY_SIZE(buff))) diff --git a/dll/win32/oleaut32/variant.c b/dll/win32/oleaut32/variant.c index fcbef5317fd..ce96ba14565 100644 --- a/dll/win32/oleaut32/variant.c +++ b/dll/win32/oleaut32/variant.c @@ -25,8 +25,6 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ -#include "config.h" - #include #include #include @@ -37,7 +35,6 @@ #include "windef.h" #include "winbase.h" -#include "wine/unicode.h" #include "winerror.h" #include "variant.h" #include "resource.h" @@ -1635,14 +1632,14 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags, /* First consume all the leading symbols and space from the string */ while (1) { - if (pNumprs->dwInFlags & NUMPRS_LEADING_WHITE && isspaceW(*lpszStr)) + if (pNumprs->dwInFlags & NUMPRS_LEADING_WHITE && iswspace(*lpszStr)) { pNumprs->dwOutFlags |= NUMPRS_LEADING_WHITE; do { cchUsed++; lpszStr++; - } while (isspaceW(*lpszStr)); + } while (iswspace(*lpszStr)); } else if (pNumprs->dwInFlags & NUMPRS_LEADING_PLUS && *lpszStr == chars.cPositiveSymbol && @@ -1717,14 +1714,14 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags, while (*lpszStr) { - if (isdigitW(*lpszStr)) + if (iswdigit(*lpszStr)) { if (dwState & B_PROCESSING_EXPONENT) { int exponentSize = 0; if (dwState & B_EXPONENT_START) { - if (!isdigitW(*lpszStr)) + if (!iswdigit(*lpszStr)) break; /* No exponent digits - invalid */ while (*lpszStr == '0') { @@ -1734,7 +1731,7 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags, } } - while (isdigitW(*lpszStr)) + while (iswdigit(*lpszStr)) { exponentSize *= 10; exponentSize += *lpszStr - '0'; @@ -1906,14 +1903,14 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags, /* Consume any trailing symbols and space */ while (1) { - if ((pNumprs->dwInFlags & NUMPRS_TRAILING_WHITE) && isspaceW(*lpszStr)) + if ((pNumprs->dwInFlags & NUMPRS_TRAILING_WHITE) && iswspace(*lpszStr)) { pNumprs->dwOutFlags |= NUMPRS_TRAILING_WHITE; do { cchUsed++; lpszStr++; - } while (isspaceW(*lpszStr)); + } while (iswspace(*lpszStr)); } else if (pNumprs->dwInFlags & NUMPRS_TRAILING_PLUS && !(pNumprs->dwOutFlags & NUMPRS_LEADING_PLUS) && @@ -5138,7 +5135,9 @@ HRESULT WINAPI VarRound(LPVARIANT pVarIn, int deci, LPVARIANT pVarOut) { double dbl; - VarR8FromDec(&V_DECIMAL(pVarIn), &dbl); + hRet = VarR8FromDec(&V_DECIMAL(pVarIn), &dbl); + if (FAILED(hRet)) + break; if (dbl>0.0f) dbl = floor(dbl*pow(10,deci)+0.5); @@ -5146,7 +5145,7 @@ HRESULT WINAPI VarRound(LPVARIANT pVarIn, int deci, LPVARIANT pVarOut) dbl = ceil(dbl*pow(10,deci)-0.5); V_VT(pVarOut)=VT_DECIMAL; - VarDecFromR8(dbl, &V_DECIMAL(pVarOut)); + hRet = VarDecFromR8(dbl, &V_DECIMAL(pVarOut)); break; } /* cases we don't know yet */ diff --git a/dll/win32/oleaut32/vartype.c b/dll/win32/oleaut32/vartype.c index 067d515e34c..cf18d7db2e9 100644 --- a/dll/win32/oleaut32/vartype.c +++ b/dll/win32/oleaut32/vartype.c @@ -22,8 +22,9 @@ #define NONAMELESSUNION #define NONAMELESSSTRUCT +#include + #include "wine/debug.h" -#include "wine/unicode.h" #include "winbase.h" #include "winuser.h" #include "winnt.h" @@ -6150,13 +6151,13 @@ VarBoolFromStr_CheckLocalised: if (VARIANT_GetLocalisedText(langId, IDS_TRUE, szBuff)) { /* Compare against localised strings, ignoring case */ - if (!strcmpiW(strIn, szBuff)) + if (!wcsicmp(strIn, szBuff)) { *pBoolOut = VARIANT_TRUE; /* Matched localised 'true' text */ return hRes; } VARIANT_GetLocalisedText(langId, IDS_FALSE, szBuff); - if (!strcmpiW(strIn, szBuff)) + if (!wcsicmp(strIn, szBuff)) { *pBoolOut = VARIANT_FALSE; /* Matched localised 'false' text */ return hRes; @@ -6171,9 +6172,9 @@ VarBoolFromStr_CheckLocalised: } /* All checks against localised text have failed, try #TRUE#/#FALSE# */ - if (!strcmpW(strIn, szFalse)) + if (!wcscmp(strIn, szFalse)) *pBoolOut = VARIANT_FALSE; - else if (!strcmpW(strIn, szTrue)) + else if (!wcscmp(strIn, szTrue)) *pBoolOut = VARIANT_TRUE; else { @@ -6356,7 +6357,7 @@ static BSTR VARIANT_MakeBstr(LCID lcid, DWORD dwFlags, WCHAR *szOut) szOut, NULL, szConverted, ARRAY_SIZE(szConverted)); szOut = szConverted; } - return SysAllocStringByteLen((LPCSTR)szOut, strlenW(szOut) * sizeof(WCHAR)); + return SysAllocStringByteLen((LPCSTR)szOut, lstrlenW(szOut) * sizeof(WCHAR)); } /* Create a (possibly localised) BSTR from a UI8 and sign */ @@ -6487,8 +6488,8 @@ static BSTR VARIANT_BstrReplaceDecimal(const WCHAR * buff, LCID lcid, ULONG dwFl minFormat.NegativeOrder = 1; /* NLS_NEG_LEFT */ /* count number of decimal digits in string */ - p = strchrW( buff, '.' ); - if (p) minFormat.NumDigits = strlenW(p + 1); + p = wcschr( buff, '.' ); + if (p) minFormat.NumDigits = lstrlenW(p + 1); numbuff[0] = '\0'; if (!GetNumberFormatW(lcid, 0, buff, &minFormat, numbuff, ARRAY_SIZE(numbuff))) @@ -6513,7 +6514,7 @@ static HRESULT VARIANT_BstrFromReal(DOUBLE dblIn, LCID lcid, ULONG dwFlags, if (!pbstrOut) return E_INVALIDARG; - sprintfW( buff, lpszFormat, dblIn ); + swprintf( buff, lpszFormat, dblIn ); /* Negative zeroes are disallowed (some applications depend on this). If buff starts with a minus, and then nothing follows but zeroes @@ -6523,7 +6524,7 @@ static HRESULT VARIANT_BstrFromReal(DOUBLE dblIn, LCID lcid, ULONG dwFlags, if (buff[0] == '-') { static const WCHAR szAccept[] = {'0', '.', '\0'}; - if (strlenW(buff + 1) == strspnW(buff + 1, szAccept)) + if (lstrlenW(buff + 1) == wcsspn(buff + 1, szAccept)) { buff[0] = '0'; buff[1] = '\0'; } } @@ -6814,7 +6815,7 @@ HRESULT WINAPI VarBstrFromDate(DATE dateIn, LCID lcid, ULONG dwFlags, BSTR* pbst if (!(dwFlags & VAR_DATEVALUEONLY)) { - time = date + strlenW(date); + time = date + lstrlenW(date); if (time != date) *time++ = ' '; if (!GetTimeFormatW(lcid, dwFormatFlags, &st, NULL, time, ARRAY_SIZE(date)-(time-date))) @@ -7658,25 +7659,25 @@ HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pd /* Parse the string into our structure */ while (*strIn) { - if (isdigitW(*strIn)) + if (iswdigit(*strIn)) { if (dp.dwCount >= 6) { hRet = DISP_E_TYPEMISMATCH; break; } - dp.dwValues[dp.dwCount] = strtoulW(strIn, &strIn, 10); + dp.dwValues[dp.dwCount] = wcstoul(strIn, &strIn, 10); dp.dwCount++; strIn--; } - else if (isalphaW(*strIn)) + else if (iswalpha(*strIn)) { BOOL bFound = FALSE; for (i = 0; i < ARRAY_SIZE(tokens); i++) { - DWORD dwLen = strlenW(tokens[i]); - if (dwLen && !strncmpiW(strIn, tokens[i], dwLen)) + DWORD dwLen = lstrlenW(tokens[i]); + if (dwLen && !_wcsnicmp(strIn, tokens[i], dwLen)) { if (i <= 25) { @@ -7755,7 +7756,7 @@ HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pd else dp.dwFlags[dp.dwCount - 1] |= DP_DATESEP; } - else if (*strIn == ',' || isspaceW(*strIn)) + else if (*strIn == ',' || iswspace(*strIn)) { if (*strIn == ',' && !strIn[1]) hRet = DISP_E_TYPEMISMATCH; diff --git a/media/doc/README.WINE b/media/doc/README.WINE index 2d0c7cc1278..ab5540dcdb7 100644 --- a/media/doc/README.WINE +++ b/media/doc/README.WINE @@ -142,7 +142,7 @@ dll/win32/odbc32 # Synced to WineStaging-4.18. Depends on port of L dll/win32/odbccp32 # Synced to WineStaging-4.18 dll/win32/ole32 # Synced to WineStaging-4.18 dll/win32/oleacc # Synced to WineStaging-4.18 -dll/win32/oleaut32 # Synced to WineStaging-4.0 +dll/win32/oleaut32 # Synced to WineStaging-4.18 dll/win32/olecli32 # Synced to WineStaging-3.3 dll/win32/oledlg # Synced to WineStaging-4.0 dll/win32/olepro32 # Synced to WineStaging-3.3 -- 2.17.1