ApfelTeeSaft/reactos
1
0
Fork 0
mirror of https://github.com/ApfelTeeSaft/reactos.git synced 2026-08-26 19:33:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

[OLEAUT32] Sync with Wine 10.0. CORE-20595

Browse Source
This commit is contained in:
Amine Khaldi
2026-07-25 17:55:19 +01:00
parent 5821d9d8a3
commit e05d78ede0
27 changed files with 2589 additions and 3227 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dll/win32/oleaut32/CMakeLists.txt
+4 -5
View File
@@ -3,14 +3,11 @@ remove_definitions(-D_WIN32_WINNT=0x502)
add_definitions(-D_WIN32_WINNT=0x600)
add_definitions(
-D__ROS_LONG64__
-DCOM_NO_WINDOWS_H
-D_OLEAUT32_
-DPROXY_DELEGATION
-DWINE_REGISTER_DLL
-DENTRY_PREFIX=OLEAUTPS_
-DPROXY_CLSID=CLSID_PSFactoryBuffer
-D_CRT_NON_CONFORMING_SWPRINTFS)
-DPROXY_CLSID=CLSID_PSFactoryBuffer)
spec2def(oleaut32.dll oleaut32.spec ADD_IMPORTLIB)
add_rpcproxy_files(oleaut32_oaidl.idl oleaut32_ocidl.idl)
@@ -25,6 +22,7 @@ list(APPEND SOURCE
olepropframe.c
recinfo.c
safearray.c
thunks.c
typelib.c
usrmarshal.c
varformat.c
@@ -60,8 +58,9 @@ endif()
add_idl_headers(oleaut32_idlheader oleaut32_oaidl.idl)
add_dependencies(oleaut32 oleaut32_idlheader)
add_idl_reg_scripts(oleaut32 registry oleaut32_oaidl.idl oleaut32_ocidl.idl)
set_module_type(oleaut32 win32dll)
target_link_libraries(oleaut32 wine wineldr uuid ${PSEH_LIB} oldnames)
target_link_libraries(oleaut32 wine wineldr uuid ${PSEH_LIB} oldnames wine_dll_canunload)
add_delay_importlibs(oleaut32 comctl32 urlmon windowscodecs)
add_importlibs(oleaut32 ole32 rpcrt4 user32 gdi32 advapi32 kernel32_vista msvcrt kernel32 ntdll)
add_pch(oleaut32 precomp.h "${PCH_SKIP_SOURCE}")
dll/win32/oleaut32/connpt.c
+27 -117
View File
@@ -101,9 +101,6 @@ static inline EnumConnectionsImpl *impl_from_IEnumConnections(IEnumConnections *
return CONTAINING_RECORD(iface, EnumConnectionsImpl, IEnumConnections_iface);
}
/************************************************************************
* ConnectionPointImpl_Destroy
*/
static void ConnectionPointImpl_Destroy(ConnectionPointImpl *Obj)
{
DWORD i;
@@ -113,16 +110,11 @@ static void ConnectionPointImpl_Destroy(ConnectionPointImpl *Obj)
Obj->sinks[i] = NULL;
}
}
HeapFree(GetProcessHeap(), 0, Obj->sinks);
HeapFree(GetProcessHeap(), 0, Obj);
free(Obj->sinks);
free(Obj);
return;
}
/************************************************************************
* ConnectionPointImpl_QueryInterface (IUnknown)
*
* See Windows documentation for more details on IUnknown methods.
*/
static HRESULT WINAPI ConnectionPointImpl_QueryInterface(
IConnectionPoint* iface,
REFIID riid,
@@ -160,47 +152,29 @@ static HRESULT WINAPI ConnectionPointImpl_QueryInterface(
return S_OK;
}
/************************************************************************
* ConnectionPointImpl_AddRef (IUnknown)
*
* See Windows documentation for more details on IUnknown methods.
*/
static ULONG WINAPI ConnectionPointImpl_AddRef(IConnectionPoint* iface)
{
ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
ULONG refCount = InterlockedIncrement(&This->ref);
TRACE("(%p)->(ref before=%d)\n", This, refCount - 1);
TRACE("%p, refcount %lu.\n", iface, refCount);
return refCount;
}
/************************************************************************
* ConnectionPointImpl_Release (IUnknown)
*
* See Windows documentation for more details on IUnknown methods.
*/
static ULONG WINAPI ConnectionPointImpl_Release(
IConnectionPoint* iface)
{
ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
ULONG refCount = InterlockedDecrement(&This->ref);
TRACE("(%p)->(ref before=%d)\n", This, refCount + 1);
TRACE("%p, refcount %lu.\n", iface, refCount);
/*
* If the reference count goes down to 0, perform suicide.
*/
if (!refCount) ConnectionPointImpl_Destroy(This);
return refCount;
}
/************************************************************************
* ConnectionPointImpl_GetConnectionInterface (IConnectionPoint)
*
*/
static HRESULT WINAPI ConnectionPointImpl_GetConnectionInterface(
IConnectionPoint *iface,
IID *piid)
@@ -211,10 +185,6 @@ static HRESULT WINAPI ConnectionPointImpl_GetConnectionInterface(
return S_OK;
}
/************************************************************************
* ConnectionPointImpl_GetConnectionPointContainer (IConnectionPoint)
*
*/
static HRESULT WINAPI ConnectionPointImpl_GetConnectionPointContainer(
IConnectionPoint *iface,
IConnectionPointContainer **ppCPC)
@@ -225,10 +195,6 @@ static HRESULT WINAPI ConnectionPointImpl_GetConnectionPointContainer(
return IUnknown_QueryInterface(This->Obj, &IID_IConnectionPointContainer, (void**)ppCPC);
}
/************************************************************************
* ConnectionPointImpl_Advise (IConnectionPoint)
*
*/
static HRESULT WINAPI ConnectionPointImpl_Advise(IConnectionPoint *iface,
IUnknown *lpUnk,
DWORD *pdwCookie)
@@ -247,9 +213,9 @@ static HRESULT WINAPI ConnectionPointImpl_Advise(IConnectionPoint *iface,
break;
}
if(i == This->maxSinks) {
This->sinks = realloc(This->sinks, (This->maxSinks + MAXSINKS) * sizeof(IUnknown*));
memset(This->sinks + This->maxSinks, 0, MAXSINKS * sizeof(IUnknown*));
This->maxSinks += MAXSINKS;
This->sinks = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->sinks,
This->maxSinks * sizeof(IUnknown *));
}
This->sinks[i] = lpSink;
This->nSinks++;
@@ -258,15 +224,11 @@ static HRESULT WINAPI ConnectionPointImpl_Advise(IConnectionPoint *iface,
}
/************************************************************************
* ConnectionPointImpl_Unadvise (IConnectionPoint)
*
*/
static HRESULT WINAPI ConnectionPointImpl_Unadvise(IConnectionPoint *iface,
DWORD dwCookie)
static HRESULT WINAPI ConnectionPointImpl_Unadvise(IConnectionPoint *iface, DWORD dwCookie)
{
ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
TRACE("(%p)->(%d)\n", This, dwCookie);
TRACE("%p, %#lx.\n", iface, dwCookie);
if(dwCookie == 0 || dwCookie > This->maxSinks) return E_INVALIDARG;
@@ -278,13 +240,7 @@ static HRESULT WINAPI ConnectionPointImpl_Unadvise(IConnectionPoint *iface,
return S_OK;
}
/************************************************************************
* ConnectionPointImpl_EnumConnections (IConnectionPoint)
*
*/
static HRESULT WINAPI ConnectionPointImpl_EnumConnections(
IConnectionPoint *iface,
LPENUMCONNECTIONS *ppEnum)
static HRESULT WINAPI ConnectionPointImpl_EnumConnections(IConnectionPoint *iface, IEnumConnections **ppEnum)
{
ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
CONNECTDATA *pCD;
@@ -298,7 +254,7 @@ static HRESULT WINAPI ConnectionPointImpl_EnumConnections(
if(This->nSinks == 0) return OLE_E_NOCONNECTION;
pCD = HeapAlloc(GetProcessHeap(), 0, sizeof(CONNECTDATA) * This->nSinks);
pCD = malloc(sizeof(CONNECTDATA) * This->nSinks);
for(i = 0, nextslot = 0; i < This->maxSinks; i++) {
if(This->sinks[i] != NULL) {
@@ -318,7 +274,7 @@ static HRESULT WINAPI ConnectionPointImpl_EnumConnections(
&IID_IEnumConnections, (void**)ppEnum);
IEnumConnections_Release(&EnumObj->IEnumConnections_iface);
HeapFree(GetProcessHeap(), 0, pCD);
free(pCD);
return hr;
}
@@ -337,20 +293,17 @@ static const IConnectionPointVtbl ConnectionPointImpl_VTable =
static const IEnumConnectionsVtbl EnumConnectionsImpl_VTable;
/************************************************************************
* EnumConnectionsImpl_Construct
*/
static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
DWORD nSinks,
CONNECTDATA *pCD)
{
EnumConnectionsImpl *Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj));
EnumConnectionsImpl *Obj = malloc(sizeof(*Obj));
DWORD i;
Obj->IEnumConnections_iface.lpVtbl = &EnumConnectionsImpl_VTable;
Obj->ref = 1;
Obj->pUnk = pUnk;
Obj->pCD = HeapAlloc(GetProcessHeap(), 0, nSinks * sizeof(CONNECTDATA));
Obj->pCD = malloc(nSinks * sizeof(CONNECTDATA));
Obj->nConns = nSinks;
Obj->nCur = 0;
@@ -361,9 +314,6 @@ static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
return Obj;
}
/************************************************************************
* EnumConnectionsImpl_Destroy
*/
static void EnumConnectionsImpl_Destroy(EnumConnectionsImpl *Obj)
{
DWORD i;
@@ -371,16 +321,11 @@ static void EnumConnectionsImpl_Destroy(EnumConnectionsImpl *Obj)
for(i = 0; i < Obj->nConns; i++)
IUnknown_Release(Obj->pCD[i].pUnk);
HeapFree(GetProcessHeap(), 0, Obj->pCD);
HeapFree(GetProcessHeap(), 0, Obj);
free(Obj->pCD);
free(Obj);
return;
}
/************************************************************************
* EnumConnectionsImpl_QueryInterface (IUnknown)
*
* See Windows documentation for more details on IUnknown methods.
*/
static HRESULT WINAPI EnumConnectionsImpl_QueryInterface(
IEnumConnections* iface,
REFIID riid,
@@ -417,56 +362,37 @@ static HRESULT WINAPI EnumConnectionsImpl_QueryInterface(
return S_OK;
}
/************************************************************************
* EnumConnectionsImpl_AddRef (IUnknown)
*
* See Windows documentation for more details on IUnknown methods.
*/
static ULONG WINAPI EnumConnectionsImpl_AddRef(IEnumConnections* iface)
{
EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
ULONG refCount = InterlockedIncrement(&This->ref);
TRACE("(%p)->(ref before=%d)\n", This, refCount - 1);
TRACE("%p, refcount %lu.\n", iface, refCount);
IUnknown_AddRef(This->pUnk);
return refCount;
}
/************************************************************************
* EnumConnectionsImpl_Release (IUnknown)
*
* See Windows documentation for more details on IUnknown methods.
*/
static ULONG WINAPI EnumConnectionsImpl_Release(IEnumConnections* iface)
{
EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
ULONG refCount = InterlockedDecrement(&This->ref);
TRACE("(%p)->(ref before=%d)\n", This, refCount + 1);
TRACE("%p, refcount %lu.\n", iface, refCount);
IUnknown_Release(This->pUnk);
/*
* If the reference count goes down to 0, perform suicide.
*/
if (!refCount) EnumConnectionsImpl_Destroy(This);
return refCount;
}
/************************************************************************
* EnumConnectionsImpl_Next (IEnumConnections)
*
*/
static HRESULT WINAPI EnumConnectionsImpl_Next(IEnumConnections* iface,
ULONG cConn, LPCONNECTDATA pCD,
ULONG *pEnum)
static HRESULT WINAPI EnumConnectionsImpl_Next(IEnumConnections* iface, ULONG cConn, LPCONNECTDATA pCD, ULONG *pEnum)
{
EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
DWORD nRet = 0;
TRACE("(%p)->(%d, %p, %p)\n", This, cConn, pCD, pEnum);
TRACE("%p, %lu, %p, %p.\n", iface, cConn, pCD, pEnum);
if(pEnum == NULL) {
if(cConn != 1)
@@ -491,16 +417,11 @@ static HRESULT WINAPI EnumConnectionsImpl_Next(IEnumConnections* iface,
return S_OK;
}
/************************************************************************
* EnumConnectionsImpl_Skip (IEnumConnections)
*
*/
static HRESULT WINAPI EnumConnectionsImpl_Skip(IEnumConnections* iface,
ULONG cSkip)
static HRESULT WINAPI EnumConnectionsImpl_Skip(IEnumConnections* iface, ULONG cSkip)
{
EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
TRACE("(%p)->(%d)\n", This, cSkip);
TRACE("%p, %lu.\n", iface, cSkip);
if(This->nCur + cSkip >= This->nConns)
return S_FALSE;
@@ -510,11 +431,6 @@ static HRESULT WINAPI EnumConnectionsImpl_Skip(IEnumConnections* iface,
return S_OK;
}
/************************************************************************
* EnumConnectionsImpl_Reset (IEnumConnections)
*
*/
static HRESULT WINAPI EnumConnectionsImpl_Reset(IEnumConnections* iface)
{
EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
@@ -525,13 +441,7 @@ static HRESULT WINAPI EnumConnectionsImpl_Reset(IEnumConnections* iface)
return S_OK;
}
/************************************************************************
* EnumConnectionsImpl_Clone (IEnumConnections)
*
*/
static HRESULT WINAPI EnumConnectionsImpl_Clone(IEnumConnections* iface,
LPENUMCONNECTIONS *ppEnum)
static HRESULT WINAPI EnumConnectionsImpl_Clone(IEnumConnections* iface, IEnumConnections **ppEnum)
{
EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
EnumConnectionsImpl *newObj;
@@ -577,7 +487,7 @@ HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid,
TRACE("(%p %s %p)\n", pUnk, debugstr_guid(riid), pCP);
*pCP = NULL;
Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj));
Obj = malloc(sizeof(*Obj));
if (!Obj)
return E_OUTOFMEMORY;
@@ -586,7 +496,7 @@ HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid,
Obj->ref = 1;
Obj->iid = *riid;
Obj->maxSinks = MAXSINKS;
Obj->sinks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IUnknown*) * MAXSINKS);
Obj->sinks = calloc(MAXSINKS, sizeof(IUnknown*));
Obj->nSinks = 0;
*pCP = &Obj->IConnectionPoint_iface;
dll/win32/oleaut32/connpt.h
+1 -1
View File
@@ -19,6 +19,6 @@
#ifndef _CONNPT_H
#define _CONNPT_H
HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid, IConnectionPoint **pCP) DECLSPEC_HIDDEN;
HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid, IConnectionPoint **pCP);
#endif /* _CONNPT_H */
dll/win32/oleaut32/dispatch.c
+9 -6
View File
@@ -176,7 +176,7 @@ done:
* (linked at run-time), as opposed to early-bound (linked at compile time).
*
* The interface is used by objects that wish to called by scripting
* languages such as VBA, in order to minimise the amount of COM and C/C++
* languages such as VBA, in order to minimize the amount of COM and C/C++
* knowledge required, or by objects that wish to live out of process from code
* that will call their methods.
*
@@ -248,7 +248,7 @@ static ULONG WINAPI StdDispatch_AddRef(LPDISPATCH iface)
StdDispatch *This = impl_from_IDispatch(iface);
ULONG refCount = InterlockedIncrement(&This->ref);
TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
TRACE("%p, refcount %lu.\n", iface, refCount);
return refCount;
}
@@ -263,7 +263,7 @@ static ULONG WINAPI StdDispatch_Release(LPDISPATCH iface)
StdDispatch *This = impl_from_IDispatch(iface);
ULONG refCount = InterlockedDecrement(&This->ref);
TRACE("(%p)->(ref before=%u)\n", This, refCount + 1);
TRACE("%p, refcount %lu.\n", iface, refCount);
if (!refCount)
{
@@ -319,7 +319,8 @@ static HRESULT WINAPI StdDispatch_GetTypeInfoCount(LPDISPATCH iface, UINT * pcti
static HRESULT WINAPI StdDispatch_GetTypeInfo(LPDISPATCH iface, UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
{
StdDispatch *This = impl_from_IDispatch(iface);
TRACE("(%d, %x, %p)\n", iTInfo, lcid, ppTInfo);
TRACE("%d, %#lx, %p.\n", iTInfo, lcid, ppTInfo);
*ppTInfo = NULL;
if (iTInfo != 0)
@@ -360,7 +361,8 @@ static HRESULT WINAPI StdDispatch_GetTypeInfo(LPDISPATCH iface, UINT iTInfo, LCI
static HRESULT WINAPI StdDispatch_GetIDsOfNames(LPDISPATCH iface, REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId)
{
StdDispatch *This = impl_from_IDispatch(iface);
TRACE("(%s, %p, %d, 0x%x, %p)\n", debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
TRACE("%s, %p, %d, %#lx, %p.\n", debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
if (!IsEqualGUID(riid, &IID_NULL))
{
@@ -398,7 +400,8 @@ static HRESULT WINAPI StdDispatch_Invoke(LPDISPATCH iface, DISPID dispIdMember,
EXCEPINFO * pExcepInfo, UINT * puArgErr)
{
StdDispatch *This = impl_from_IDispatch(iface);
TRACE("(%d, %s, 0x%x, 0x%x, %p, %p, %p, %p)\n", dispIdMember, debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
TRACE("%ld, %s, %#lx, 0x%x, %p, %p, %p, %p.\n", dispIdMember, debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
if (!IsEqualGUID(riid, &IID_NULL))
{
dll/win32/oleaut32/hash.c
+3 -31
View File
@@ -509,7 +509,7 @@ ULONG WINAPI LHashValOfNameSysA( SYSKIND skind, LCID lcid, LPCSTR lpStr)
ULONG nHiWord, nLoWord = 0x0deadbee;
const unsigned char *str = (const unsigned char *)lpStr, *pnLookup = NULL;
TRACE("(%d, 0x%x, %s) %s\n", skind, lcid, debugstr_a(lpStr),
TRACE("%d, %#lx, %s, %s.\n", skind, lcid, debugstr_a(lpStr),
(skind == SYS_WIN16) ? "SYS_WIN16" : (skind == SYS_WIN32) ? "SYS_WIN32" : "");
if (!str)
@@ -520,34 +520,6 @@ ULONG WINAPI LHashValOfNameSysA( SYSKIND skind, LCID lcid, LPCSTR lpStr)
switch (PRIMARYLANGID(LANGIDFROMLCID(lcid)))
{
default:
ERR("Unknown lcid %x, treating as latin-based, please report\n", lcid);
/* .. Fall Through .. */
case LANG_AFRIKAANS: case LANG_ALBANIAN: case LANG_ARMENIAN:
case LANG_ASSAMESE: case LANG_AZERI: case LANG_BASQUE:
case LANG_BELARUSIAN: case LANG_BENGALI: case LANG_BULGARIAN:
case LANG_CATALAN: case LANG_DANISH: case LANG_DIVEHI:
case LANG_DUTCH: case LANG_ENGLISH: case LANG_ESTONIAN:
case LANG_FAEROESE: case LANG_FINNISH: case LANG_FRENCH:
case LANG_GALICIAN: case LANG_GEORGIAN: case LANG_GERMAN:
case LANG_GUJARATI: case LANG_HINDI: case LANG_INDONESIAN:
case LANG_ITALIAN: case LANG_KANNADA: case LANG_KASHMIRI:
case LANG_KAZAK: case LANG_KONKANI: case LANG_KYRGYZ:
case LANG_LATVIAN: case LANG_LITHUANIAN: case LANG_MACEDONIAN:
case LANG_MALAY: case LANG_MALAYALAM: case LANG_MANIPURI:
case LANG_MARATHI: case LANG_MONGOLIAN: case LANG_NEPALI:
case LANG_ORIYA: case LANG_PORTUGUESE: case LANG_PUNJABI:
case LANG_ROMANIAN: case LANG_SANSKRIT: case LANG_SERBIAN:
case LANG_SINDHI: case LANG_SLOVENIAN: case LANG_SWAHILI:
case LANG_SWEDISH: case LANG_SYRIAC: case LANG_TAMIL:
case LANG_TATAR: case LANG_TELUGU: case LANG_THAI:
case LANG_UKRAINIAN: case LANG_URDU: case LANG_UZBEK:
case LANG_VIETNAMESE: case LANG_SCOTTISH_GAELIC: case LANG_MALTESE:
case LANG_MAORI: case LANG_ROMANSH: case LANG_IRISH:
case LANG_SAMI: case LANG_UPPER_SORBIAN: case LANG_SUTU:
case LANG_TSONGA: case LANG_TSWANA: case LANG_VENDA:
case LANG_XHOSA: case LANG_ZULU: case LANG_ESPERANTO:
case LANG_WALON: case LANG_CORNISH: case LANG_WELSH:
case LANG_BRETON: case LANG_MANX_GAELIC:
nOffset = 16;
pnLookup = Lookup_16;
break;
@@ -633,9 +605,9 @@ ULONG WINAPI LHashValOfNameSys(SYSKIND skind, LCID lcid, LPCOLESTR str)
if (!str) return 0;
len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
strA = HeapAlloc( GetProcessHeap(), 0, len );
strA = malloc(len);
WideCharToMultiByte( CP_ACP, 0, str, -1, strA, len, NULL, NULL );
res = LHashValOfNameSysA(skind, lcid, strA);
HeapFree(GetProcessHeap(), 0, strA);
free(strA);
return res;
}
dll/win32/oleaut32/oleaut.c
+165 -116
View File
@@ -18,6 +18,7 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
@@ -34,6 +35,7 @@
#include "ole2.h"
#include "olectl.h"
#include "oleauto.h"
#include "rpcproxy.h"
#include "initguid.h"
#include "typelib.h"
#include "oleaut32_oaidl.h"
@@ -115,7 +117,7 @@ static inline size_t bstr_alloc_size(size_t size)
static inline bstr_t *bstr_from_str(BSTR str)
{
return CONTAINING_RECORD((void *)str, bstr_t, u.str);
return CONTAINING_RECORD(str, bstr_t, u.str);
}
static inline bstr_cache_entry_t *get_cache_entry_from_idx(unsigned cache_idx)
@@ -505,9 +507,6 @@ void WINAPI SetOaNoCache(void)
bstr_cache_enabled = FALSE;
}
static const WCHAR _delimiter[] = {'!',0}; /* default delimiter apparently */
static const WCHAR *pdelimiter = &_delimiter[0];
/***********************************************************************
* RegisterActiveObject (OLEAUT32.33)
*
@@ -533,7 +532,7 @@ HRESULT WINAPI DECLSPEC_HOTPATCH RegisterActiveObject(
DWORD rot_flags = ROTFLAGS_REGISTRATIONKEEPSALIVE; /* default registration is strong */
StringFromGUID2(rcid,guidbuf,39);
ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
ret = CreateItemMoniker(L"!", guidbuf, &moniker);
if (FAILED(ret))
return ret;
ret = GetRunningObjectTable(0,&runobtable);
@@ -597,7 +596,7 @@ HRESULT WINAPI DECLSPEC_HOTPATCH GetActiveObject(REFCLSID rcid,LPVOID preserved,
LPMONIKER moniker;
StringFromGUID2(rcid,guidbuf,39);
ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
ret = CreateItemMoniker(L"!", guidbuf, &moniker);
if (FAILED(ret))
return ret;
ret = GetRunningObjectTable(0,&runobtable);
@@ -660,15 +659,14 @@ ULONG WINAPI OaBuildVersion(void)
case 0x00000005: /* W2K */
return MAKELONG(0xffff, 40);
case 0x00000105: /* WinXP */
#ifdef __REACTOS__
case 0x00000205: /* Win2K3 */
#endif /* __REACTOS__ */
case 0x00000006: /* Vista */
case 0x00000106: /* Win7 */
case 0x00000205: /* W2K3 */
case 0x00000206: /* Win8, Win10, Win11 */
return MAKELONG(0xffff, 50);
default:
FIXME("Version value not known yet. Please investigate it !\n");
return MAKELONG(0xffff, 40); /* for now return the same value as for w2k */
return MAKELONG(0xffff, 50); /* for now return the same value as for Win10 */
}
}
@@ -697,7 +695,7 @@ HRESULT WINAPI OleTranslateColor(
COLORREF colorref;
BYTE b = HIBYTE(HIWORD(clr));
TRACE("(%08x, %p, %p)\n", clr, hpal, pColorRef);
TRACE("%#lx, %p, %p.\n", clr, hpal, pColorRef);
/*
* In case pColorRef is NULL, provide our own to simplify the code.
@@ -762,10 +760,10 @@ HRESULT WINAPI OleTranslateColor(
return S_OK;
}
extern HRESULT WINAPI OLEAUTPS_DllGetClassObject(REFCLSID, REFIID, LPVOID *) DECLSPEC_HIDDEN;
extern BOOL WINAPI OLEAUTPS_DllMain(HINSTANCE, DWORD, LPVOID) DECLSPEC_HIDDEN;
extern HRESULT WINAPI OLEAUTPS_DllRegisterServer(void) DECLSPEC_HIDDEN;
extern HRESULT WINAPI OLEAUTPS_DllUnregisterServer(void) DECLSPEC_HIDDEN;
extern HRESULT WINAPI OLEAUTPS_DllGetClassObject(REFCLSID, REFIID, LPVOID *);
extern BOOL WINAPI OLEAUTPS_DllMain(HINSTANCE, DWORD, LPVOID);
extern HRESULT WINAPI OLEAUTPS_DllRegisterServer(void);
extern HRESULT WINAPI OLEAUTPS_DllUnregisterServer(void);
extern HRESULT WINAPI CreateProxyFromTypeInfo(ITypeInfo *typeinfo,
IUnknown *outer, REFIID iid, IRpcProxyBuffer **proxy, void **obj);
@@ -820,7 +818,7 @@ static BOOL actctx_get_typelib_module(REFIID iid, WCHAR *module, DWORD len)
if (tlib->name_len/sizeof(WCHAR) >= len)
{
ERR("need larger module buffer, %u\n", tlib->name_len);
ERR("need larger module buffer, %lu.\n", tlib->name_len);
return FALSE;
}
@@ -832,13 +830,13 @@ static BOOL actctx_get_typelib_module(REFIID iid, WCHAR *module, DWORD len)
static HRESULT reg_get_typelib_module(REFIID iid, WCHAR *module, DWORD len)
{
REGSAM opposite = (sizeof(void*) == 8) ? KEY_WOW64_32KEY : KEY_WOW64_64KEY;
char tlguid[200], typelibkey[300], interfacekey[300], ver[100], tlfn[260];
char tlguid[200], typelibkey[316], interfacekey[300], ver[100], tlfn[260];
DWORD tlguidlen, verlen, type;
LONG tlfnlen, err;
BOOL is_wow64;
HKEY ikey;
sprintf( interfacekey, "Interface\\{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\Typelib",
sprintf( interfacekey, "Interface\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\Typelib",
iid->Data1, iid->Data2, iid->Data3,
iid->Data4[0], iid->Data4[1], iid->Data4[2], iid->Data4[3],
iid->Data4[4], iid->Data4[5], iid->Data4[6], iid->Data4[7]
@@ -989,7 +987,7 @@ static HRESULT WINAPI dispatch_typelib_ps_CreateProxy(IPSFactoryBuffer *iface,
hr = dispatch_create_proxy(outer, proxy, out);
if (FAILED(hr))
ERR("Failed to create proxy, hr %#x.\n", hr);
ERR("Failed to create proxy, hr %#lx.\n", hr);
ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
ITypeInfo_Release(typeinfo);
@@ -1009,6 +1007,114 @@ static HRESULT dispatch_create_stub(IUnknown *server, IRpcStubBuffer **stub)
return hr;
}
struct dispinterface_stub
{
CInterfaceStubVtbl stub_vtbl;
CStdStubBuffer stub_buffer;
};
static struct dispinterface_stub *impl_from_IRpcStubBuffer(IRpcStubBuffer *iface)
{
return CONTAINING_RECORD(&iface->lpVtbl, struct dispinterface_stub, stub_buffer.lpVtbl);
}
static ULONG WINAPI dispinterface_stub_Release(IRpcStubBuffer *iface)
{
struct dispinterface_stub *stub = impl_from_IRpcStubBuffer(iface);
unsigned int refcount = InterlockedDecrement(&stub->stub_buffer.RefCount);
TRACE("%p decreasing refcount to %u.\n", stub, refcount);
if (!refcount)
{
/* Copied from NdrCStdStubBuffer_Release(), but supposedly incorrect
* according to the comment there. */
IRpcStubBuffer_Disconnect(iface);
free(stub);
}
return refcount;
}
extern const ExtendedProxyFileInfo oleaut32_oaidl_ProxyFileInfo;
static const CInterfaceStubVtbl *find_idispatch_stub_vtbl(void)
{
CInterfaceStubVtbl *const *vtbl;
for (vtbl = oleaut32_oaidl_ProxyFileInfo.pStubVtblList; *vtbl; ++vtbl)
{
if (IsEqualGUID((*vtbl)->header.piid, &IID_IDispatch))
return *vtbl;
}
assert(0);
return NULL;
}
/* Normal dispinterfaces have an IID specified by the IDL compiler as DIID_*,
* but are otherwise identical to IDispatch. Unfortunately, such interfaces may
* not actually support IDispatch in QueryInterface.
*
* This becomes a problem, since CreateStub() was designed such that, for some
* reason, the caller need not actually pass the interface matching "iid". As
* such the standard rpcrt4 implementation will query the server for the
* relevant IID.
*
* This means that we cannot just pass IID_IDispatch with the object, even
* though it is in theory an IDispatch. However, while the standard stub
* constructor is not exported from rpcrt4, all of the vtbl methods are, and
* the type is public, so we *can* manually create it ourselves, bypassing the
* QueryInterface check.
*
* This relies on some rpcrt4 implementation details.
*/
static HRESULT dispinterface_create_stub(IUnknown *server, const GUID *iid, IRpcStubBuffer **stub)
{
const CInterfaceStubVtbl *stub_vtbl = find_idispatch_stub_vtbl();
struct dispinterface_stub *object;
void *dispatch;
HRESULT hr;
if (!(object = calloc(1, sizeof(*object))))
return E_OUTOFMEMORY;
/* It's possible we can just assume that "server" is already the
* dispinterface type—we don't have tests for this—but since rpcrt4 queries
* (which we do have tests for) it makes sense for us to match that
* behaviour. */
if (FAILED(hr = IUnknown_QueryInterface(server, iid, &dispatch)))
{
ERR("Object does not support interface %s.\n", debugstr_guid(iid));
free(object);
return hr;
}
object->stub_vtbl.header = stub_vtbl->header;
object->stub_vtbl.Vtbl.QueryInterface = CStdStubBuffer_QueryInterface;
object->stub_vtbl.Vtbl.AddRef = CStdStubBuffer_AddRef;
object->stub_vtbl.Vtbl.Release = dispinterface_stub_Release;
object->stub_vtbl.Vtbl.Connect = CStdStubBuffer_Connect;
object->stub_vtbl.Vtbl.Disconnect = CStdStubBuffer_Disconnect;
object->stub_vtbl.Vtbl.Invoke = CStdStubBuffer_Invoke;
object->stub_vtbl.Vtbl.IsIIDSupported = CStdStubBuffer_IsIIDSupported;
object->stub_vtbl.Vtbl.CountRefs = CStdStubBuffer_CountRefs;
object->stub_vtbl.Vtbl.DebugServerQueryInterface = CStdStubBuffer_DebugServerQueryInterface;
object->stub_vtbl.Vtbl.DebugServerRelease = CStdStubBuffer_DebugServerRelease;
object->stub_buffer.lpVtbl = &object->stub_vtbl.Vtbl;
object->stub_buffer.RefCount = 1;
object->stub_buffer.pvServerObject = dispatch;
/* rpcrt4 will also fill pPSFactory, but it never uses it except in the
* Release method (which we reimplement). It's only to keep a reference to
* the module to implement NdrDllCanUnloadNow(). We use the default
* DllCanUnloadNow() from winecrt0, which always returns S_FALSE, so don't
* bother filling pPSFactory. */
TRACE("Created stub %p.\n", object);
*stub = (IRpcStubBuffer *)&object->stub_buffer.lpVtbl;
return S_OK;
}
static HRESULT WINAPI dispatch_typelib_ps_CreateStub(IPSFactoryBuffer *iface,
REFIID iid, IUnknown *server, IRpcStubBuffer **stub)
{
@@ -1032,10 +1138,10 @@ static HRESULT WINAPI dispatch_typelib_ps_CreateStub(IPSFactoryBuffer *iface,
if (attr->typekind == TKIND_INTERFACE || (attr->wTypeFlags & TYPEFLAG_FDUAL))
hr = CreateStubFromTypeInfo(typeinfo, iid, server, stub);
else
hr = dispatch_create_stub(server, stub);
hr = dispinterface_create_stub(server, iid, stub);
if (FAILED(hr))
ERR("Failed to create proxy, hr %#x.\n", hr);
ERR("Failed to create stub, hr %#lx.\n", hr);
ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
ITypeInfo_Release(typeinfo);
@@ -1090,31 +1196,13 @@ HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
return OLEAUTPS_DllGetClassObject(rclsid, iid, ppv);
}
/***********************************************************************
* DllCanUnloadNow (OLEAUT32.@)
*
* Determine if this dll can be unloaded from the callers address space.
*
* PARAMS
* None.
*
* RETURNS
* Always returns S_FALSE. This dll cannot be unloaded.
*/
HRESULT WINAPI DllCanUnloadNow(void)
{
return S_FALSE;
}
/*****************************************************************************
* DllMain [OLEAUT32.@]
*/
BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
{
static const WCHAR oanocacheW[] = {'o','a','n','o','c','a','c','h','e',0};
if(fdwReason == DLL_PROCESS_ATTACH)
bstr_cache_enabled = !GetEnvironmentVariableW(oanocacheW, NULL, 0);
bstr_cache_enabled = !GetEnvironmentVariableW(L"oanocache", NULL, 0);
return OLEAUTPS_DllMain( hInstDll, fdwReason, lpvReserved );
}
@@ -1150,97 +1238,58 @@ HCURSOR WINAPI OleIconToCursor( HINSTANCE hinstExe, HICON hIcon)
*/
HRESULT WINAPI GetAltMonthNames(LCID lcid, LPOLESTR **str)
{
static const WCHAR ar_month1W[] = {0x645,0x62d,0x631,0x645,0};
static const WCHAR ar_month2W[] = {0x635,0x641,0x631,0};
static const WCHAR ar_month3W[] = {0x631,0x628,0x64a,0x639,' ',0x627,0x644,0x627,0x648,0x644,0};
static const WCHAR ar_month4W[] = {0x631,0x628,0x64a,0x639,' ',0x627,0x644,0x62b,0x627,0x646,0x64a,0};
static const WCHAR ar_month5W[] = {0x62c,0x645,0x627,0x62f,0x649,' ',0x627,0x644,0x627,0x648,0x644,0x649,0};
static const WCHAR ar_month6W[] = {0x62c,0x645,0x627,0x62f,0x649,' ',0x627,0x644,0x62b,0x627,0x646,0x64a,0x629,0};
static const WCHAR ar_month7W[] = {0x631,0x62c,0x628,0};
static const WCHAR ar_month8W[] = {0x634,0x639,0x628,0x627,0x646,0};
static const WCHAR ar_month9W[] = {0x631,0x645,0x636,0x627,0x646,0};
static const WCHAR ar_month10W[] = {0x634,0x648,0x627,0x643,0};
static const WCHAR ar_month11W[] = {0x630,0x648,' ',0x627,0x644,0x642,0x639,0x62f,0x629,0};
static const WCHAR ar_month12W[] = {0x630,0x648,' ',0x627,0x644,0x62d,0x62c,0x629,0};
static const WCHAR *arabic_hijri[] =
{
ar_month1W,
ar_month2W,
ar_month3W,
ar_month4W,
ar_month5W,
ar_month6W,
ar_month7W,
ar_month8W,
ar_month9W,
ar_month10W,
ar_month11W,
ar_month12W,
L"\x0645\x062d\x0631\x0645",
L"\x0635\x0641\x0631",
L"\x0631\x0628\x064a\x0639 \x0627\x0644\x0627\x0648\x0644",
L"\x0631\x0628\x064a\x0639 \x0627\x0644\x062b\x0627\x0646\x064a",
L"\x062c\x0645\x0627\x062f\x0649 \x0627\x0644\x0627\x0648\x0644\x0649",
L"\x062c\x0645\x0627\x062f\x0649 \x0627\x0644\x062b\x0627\x0646\x064a\x0629",
L"\x0631\x062c\x0628",
L"\x0634\x0639\x0628\x0627\x0646",
L"\x0631\x0645\x0636\x0627\x0646",
L"\x0634\x0648\x0627\x0643",
L"\x0630\x0648 \x0627\x0644\x0642\x0639\x062f\x0629",
L"\x0630\x0648 \x0627\x0644\x062d\x062c\x0629",
NULL
};
static const WCHAR pl_month1W[] = {'s','t','y','c','z','n','i','a',0};
static const WCHAR pl_month2W[] = {'l','u','t','e','g','o',0};
static const WCHAR pl_month3W[] = {'m','a','r','c','a',0};
static const WCHAR pl_month4W[] = {'k','w','i','e','t','n','i','a',0};
static const WCHAR pl_month5W[] = {'m','a','j','a',0};
static const WCHAR pl_month6W[] = {'c','z','e','r','w','c','a',0};
static const WCHAR pl_month7W[] = {'l','i','p','c','a',0};
static const WCHAR pl_month8W[] = {'s','i','e','r','p','n','i','a',0};
static const WCHAR pl_month9W[] = {'w','r','z','e',0x15b,'n','i','a',0};
static const WCHAR pl_month10W[] = {'p','a',0x17a,'d','z','i','e','r','n','i','k','a',0};
static const WCHAR pl_month11W[] = {'l','i','s','t','o','p','a','d','a',0};
static const WCHAR pl_month12W[] = {'g','r','u','d','n','i','a',0};
static const WCHAR *polish_genitive_names[] =
{
pl_month1W,
pl_month2W,
pl_month3W,
pl_month4W,
pl_month5W,
pl_month6W,
pl_month7W,
pl_month8W,
pl_month9W,
pl_month10W,
pl_month11W,
pl_month12W,
L"stycznia",
L"lutego",
L"marca",
L"kwietnia",
L"maja",
L"czerwca",
L"lipca",
L"sierpnia",
L"wrze\x015bnia",
L"pa\x017a" "dziernika",
L"listopada",
L"grudnia",
NULL
};
static const WCHAR ru_month1W[] = {0x44f,0x43d,0x432,0x430,0x440,0x44f,0};
static const WCHAR ru_month2W[] = {0x444,0x435,0x432,0x440,0x430,0x43b,0x44f,0};
static const WCHAR ru_month3W[] = {0x43c,0x430,0x440,0x442,0x430,0};
static const WCHAR ru_month4W[] = {0x430,0x43f,0x440,0x435,0x43b,0x44f,0};
static const WCHAR ru_month5W[] = {0x43c,0x430,0x44f,0};
static const WCHAR ru_month6W[] = {0x438,0x44e,0x43d,0x44f,0};
static const WCHAR ru_month7W[] = {0x438,0x44e,0x43b,0x44f,0};
static const WCHAR ru_month8W[] = {0x430,0x432,0x433,0x443,0x441,0x442,0x430,0};
static const WCHAR ru_month9W[] = {0x441,0x435,0x43d,0x442,0x44f,0x431,0x440,0x44f,0};
static const WCHAR ru_month10W[] = {0x43e,0x43a,0x442,0x44f,0x431,0x440,0x44f,0};
static const WCHAR ru_month11W[] = {0x43d,0x43e,0x44f,0x431,0x440,0x44f,0};
static const WCHAR ru_month12W[] = {0x434,0x435,0x43a,0x430,0x431,0x440,0x44f,0};
static const WCHAR *russian_genitive_names[] =
{
ru_month1W,
ru_month2W,
ru_month3W,
ru_month4W,
ru_month5W,
ru_month6W,
ru_month7W,
ru_month8W,
ru_month9W,
ru_month10W,
ru_month11W,
ru_month12W,
L"\x044f\x043d\x0432\x0430\x0440\x044f",
L"\x0444\x0435\x0432\x0440\x0430\x043b\x044f",
L"\x043c\x0430\x0440\x0442\x0430",
L"\x0430\x043f\x0440\x0435\x043b\x044f",
L"\x043c\x0430\x044f",
L"\x0438\x044e\x043d\x044f",
L"\x0438\x044e\x043b\x044f",
L"\x0430\x0432\x0433\x0443\x0441\x0442\x0430",
L"\x0441\x0435\x043d\x0442\x044f\x0431\x0440\x044f",
L"\x043e\x043a\x0442\x044f\x0431\x0440\x044f",
L"\x043d\x043e\x044f\x0431\x0440\x044f",
L"\x0434\x0435\x043a\x0430\x0431\x0440\x044f",
NULL
};
TRACE("%#x, %p\n", lcid, str);
TRACE("%#lx, %p.\n", lcid, str);
if (PRIMARYLANGID(LANGIDFROMLCID(lcid)) == LANG_ARABIC)
*str = (LPOLESTR *)arabic_hijri;
dll/win32/oleaut32/oleaut32.rc
+3 -8
View File
@@ -18,8 +18,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <windef.h>
#include "resource.h"
/* UTF-8 */
@@ -120,13 +118,10 @@
/* @makedep: oleaut32.rgs */
1 WINE_REGISTRY oleaut32.rgs
2 WINE_REGISTRY "oleaut32_oaidl.rgs"
3 WINE_REGISTRY "oleaut32_ocidl.rgs"
#define WINE_FILEDESCRIPTION_STR "Wine OLE dll"
#define WINE_FILENAME_STR "oleaut32.dll"
#define WINE_FILEVERSION 6, 0, 6001, 18000 /* version from Vista SP1 */
#define WINE_FILEVERSION_STR "6.0.6001.18000"
#define WINE_FILEVERSION 10, 0, 19043, 1466 /* version from Win10 2009 */
#define WINE_FILEVERSION_STR "10.0.19043.1466"
#define WINE_EXTRAVALUES VALUE "OLESelfRegister",""
#include <wine/wine_common_ver.rc>
#include "wine/wine_common_ver.rc"
dll/win32/oleaut32/oleaut32.spec
+29 -8
View File
@@ -140,14 +140,12 @@
141 stdcall VarAdd(ptr ptr ptr)
142 stdcall VarAnd(ptr ptr ptr)
143 stdcall VarDiv(ptr ptr ptr)
@ stdcall -private DllCanUnloadNow()
@ stdcall -private DllGetClassObject(ptr ptr ptr)
144 stub OACreateTypeLib2
146 stdcall DispCallFunc(ptr long long long long ptr ptr ptr)
147 stdcall VariantChangeTypeEx(ptr ptr long long long)
148 stdcall SafeArrayPtrOfIndex(ptr ptr ptr)
149 stdcall SysStringByteLen(ptr)
150 stdcall SysAllocStringByteLen(ptr long)
@ stdcall -private DllRegisterServer()
152 stdcall VarEqv(ptr ptr ptr)
153 stdcall VarIdiv(ptr ptr ptr)
154 stdcall VarImp(ptr ptr ptr)
@@ -196,9 +194,9 @@
197 stdcall VarDecFromStr(wstr long long ptr)
198 stdcall VarDecFromDisp(ptr long ptr)
199 stdcall VarDecFromBool(long ptr)
200 stdcall GetErrorInfo(long ptr) ole32.GetErrorInfo
201 stdcall SetErrorInfo(long ptr) ole32.SetErrorInfo
202 stdcall CreateErrorInfo(ptr) ole32.CreateErrorInfo
200 stdcall -import GetErrorInfo(long ptr)
201 stdcall -import SetErrorInfo(long ptr)
202 stdcall -import CreateErrorInfo(ptr)
203 stdcall VarDecRound(ptr long ptr)
204 stdcall VarDecCmp(ptr ptr)
205 stdcall VarI2FromI1(long ptr)
@@ -296,8 +294,6 @@
297 stub LPSAFEARRAY_Unmarshal
298 stdcall VarDecCmpR8(ptr double)
299 stdcall VarCyAdd(int64 int64 ptr)
@ stdcall -private DllUnregisterServer()
301 stub OACreateTypeLib2
303 stdcall VarCyMul(int64 int64 ptr)
304 stdcall VarCyMulI4(int64 long ptr)
305 stdcall VarCySub(int64 int64 ptr)
@@ -361,6 +357,26 @@
377 stdcall VarI1FromUI8(int64 ptr)
378 stdcall VarUI2FromI8(int64 ptr)
379 stdcall VarUI2FromUI8(int64 ptr)
380 stub UserHWND_from_local
381 stub UserHWND_to_local
382 stub UserHWND_free_inst
383 stub UserHWND_free_local
384 stub UserBSTR_from_local
385 stub UserBSTR_to_local
386 stub UserBSTR_free_inst
387 stub UserBSTR_free_local
388 stub UserVARIANT_from_local
389 stub UserVARIANT_to_local
390 stub UserVARIANT_free_inst
391 stub UserVARIANT_free_local
392 stub UserEXCEPINFO_from_local
393 stub UserEXCEPINFO_to_local
394 stub UserEXCEPINFO_free_inst
395 stub UserEXCEPINFO_free_local
396 stub UserMSG_from_local
397 stub UserMSG_to_local
398 stub UserMSG_free_inst
399 stub UserMSG_free_local
401 stdcall OleLoadPictureEx(ptr long long ptr long long long ptr)
402 stub OleLoadPictureFileEx
411 stdcall SafeArrayCreateVector(long long long)
@@ -396,3 +412,8 @@
441 stdcall VarUI8FromDec(long ptr)
442 stdcall RegisterTypeLibForUser(ptr wstr wstr)
443 stdcall UnRegisterTypeLibForUser(ptr long long long long)
@ stdcall -private DllCanUnloadNow()
@ stdcall -private DllGetClassObject(ptr ptr ptr)
@ stdcall -private DllRegisterServer()
@ stdcall -private DllUnregisterServer()
dll/win32/oleaut32/oleaut32_oaidl.idl
+1 -1
View File
@@ -31,4 +31,4 @@ cpp_quote("#endif /* oleaut32_oaidl.idl hack */")
threading(both),
uuid(b196b286-bab4-101a-b69c-00aa00341d07)
]
coclass PSFactoryBuffer { interface IFactoryBuffer; }
coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
dll/win32/oleaut32/oleaut32_oaidl.rgs
-78
View File
@@ -1,78 +0,0 @@
HKCR
{
NoRemove Interface
{
'{00020400-0000-0000-C000-000000000046}' = s 'IDispatch'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{00020404-0000-0000-C000-000000000046}' = s 'IEnumVARIANT'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{00020403-0000-0000-C000-000000000046}' = s 'ITypeComp'
{
NumMethods = s 5
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{00020401-0000-0000-C000-000000000046}' = s 'ITypeInfo'
{
NumMethods = s 22
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{00020412-0000-0000-C000-000000000046}' = s 'ITypeInfo2'
{
NumMethods = s 37
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{00020402-0000-0000-C000-000000000046}' = s 'ITypeLib'
{
NumMethods = s 13
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{00020411-0000-0000-C000-000000000046}' = s 'ITypeLib2'
{
NumMethods = s 17
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{1CF2B120-547D-101B-8E65-08002B2BD119}' = s 'IErrorInfo'
{
NumMethods = s 8
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{22F03340-547D-101B-8E65-08002B2BD119}' = s 'ICreateErrorInfo'
{
NumMethods = s 8
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{DF0B3D60-548F-101B-8E65-08002B2BD119}' = s 'ISupportErrorInfo'
{
NumMethods = s 4
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{0000002E-0000-0000-C000-000000000046}' = s 'ITypeFactory'
{
NumMethods = s 4
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{3127CA40-446E-11CE-8135-00AA004BB851}' = s 'IErrorLog'
{
NumMethods = s 4
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{55272A00-42CB-11CE-8135-00AA004BB851}' = s 'IPropertyBag'
{
NumMethods = s 5
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
}
NoRemove CLSID
{
'{B196B286-BAB4-101A-B69C-00AA00341D07}' = s 'PSFactoryBuffer'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
}
}
}
dll/win32/oleaut32/oleaut32_ocidl.idl
+1 -1
View File
@@ -25,7 +25,7 @@
threading(both),
uuid(b196b286-bab4-101a-b69c-00aa00341d07)
]
coclass PSFactoryBuffer { interface IFactoryBuffer; }
coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
[
helpstring("Standard Font"),
dll/win32/oleaut32/oleaut32_ocidl.rgs
-252
View File
@@ -1,252 +0,0 @@
HKCR
{
NoRemove Interface
{
'{BEF6E002-A874-101A-8BBA-00AA00300CAB}' = s 'IFont'
{
NumMethods = s 27
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{BEF6E003-A874-101A-8BBA-00AA00300CAB}' = s 'IFontDisp'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{4EF6100A-AF88-11D0-9846-00C04FC29993}' = s 'IFontEventsDisp'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{7BF80980-BF32-101A-8BBB-00AA00300CAB}' = s 'IPicture'
{
NumMethods = s 17
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{7BF80981-BF32-101A-8BBB-00AA00300CAB}' = s 'IPictureDisp'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{B196B288-BAB4-101A-B69C-00AA00341D07}' = s 'IOleControl'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{B196B289-BAB4-101A-B69C-00AA00341D07}' = s 'IOleControlSite'
{
NumMethods = s 10
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{9C2CAD80-3424-11CF-B670-00AA004CD6D8}' = s 'IOleInPlaceSiteEx'
{
NumMethods = s 18
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{B196B28F-BAB4-101A-B69C-00AA00341D07}' = s 'IClassFactory2'
{
NumMethods = s 8
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{B196B283-BAB4-101A-B69C-00AA00341D07}' = s 'IProvideClassInfo'
{
NumMethods = s 4
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{A6BC3AC0-DBAA-11CE-9DE3-00AA004BB851}' = s 'IProvideClassInfo2'
{
NumMethods = s 5
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{A7ABA9C1-8983-11CF-8F20-00805F2CD064}' = s 'IProvideMultipleClassInfo'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{B196B286-BAB4-101A-B69C-00AA00341D07}' = s 'IConnectionPoint'
{
NumMethods = s 8
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{B196B284-BAB4-101A-B69C-00AA00341D07}' = s 'IConnectionPointContainer'
{
NumMethods = s 5
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{B196B287-BAB4-101A-B69C-00AA00341D07}' = s 'IEnumConnections'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{B196B285-BAB4-101A-B69C-00AA00341D07}' = s 'IEnumConnectionPoints'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{B196B28D-BAB4-101A-B69C-00AA00341D07}' = s 'IPropertyPage'
{
NumMethods = s 14
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{01E44665-24AC-101B-84ED-08002B2EC713}' = s 'IPropertyPage2'
{
NumMethods = s 15
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{B196B28C-BAB4-101A-B69C-00AA00341D07}' = s 'IPropertyPageSite'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{9BFBBC02-EFF1-101A-84ED-00AA00341D07}' = s 'IPropertyNotifySink'
{
NumMethods = s 5
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{742B0E01-14E6-101B-914E-00AA00300CAB}' = s 'ISimpleFrameSite'
{
NumMethods = s 5
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{7FD52380-4E07-101B-AE2D-08002B2EC713}' = s 'IPersistStreamInit'
{
NumMethods = s 9
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{BD1AE5E0-A6AE-11CE-BD37-504200C10000}' = s 'IPersistMemory'
{
NumMethods = s 9
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{37D84F60-42CB-11CE-8135-00AA004BB851}' = s 'IPersistPropertyBag'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{22F55882-280B-11D0-A8A9-00A0C90C2004}' = s 'IPropertyBag2'
{
NumMethods = s 8
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{22F55881-280B-11D0-A8A9-00A0C90C2004}' = s 'IPersistPropertyBag2'
{
NumMethods = s 8
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{B196B28B-BAB4-101A-B69C-00AA00341D07}' = s 'ISpecifyPropertyPages'
{
NumMethods = s 4
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{376BD3AA-3845-101B-84ED-08002B2EC713}' = s 'IPerPropertyBrowsing'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{3AF24290-0C96-11CE-A0CF-00AA00600AB8}' = s 'IAdviseSinkEx'
{
NumMethods = s 9
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{55980BA0-35AA-11CF-B671-00AA004CD6D8}' = s 'IPointerInactive'
{
NumMethods = s 6
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{FC4801A3-2BA9-11CF-A229-00AA003D7352}' = s 'IObjectWithSite'
{
NumMethods = s 5
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{894AD3B0-EF97-11CE-9BC9-00AA00608E01}' = s 'IOleUndoUnit'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{A1FAF330-EF97-11CE-9BC9-00AA00608E01}' = s 'IOleParentUndoUnit'
{
NumMethods = s 12
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{B3E7C340-EF97-11CE-9BC9-00AA00608E01}' = s 'IEnumOleUndoUnits'
{
NumMethods = s 7
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{D001F200-EF97-11CE-9BC9-00AA00608E01}' = s 'IOleUndoManager'
{
NumMethods = s 15
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
'{CF51ED10-62FE-11CF-BF86-00A0C9034836}' = s 'IQuickActivate'
{
NumMethods = s 6
ProxyStubClsid32 = s '{B196B286-BAB4-101A-B69C-00AA00341D07}'
}
}
NoRemove CLSID
{
'{B196B286-BAB4-101A-B69C-00AA00341D07}' = s 'PSFactoryBuffer'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
}
'{0BE35203-8F91-11CE-9DE3-00AA004BB851}' = s 'Standard Font'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
ProgId = s 'StdFont'
}
'{46763EE0-CAB2-11CE-8C20-00AA0051E5D4}' = s 'Obsolete Font'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
ProgId = s 'OldFont'
}
'{0BE35204-8F91-11CE-9DE3-00AA004BB851}' = s 'Standard Picture'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Apartment' }
ProgId = s 'StdPicture'
}
'{00020420-0000-0000-C000-000000000046}' = s 'PSDispatch'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
}
'{00020421-0000-0000-C000-000000000046}' = s 'PSEnumVariant'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
}
'{00020422-0000-0000-C000-000000000046}' = s 'PSTypeInfo'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
}
'{00020423-0000-0000-C000-000000000046}' = s 'PSTypeLib'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
}
'{00020424-0000-0000-C000-000000000046}' = s 'PSOAInterface'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
}
'{00020425-0000-0000-C000-000000000046}' = s 'PSTypeComp'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
}
'{DF0B3D60-548F-101B-8E65-08002B2BD119}' = s 'PSSupportErrorInfo'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
}
'{0000002F-0000-0000-C000-000000000046}' = s 'CLSID_RecordInfo'
{
InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
}
}
'StdFont' = s 'Standard Font'
{
CLSID = s '{0BE35203-8F91-11CE-9DE3-00AA004BB851}'
}
'OldFont' = s 'Obsolete Font'
{
CLSID = s '{46763EE0-CAB2-11CE-8C20-00AA0051E5D4}'
}
'StdPicture' = s 'Standard Picture'
{
CLSID = s '{0BE35204-8F91-11CE-9DE3-00AA004BB851}'
}
}
dll/win32/oleaut32/olefont.c
+71 -218
View File
@@ -26,9 +26,6 @@
#include <string.h>
#define COBJMACROS
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
#include "winerror.h"
#include "windef.h"
#include "winbase.h"
@@ -117,7 +114,7 @@ static void HFONTItem_Delete(PHFONTItem item)
{
DeleteObject(item->gdiFont);
list_remove(&item->entry);
HeapFree(GetProcessHeap(), 0, item);
free(item);
}
/* Find hfont item entry in the list. Should be called while holding the crit sect */
@@ -136,7 +133,7 @@ static HFONTItem *find_hfontitem(HFONT hfont)
/* Add an item to the list with one internal reference */
static HRESULT add_hfontitem(HFONT hfont)
{
HFONTItem *new_item = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_item));
HFONTItem *new_item = malloc(sizeof(*new_item));
if(!new_item) return E_OUTOFMEMORY;
@@ -226,17 +223,6 @@ static HRESULT dec_ext_ref(HFONT hfont)
return hr;
}
static WCHAR *strdupW(const WCHAR* str)
{
WCHAR *ret;
DWORD size = (lstrlenW(str) + 1) * sizeof(WCHAR);
ret = HeapAlloc(GetProcessHeap(), 0, size);
if(ret)
memcpy(ret, str, size);
return ret;
}
/***********************************************************************
* Declaration of the implementation class for the IFont interface
*/
@@ -255,7 +241,6 @@ struct OLEFontImpl
IPersistStream IPersistStream_iface;
IConnectionPointContainer IConnectionPointContainer_iface;
IPersistPropertyBag IPersistPropertyBag_iface;
IPersistStreamInit IPersistStreamInit_iface;
/*
* Reference count for that instance of the class.
*/
@@ -311,11 +296,6 @@ static inline OLEFontImpl *impl_from_IPersistPropertyBag( IPersistPropertyBag *i
return CONTAINING_RECORD(iface, OLEFontImpl, IPersistPropertyBag_iface);
}
static inline OLEFontImpl *impl_from_IPersistStreamInit( IPersistStreamInit *iface )
{
return CONTAINING_RECORD(iface, OLEFontImpl, IPersistStreamInit_iface);
}
/***********************************************************************
* Prototypes for the implementation functions for the IFont
@@ -344,12 +324,12 @@ HRESULT WINAPI OleCreateFontIndirect(
*ppvObj = 0;
if (!lpFontDesc) {
static WCHAR fname[] = { 'S','y','s','t','e','m',0 };
static WCHAR fname[] = L"System";
fd.cbSizeofstruct = sizeof(fd);
fd.lpstrName = fname;
fd.cySize.s.Lo = 80000;
fd.cySize.s.Hi = 0;
fd.cySize.Lo = 80000;
fd.cySize.Hi = 0;
fd.sWeight = 0;
fd.sCharset = 0;
fd.fItalic = FALSE;
@@ -357,6 +337,8 @@ HRESULT WINAPI OleCreateFontIndirect(
fd.fStrikethrough = FALSE;
lpFontDesc = &fd;
}
else if (!lpFontDesc->lpstrName)
return CTL_E_INVALIDPROPERTYVALUE;
newFont = OLEFontImpl_Construct(lpFontDesc);
if (!newFont) return E_OUTOFMEMORY;
@@ -380,25 +362,17 @@ HRESULT WINAPI OleCreateFontIndirect(
*/
static void OLEFont_SendNotify(OLEFontImpl* this, DISPID dispID)
{
static const WCHAR wszName[] = {'N','a','m','e',0};
static const WCHAR wszSize[] = {'S','i','z','e',0};
static const WCHAR wszBold[] = {'B','o','l','d',0};
static const WCHAR wszItalic[] = {'I','t','a','l','i','c',0};
static const WCHAR wszUnder[] = {'U','n','d','e','r','l','i','n','e',0};
static const WCHAR wszStrike[] = {'S','t','r','i','k','e','t','h','r','o','u','g','h',0};
static const WCHAR wszWeight[] = {'W','e','i','g','h','t',0};
static const WCHAR wszCharset[] = {'C','h','a','r','s','e','t',0};
static const LPCWSTR dispid_mapping[] =
{
wszName,
NULL,
wszSize,
wszBold,
wszItalic,
wszUnder,
wszStrike,
wszWeight,
wszCharset
L"Name",
NULL,
L"Size",
L"Bold",
L"Italic",
L"Underline",
L"Strikethrough",
L"Weight",
L"Charset"
};
IEnumConnections *pEnum;
@@ -491,10 +465,6 @@ static HRESULT WINAPI OLEFontImpl_QueryInterface(
{
*ppvObject = &this->IPersistPropertyBag_iface;
}
else if (IsEqualGUID(&IID_IPersistStreamInit, riid))
{
*ppvObject = &this->IPersistStreamInit_iface;
}
if (!*ppvObject)
{
@@ -507,28 +477,20 @@ static HRESULT WINAPI OLEFontImpl_QueryInterface(
return S_OK;
}
/************************************************************************
* OLEFontImpl_AddRef (IUnknown)
*/
static ULONG WINAPI OLEFontImpl_AddRef(
IFont* iface)
static ULONG WINAPI OLEFontImpl_AddRef(IFont* iface)
{
OLEFontImpl *this = impl_from_IFont(iface);
TRACE("(%p)->(ref=%d)\n", this, this->ref);
return InterlockedIncrement(&this->ref);
ULONG ref = InterlockedIncrement(&this->ref);
TRACE("%p, refcount %lu.\n", iface, ref);
return ref;
}
/************************************************************************
* OLEFontImpl_Release (IUnknown)
*/
static ULONG WINAPI OLEFontImpl_Release(IFont* iface)
{
OLEFontImpl *this = impl_from_IFont(iface);
ULONG ref;
ULONG ref = InterlockedDecrement(&this->ref);
TRACE("(%p)->(ref=%d)\n", this, this->ref);
ref = InterlockedDecrement(&this->ref);
TRACE("%p, refcount %lu.\n", iface, ref);
if (ref == 0)
{
@@ -623,7 +585,7 @@ static void realize_font(OLEFontImpl *This)
* Ratio is applied here relative to the standard.
*/
fontHeight = MulDiv( This->description.cySize.s.Lo, This->cyLogical*635, This->cyHimetric*18 );
fontHeight = MulDiv( This->description.cySize.Lo, This->cyLogical*635, This->cyHimetric*18 );
logFont.lfHeight = ((fontHeight%10000L)>5000L) ? (-fontHeight/10000L) - 1 :
(-fontHeight/10000L);
@@ -647,8 +609,8 @@ static void realize_font(OLEFontImpl *This)
GetTextFaceW(hdc, ARRAY_SIZE(text_face), text_face);
if(lstrcmpiW(text_face, This->description.lpstrName))
{
HeapFree(GetProcessHeap(), 0, This->description.lpstrName);
This->description.lpstrName = strdupW(text_face);
free(This->description.lpstrName);
This->description.lpstrName = wcsdup(text_face);
}
GetTextMetricsW(hdc, &tm);
This->description.sCharset = tm.tmCharSet;
@@ -674,10 +636,7 @@ static HRESULT WINAPI OLEFontImpl_get_Name(
realize_font(this);
if (this->description.lpstrName!=0)
*pname = SysAllocString(this->description.lpstrName);
else
*pname = 0;
*pname = SysAllocString(this->description.lpstrName);
return S_OK;
}
@@ -695,8 +654,8 @@ static HRESULT WINAPI OLEFontImpl_put_Name(
if (!name)
return CTL_E_INVALIDPROPERTYVALUE;
HeapFree(GetProcessHeap(), 0, This->description.lpstrName);
This->description.lpstrName = strdupW(name);
free(This->description.lpstrName);
This->description.lpstrName = wcsdup(name);
if (!This->description.lpstrName) return E_OUTOFMEMORY;
TRACE("new name %s\n", debugstr_w(This->description.lpstrName));
@@ -722,38 +681,24 @@ static HRESULT WINAPI OLEFontImpl_get_Size(
* Convert realized font height in pixels to points descaled by current
* scaling ratio then scaled up by 10000.
*/
psize->s.Lo = MulDiv(this->nRealHeight,
this->cyHimetric * 72 * 10000,
this->cyLogical * 2540);
psize->s.Hi = 0;
psize->Lo = MulDiv(this->nRealHeight, this->cyHimetric * 72 * 10000, this->cyLogical * 2540);
psize->Hi = 0;
return S_OK;
}
/************************************************************************
* OLEFontImpl_put_Size (IFont)
*/
static HRESULT WINAPI OLEFontImpl_put_Size(
IFont* iface,
CY size)
static HRESULT WINAPI OLEFontImpl_put_Size(IFont *iface, CY size)
{
OLEFontImpl *this = impl_from_IFont(iface);
TRACE("(%p)->(%d)\n", this, size.s.Lo);
this->description.cySize.s.Hi = 0;
this->description.cySize.s.Lo = size.s.Lo;
TRACE("%p, %ld.\n", iface, size.Lo);
this->description.cySize.Hi = 0;
this->description.cySize.Lo = size.Lo;
OLEFont_SendNotify(this, DISPID_FONT_SIZE);
return S_OK;
}
/************************************************************************
* OLEFontImpl_get_Bold (IFont)
*
* See Windows documentation for more details on IFont methods.
*/
static HRESULT WINAPI OLEFontImpl_get_Bold(
IFont* iface,
BOOL* pbold)
static HRESULT WINAPI OLEFontImpl_get_Bold(IFont *iface, BOOL *pbold)
{
OLEFontImpl *this = impl_from_IFont(iface);
TRACE("(%p)->(%p)\n", this, pbold);
@@ -998,13 +943,13 @@ static HRESULT WINAPI OLEFontImpl_Clone(
*ppfont = NULL;
newObject = HeapAlloc(GetProcessHeap(), 0, sizeof(OLEFontImpl));
newObject = malloc(sizeof(OLEFontImpl));
if (newObject==NULL)
return E_OUTOFMEMORY;
*newObject = *this;
/* allocate separate buffer */
newObject->description.lpstrName = strdupW(this->description.lpstrName);
newObject->description.lpstrName = wcsdup(this->description.lpstrName);
/* Increment internal ref in hfont item list */
if(newObject->gdiFont) inc_int_ref(newObject->gdiFont);
@@ -1046,9 +991,9 @@ static HRESULT WINAPI OLEFontImpl_IsEqual(
if(pFontOther == NULL)
return E_POINTER;
else if (left->description.cySize.s.Lo != right->description.cySize.s.Lo)
else if (left->description.cySize.Lo != right->description.cySize.Lo)
return S_FALSE;
else if (left->description.cySize.s.Hi != right->description.cySize.s.Hi)
else if (left->description.cySize.Hi != right->description.cySize.Hi)
return S_FALSE;
else if (left->description.sWeight != right->description.sWeight)
return S_FALSE;
@@ -1081,7 +1026,8 @@ static HRESULT WINAPI OLEFontImpl_SetRatio(
LONG cyHimetric)
{
OLEFontImpl *this = impl_from_IFont(iface);
TRACE("(%p)->(%d, %d)\n", this, cyLogical, cyHimetric);
TRACE("%p, %ld, %ld.\n", iface, cyLogical, cyHimetric);
if(cyLogical == 0 || cyHimetric == 0)
return E_FAIL;
@@ -1247,7 +1193,6 @@ static HRESULT WINAPI OLEFontImpl_GetTypeInfo(
LCID lcid,
ITypeInfo** ppTInfo)
{
static const WCHAR stdole2tlb[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
ITypeLib *tl;
HRESULT hres;
@@ -1255,16 +1200,16 @@ static HRESULT WINAPI OLEFontImpl_GetTypeInfo(
TRACE("(%p, iTInfo=%d, lcid=%04x, %p)\n", this, iTInfo, (int)lcid, ppTInfo);
if (iTInfo != 0)
return E_FAIL;
hres = LoadTypeLib(stdole2tlb, &tl);
hres = LoadTypeLib(L"stdole2.tlb", &tl);
if (FAILED(hres)) {
ERR("Could not load the stdole2.tlb?\n");
return hres;
}
hres = ITypeLib_GetTypeInfoOfGuid(tl, &IID_IFontDisp, ppTInfo);
ITypeLib_Release(tl);
if (FAILED(hres)) {
FIXME("Did not IDispatch typeinfo from typelib, hres %x\n",hres);
}
if (FAILED(hres))
FIXME("Did not IDispatch typeinfo from typelib, hres %#lx.\n", hres);
return hres;
}
@@ -1321,7 +1266,7 @@ static HRESULT WINAPI OLEFontImpl_Invoke(
OLEFontImpl *this = impl_from_IDispatch(iface);
HRESULT hr;
TRACE("%p->(%d,%s,0x%x,0x%x,%p,%p,%p,%p)\n", this, dispIdMember,
TRACE("%p, %ld, %s, %#lx, %#x, %p, %p, %p, %p.\n", iface, dispIdMember,
debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExepInfo,
puArgErr);
@@ -1518,7 +1463,7 @@ static HRESULT WINAPI OLEFontImpl_Invoke(
}
break;
default:
ERR("member not found for dispid 0x%x\n", dispIdMember);
ERR("member not found for dispid %#lx.\n", dispIdMember);
return DISP_E_MEMBERNOTFOUND;
}
}
@@ -1649,10 +1594,10 @@ static HRESULT WINAPI OLEFontImpl_Load(
if (cbRead != sizeof(WORD)) return E_FAIL;
/* Size */
IStream_Read(pLoadStream, &this->description.cySize.s.Lo, sizeof(DWORD), &cbRead);
IStream_Read(pLoadStream, &this->description.cySize.Lo, sizeof(DWORD), &cbRead);
if (cbRead != sizeof(DWORD)) return E_FAIL;
this->description.cySize.s.Hi = 0;
this->description.cySize.Hi = 0;
/* Name */
IStream_Read(pLoadStream, &string_size, sizeof(BYTE), &cbRead);
@@ -1661,10 +1606,10 @@ static HRESULT WINAPI OLEFontImpl_Load(
IStream_Read(pLoadStream, readBuffer, string_size, &cbRead);
if (cbRead != string_size) return E_FAIL;
HeapFree(GetProcessHeap(), 0, this->description.lpstrName);
free(this->description.lpstrName);
len = MultiByteToWideChar( CP_ACP, 0, readBuffer, string_size, NULL, 0 );
this->description.lpstrName = HeapAlloc( GetProcessHeap(), 0, (len+1) * sizeof(WCHAR) );
this->description.lpstrName = malloc((len + 1) * sizeof(WCHAR));
MultiByteToWideChar( CP_ACP, 0, readBuffer, string_size, this->description.lpstrName, len );
this->description.lpstrName[len] = 0;
@@ -1720,28 +1665,25 @@ static HRESULT WINAPI OLEFontImpl_Save(
if (written != sizeof(WORD)) return E_FAIL;
/* Size */
IStream_Write(pOutStream, &this->description.cySize.s.Lo, sizeof(DWORD), &written);
IStream_Write(pOutStream, &this->description.cySize.Lo, sizeof(DWORD), &written);
if (written != sizeof(DWORD)) return E_FAIL;
/* FontName */
if (this->description.lpstrName)
string_size = WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
lstrlenW(this->description.lpstrName), NULL, 0, NULL, NULL );
else
string_size = 0;
string_size = WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
lstrlenW(this->description.lpstrName), NULL, 0, NULL, NULL );
IStream_Write(pOutStream, &string_size, sizeof(BYTE), &written);
if (written != sizeof(BYTE)) return E_FAIL;
if (string_size)
{
if (!(writeBuffer = HeapAlloc( GetProcessHeap(), 0, string_size ))) return E_OUTOFMEMORY;
if (!(writeBuffer = malloc(string_size))) return E_OUTOFMEMORY;
WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
lstrlenW(this->description.lpstrName),
writeBuffer, string_size, NULL, NULL );
IStream_Write(pOutStream, writeBuffer, string_size, &written);
HeapFree(GetProcessHeap(), 0, writeBuffer);
free(writeBuffer);
if (written != string_size) return E_FAIL;
}
@@ -1771,10 +1713,9 @@ static HRESULT WINAPI OLEFontImpl_GetSizeMax(
pcbSize->u.LowPart += sizeof(DWORD); /* Size */
pcbSize->u.LowPart += sizeof(BYTE); /* StrLength */
if (this->description.lpstrName!=0)
pcbSize->u.LowPart += WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
lstrlenW(this->description.lpstrName),
NULL, 0, NULL, NULL );
pcbSize->u.LowPart += WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
lstrlenW(this->description.lpstrName),
NULL, 0, NULL, NULL );
return S_OK;
}
@@ -1922,20 +1863,13 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
Italic = 0 'False
Strikethrough = 0 'False
*/
static const WCHAR sAttrName[] = {'N','a','m','e',0};
static const WCHAR sAttrSize[] = {'S','i','z','e',0};
static const WCHAR sAttrCharset[] = {'C','h','a','r','s','e','t',0};
static const WCHAR sAttrWeight[] = {'W','e','i','g','h','t',0};
static const WCHAR sAttrUnderline[] = {'U','n','d','e','r','l','i','n','e',0};
static const WCHAR sAttrItalic[] = {'I','t','a','l','i','c',0};
static const WCHAR sAttrStrikethrough[] = {'S','t','r','i','k','e','t','h','r','o','u','g','h',0};
OLEFontImpl *this = impl_from_IPersistPropertyBag(iface);
VARIANT value;
HRESULT iRes;
VariantInit(&value);
iRes = IPropertyBag_Read(pPropBag, sAttrName, &value, pErrorLog);
iRes = IPropertyBag_Read(pPropBag, L"Name", &value, pErrorLog);
if (iRes == S_OK)
{
iRes = VariantChangeType(&value, &value, 0, VT_BSTR);
@@ -1948,7 +1882,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
VariantClear(&value);
if (iRes == S_OK) {
iRes = IPropertyBag_Read(pPropBag, sAttrSize, &value, pErrorLog);
iRes = IPropertyBag_Read(pPropBag, L"Size", &value, pErrorLog);
if (iRes == S_OK)
{
iRes = VariantChangeType(&value, &value, 0, VT_CY);
@@ -1962,7 +1896,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
}
if (iRes == S_OK) {
iRes = IPropertyBag_Read(pPropBag, sAttrCharset, &value, pErrorLog);
iRes = IPropertyBag_Read(pPropBag, L"Charset", &value, pErrorLog);
if (iRes == S_OK)
{
iRes = VariantChangeType(&value, &value, 0, VT_I2);
@@ -1976,7 +1910,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
}
if (iRes == S_OK) {
iRes = IPropertyBag_Read(pPropBag, sAttrWeight, &value, pErrorLog);
iRes = IPropertyBag_Read(pPropBag, L"Weight", &value, pErrorLog);
if (iRes == S_OK)
{
iRes = VariantChangeType(&value, &value, 0, VT_I2);
@@ -1990,7 +1924,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
}
if (iRes == S_OK) {
iRes = IPropertyBag_Read(pPropBag, sAttrUnderline, &value, pErrorLog);
iRes = IPropertyBag_Read(pPropBag, L"Underline", &value, pErrorLog);
if (iRes == S_OK)
{
iRes = VariantChangeType(&value, &value, 0, VT_BOOL);
@@ -2004,7 +1938,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
}
if (iRes == S_OK) {
iRes = IPropertyBag_Read(pPropBag, sAttrItalic, &value, pErrorLog);
iRes = IPropertyBag_Read(pPropBag, L"Italic", &value, pErrorLog);
if (iRes == S_OK)
{
iRes = VariantChangeType(&value, &value, 0, VT_BOOL);
@@ -2018,7 +1952,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
}
if (iRes == S_OK) {
iRes = IPropertyBag_Read(pPropBag, sAttrStrikethrough, &value, pErrorLog);
iRes = IPropertyBag_Read(pPropBag, L"Strikethrough", &value, pErrorLog);
if (iRes == S_OK)
{
iRes = VariantChangeType(&value, &value, 0, VT_BOOL);
@@ -2032,7 +1966,7 @@ static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
}
if (FAILED(iRes))
WARN("-- 0x%08x\n", iRes);
WARN("-- %#lx.\n", iRes);
return iRes;
}
@@ -2056,86 +1990,6 @@ static const IPersistPropertyBagVtbl OLEFontImpl_IPersistPropertyBag_VTable =
OLEFontImpl_IPersistPropertyBag_Save
};
/************************************************************************
* OLEFontImpl implementation of IPersistStreamInit.
*/
static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_QueryInterface(
IPersistStreamInit *iface, REFIID riid, LPVOID *ppvObj
) {
OLEFontImpl *this = impl_from_IPersistStreamInit(iface);
return IFont_QueryInterface(&this->IFont_iface,riid,ppvObj);
}
static ULONG WINAPI OLEFontImpl_IPersistStreamInit_AddRef(
IPersistStreamInit *iface
) {
OLEFontImpl *this = impl_from_IPersistStreamInit(iface);
return IFont_AddRef(&this->IFont_iface);
}
static ULONG WINAPI OLEFontImpl_IPersistStreamInit_Release(
IPersistStreamInit *iface
) {
OLEFontImpl *this = impl_from_IPersistStreamInit(iface);
return IFont_Release(&this->IFont_iface);
}
static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_GetClassID(
IPersistStreamInit *iface, CLSID *classid
) {
FIXME("(%p,%p), stub!\n", iface, classid);
return E_FAIL;
}
static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_IsDirty(
IPersistStreamInit *iface
) {
FIXME("(%p), stub!\n", iface);
return E_FAIL;
}
static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_Load(
IPersistStreamInit *iface, LPSTREAM pStm
) {
FIXME("(%p,%p), stub!\n", iface, pStm);
return E_FAIL;
}
static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_Save(
IPersistStreamInit *iface, LPSTREAM pStm, BOOL fClearDirty
) {
FIXME("(%p,%p,%d), stub!\n", iface, pStm, fClearDirty);
return E_FAIL;
}
static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_GetSizeMax(
IPersistStreamInit *iface, ULARGE_INTEGER *pcbSize
) {
FIXME("(%p,%p), stub!\n", iface, pcbSize);
return E_FAIL;
}
static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_InitNew(
IPersistStreamInit *iface
) {
FIXME("(%p), stub!\n", iface);
return S_OK;
}
static const IPersistStreamInitVtbl OLEFontImpl_IPersistStreamInit_VTable =
{
OLEFontImpl_IPersistStreamInit_QueryInterface,
OLEFontImpl_IPersistStreamInit_AddRef,
OLEFontImpl_IPersistStreamInit_Release,
OLEFontImpl_IPersistStreamInit_GetClassID,
OLEFontImpl_IPersistStreamInit_IsDirty,
OLEFontImpl_IPersistStreamInit_Load,
OLEFontImpl_IPersistStreamInit_Save,
OLEFontImpl_IPersistStreamInit_GetSizeMax,
OLEFontImpl_IPersistStreamInit_InitNew
};
/************************************************************************
* OLEFontImpl_Construct
*
@@ -2149,7 +2003,7 @@ static OLEFontImpl* OLEFontImpl_Construct(const FONTDESC *fontDesc)
{
OLEFontImpl* newObject;
newObject = HeapAlloc(GetProcessHeap(), 0, sizeof(OLEFontImpl));
newObject = malloc(sizeof(OLEFontImpl));
if (newObject==0)
return newObject;
@@ -2159,12 +2013,11 @@ static OLEFontImpl* OLEFontImpl_Construct(const FONTDESC *fontDesc)
newObject->IPersistStream_iface.lpVtbl = &OLEFontImpl_IPersistStream_VTable;
newObject->IConnectionPointContainer_iface.lpVtbl = &OLEFontImpl_IConnectionPointContainer_VTable;
newObject->IPersistPropertyBag_iface.lpVtbl = &OLEFontImpl_IPersistPropertyBag_VTable;
newObject->IPersistStreamInit_iface.lpVtbl = &OLEFontImpl_IPersistStreamInit_VTable;
newObject->ref = 1;
newObject->description.cbSizeofstruct = sizeof(FONTDESC);
newObject->description.lpstrName = strdupW(fontDesc->lpstrName);
newObject->description.lpstrName = wcsdup(fontDesc->lpstrName);
newObject->description.cySize = fontDesc->cySize;
newObject->description.sWeight = fontDesc->sWeight;
newObject->description.sCharset = fontDesc->sCharset;
@@ -2205,14 +2058,14 @@ static void OLEFontImpl_Destroy(OLEFontImpl* fontDesc)
{
TRACE("(%p)\n", fontDesc);
HeapFree(GetProcessHeap(), 0, fontDesc->description.lpstrName);
free(fontDesc->description.lpstrName);
if (fontDesc->pPropertyNotifyCP)
IConnectionPoint_Release(fontDesc->pPropertyNotifyCP);
if (fontDesc->pFontEventsCP)
IConnectionPoint_Release(fontDesc->pFontEventsCP);
HeapFree(GetProcessHeap(), 0, fontDesc);
free(fontDesc);
}
/*******************************************************************************
dll/win32/oleaut32/olepicture.c
+284 -308
View File
File diff suppressed because it is too large Load Diff
dll/win32/oleaut32/olepropframe.c
+12 -16
View File
@@ -22,8 +22,6 @@
#include <stdarg.h>
#define COBJMACROS
#define NONAMELESSUNION
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
@@ -93,7 +91,7 @@ static ULONG WINAPI PropertyPageSite_AddRef(IPropertyPageSite* iface)
PropertyPageSite *this = impl_from_IPropertyPageSite(iface);
LONG ref = InterlockedIncrement(&this->ref);
TRACE("(%p) ref=%d\n", this, ref);
TRACE("%p, refcount %ld.\n", iface, ref);
return ref;
}
@@ -102,7 +100,7 @@ static ULONG WINAPI PropertyPageSite_Release(IPropertyPageSite* iface)
PropertyPageSite *this = impl_from_IPropertyPageSite(iface);
LONG ref = InterlockedDecrement(&this->ref);
TRACE("(%p) ref=%d\n", this, ref);
TRACE("%p, refcount %ld.\n", iface, ref);
if(!ref)
HeapFree(GetProcessHeap(), 0, this);
return ref;
@@ -111,7 +109,7 @@ static ULONG WINAPI PropertyPageSite_Release(IPropertyPageSite* iface)
static HRESULT WINAPI PropertyPageSite_OnStatusChange(
IPropertyPageSite *iface, DWORD dwFlags)
{
TRACE("(%p, %x)\n", iface, dwFlags);
TRACE("%p, %lx.\n", iface, dwFlags);
return S_OK;
}
@@ -154,8 +152,6 @@ static IPropertyPageSiteVtbl PropertyPageSiteVtbl = {
*/
HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
{
static const WCHAR comctlW[] = { 'c','o','m','c','t','l','3','2','.','d','l','l',0 };
PROPSHEETHEADERW property_sheet;
PROPSHEETPAGEW property_sheet_page;
struct {
@@ -180,7 +176,7 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
if(!lpParams)
return E_POINTER;
TRACE("(%d %p %d %d %s %d %p %d %p %d %d)\n", lpParams->cbStructSize,
TRACE("%ld, %p, %d, %d, %s, %ld, %p, %ld, %p, %ld, %ld.\n", lpParams->cbStructSize,
lpParams->hWndOwner, lpParams->x, lpParams->y,
debugstr_w(lpParams->lpszCaption), lpParams->cObjects,
lpParams->lplpUnk, lpParams->cPages, lpParams->lpPages,
@@ -198,7 +194,7 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
FIXME("dispidInitialProperty not yet implemented\n");
hdc = GetDC(NULL);
hcomctl = LoadLibraryW(comctlW);
hcomctl = LoadLibraryW(L"comctl32.dll");
if(hcomctl)
property_sheet_dialog_find = FindResourceW(hcomctl,
MAKEINTRESOURCEW(1006 /*IDD_PROPSHEET*/), (LPWSTR)RT_DIALOG);
@@ -246,14 +242,14 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
property_sheet.pszCaption = lpParams->lpszCaption;
}
property_sheet.u3.phpage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
property_sheet.phpage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
lpParams->cPages*sizeof(HPROPSHEETPAGE));
property_page = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
lpParams->cPages*sizeof(IPropertyPage*));
dialogs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
lpParams->cPages*sizeof(*dialogs));
if(!property_sheet.u3.phpage || !property_page || !dialogs) {
HeapFree(GetProcessHeap(), 0, property_sheet.u3.phpage);
if(!property_sheet.phpage || !property_page || !dialogs) {
HeapFree(GetProcessHeap(), 0, property_sheet.phpage);
HeapFree(GetProcessHeap(), 0, property_page);
HeapFree(GetProcessHeap(), 0, dialogs);
return E_OUTOFMEMORY;
@@ -288,7 +284,7 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
res = IPropertyPage_SetObjects(property_page[i],
lpParams->cObjects, lpParams->lplpUnk);
if(FAILED(res))
WARN("SetObjects() failed, hr %#x.\n", res);
WARN("SetObjects() failed, hr %#lx.\n", res);
res = IPropertyPage_GetPageInfo(property_page[i], &page_info);
if(FAILED(res))
@@ -297,11 +293,11 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
dialogs[i].template.cx = MulDiv(page_info.size.cx, 4, font_width);
dialogs[i].template.cy = MulDiv(page_info.size.cy, 8, font_height);
property_sheet_page.u.pResource = &dialogs[i].template;
property_sheet_page.pResource = &dialogs[i].template;
property_sheet_page.lParam = (LPARAM)property_page[i];
property_sheet_page.pszTitle = page_info.pszTitle;
property_sheet.u3.phpage[property_sheet.nPages++] =
property_sheet.phpage[property_sheet.nPages++] =
CreatePropertySheetPageW(&property_sheet_page);
}
@@ -314,7 +310,7 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
HeapFree(GetProcessHeap(), 0, dialogs);
HeapFree(GetProcessHeap(), 0, property_page);
HeapFree(GetProcessHeap(), 0, property_sheet.u3.phpage);
HeapFree(GetProcessHeap(), 0, property_sheet.phpage);
return S_OK;
}
dll/win32/oleaut32/precomp.h
-2
View File
@@ -9,8 +9,6 @@
#define _INC_WINDOWS
#define COBJMACROS
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
#include <windef.h>
#include <winbase.h>
dll/win32/oleaut32/recinfo.c
+19 -24
View File
@@ -19,8 +19,6 @@
#include <stdarg.h>
#define COBJMACROS
#define NONAMELESSUNION
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
@@ -163,7 +161,7 @@ static ULONG WINAPI IRecordInfoImpl_AddRef(IRecordInfo *iface)
{
IRecordInfoImpl *This = impl_from_IRecordInfo(iface);
ULONG ref = InterlockedIncrement(&This->ref);
TRACE("(%p) -> %d\n", This, ref);
TRACE("%p, refcount %lu.\n", iface, ref);
return ref;
}
@@ -172,16 +170,16 @@ static ULONG WINAPI IRecordInfoImpl_Release(IRecordInfo *iface)
IRecordInfoImpl *This = impl_from_IRecordInfo(iface);
ULONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) -> %d\n", This, ref);
TRACE("%p, refcount %lu.\n", iface, ref);
if(!ref) {
int i;
for(i=0; i<This->n_vars; i++)
SysFreeString(This->fields[i].name);
SysFreeString(This->name);
HeapFree(GetProcessHeap(), 0, This->fields);
free(This->fields);
ITypeInfo_Release(This->pTypeInfo);
HeapFree(GetProcessHeap(), 0, This);
free(This);
}
return ref;
}
@@ -441,8 +439,7 @@ static HRESULT WINAPI IRecordInfoImpl_PutField(IRecordInfo *iface, ULONG wFlags,
IRecordInfoImpl *This = impl_from_IRecordInfo(iface);
int i;
TRACE("(%p)->(%08x %p %s %p)\n", This, wFlags, pvData, debugstr_w(szFieldName),
pvarField);
TRACE("%p, %#lx, %p, %s, %p.\n", iface, wFlags, pvData, debugstr_w(szFieldName), pvarField);
if(!pvData || !szFieldName || !pvarField
|| (wFlags != INVOKE_PROPERTYPUTREF && wFlags != INVOKE_PROPERTYPUT))
@@ -469,7 +466,7 @@ static HRESULT WINAPI IRecordInfoImpl_PutFieldNoCopy(IRecordInfo *iface, ULONG w
IRecordInfoImpl *This = impl_from_IRecordInfo(iface);
int i;
FIXME("(%p)->(%08x %p %s %p) stub\n", This, wFlags, pvData, debugstr_w(szFieldName), pvarField);
FIXME("%p, %#lx, %p, %s, %p stub\n", iface, wFlags, pvData, debugstr_w(szFieldName), pvarField);
if(!pvData || !szFieldName || !pvarField
|| (wFlags != INVOKE_PROPERTYPUTREF && wFlags != INVOKE_PROPERTYPUT))
@@ -525,7 +522,7 @@ static PVOID WINAPI IRecordInfoImpl_RecordCreate(IRecordInfo *iface)
TRACE("(%p)\n", This);
record = HeapAlloc(GetProcessHeap(), 0, This->size);
record = CoTaskMemAlloc(This->size);
IRecordInfo_RecordInit(iface, record);
TRACE("created record at %p\n", record);
return record;
@@ -556,9 +553,7 @@ static HRESULT WINAPI IRecordInfoImpl_RecordDestroy(IRecordInfo *iface, PVOID pv
if(FAILED(hres))
return hres;
if(!HeapFree(GetProcessHeap(), 0, pvRecord))
return E_INVALIDARG;
CoTaskMemFree(pvRecord);
return S_OK;
}
@@ -597,8 +592,8 @@ HRESULT WINAPI GetRecordInfoFromGuids(REFGUID rGuidTypeLib, ULONG uVerMajor,
ITypeInfo *pTypeInfo;
ITypeLib *pTypeLib;
HRESULT hres;
TRACE("(%p,%d,%d,%d,%s,%p)\n", rGuidTypeLib, uVerMajor, uVerMinor,
TRACE("%s, %lu, %lu, %#lx, %s, %p.\n", debugstr_guid(rGuidTypeLib), uVerMajor, uVerMinor,
lcid, debugstr_guid(rGuidTypeInfo), ppRecInfo);
hres = LoadRegTypeLib(rGuidTypeLib, uVerMajor, uVerMinor, lcid, &pTypeLib);
@@ -637,22 +632,22 @@ HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo* pTI, IRecordInfo** ppRecInfo
hres = ITypeInfo_GetTypeAttr(pTI, &typeattr);
if(FAILED(hres) || !typeattr) {
WARN("GetTypeAttr failed: %08x\n", hres);
WARN("GetTypeAttr failed: %#lx.\n", hres);
return hres;
}
if(typeattr->typekind == TKIND_ALIAS) {
hres = ITypeInfo_GetRefTypeInfo(pTI, typeattr->tdescAlias.u.hreftype, &pTypeInfo);
hres = ITypeInfo_GetRefTypeInfo(pTI, typeattr->tdescAlias.hreftype, &pTypeInfo);
guid = typeattr->guid;
ITypeInfo_ReleaseTypeAttr(pTI, typeattr);
if(FAILED(hres)) {
WARN("GetRefTypeInfo failed: %08x\n", hres);
WARN("GetRefTypeInfo failed: %#lx.\n", hres);
return hres;
}
hres = ITypeInfo_GetTypeAttr(pTypeInfo, &typeattr);
if(FAILED(hres)) {
ITypeInfo_Release(pTypeInfo);
WARN("GetTypeAttr failed for referenced type: %08x\n", hres);
WARN("GetTypeAttr failed for referenced type: %#lx.\n", hres);
return hres;
}
}else {
@@ -668,7 +663,7 @@ HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo* pTI, IRecordInfo** ppRecInfo
return E_INVALIDARG;
}
ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret));
ret = calloc(1, sizeof(*ret));
ret->IRecordInfo_iface.lpVtbl = &IRecordInfoImplVtbl;
ret->ref = 1;
ret->pTypeInfo = pTypeInfo;
@@ -688,7 +683,7 @@ HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo* pTI, IRecordInfo** ppRecInfo
ret->name = NULL;
}
ret->fields = HeapAlloc(GetProcessHeap(), 0, ret->n_vars*sizeof(fieldstr));
ret->fields = calloc(ret->n_vars, sizeof(fieldstr));
for(i = 0; i<ret->n_vars; i++) {
VARDESC *vardesc;
hres = ITypeInfo_GetVarDesc(pTypeInfo, i, &vardesc);
@@ -698,12 +693,12 @@ HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo* pTI, IRecordInfo** ppRecInfo
}
ret->fields[i].vt = vardesc->elemdescVar.tdesc.vt;
ret->fields[i].varkind = vardesc->varkind;
ret->fields[i].offset = vardesc->u.oInst;
ret->fields[i].offset = vardesc->oInst;
hres = ITypeInfo_GetDocumentation(pTypeInfo, vardesc->memid, &ret->fields[i].name,
NULL, NULL, NULL);
if(FAILED(hres))
WARN("GetDocumentation failed: %08x\n", hres);
TRACE("field=%s, offset=%d\n", debugstr_w(ret->fields[i].name), ret->fields[i].offset);
WARN("GetDocumentation failed: %#lx.\n", hres);
TRACE("field=%s, offset=%ld\n", debugstr_w(ret->fields[i].name), ret->fields[i].offset);
ITypeInfo_ReleaseVarDesc(pTypeInfo, vardesc);
}
dll/win32/oleaut32/safearray.c
+12 -12
View File
@@ -287,7 +287,7 @@ static HRESULT SAFEARRAY_DestroyData(SAFEARRAY *psa, ULONG ulStartCell)
ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
if (ulStartCell > ulCellCount) {
FIXME("unexpected ulCellCount %d, start %d\n",ulCellCount,ulStartCell);
FIXME("unexpected ulCellCount %ld, start %ld\n", ulCellCount, ulStartCell);
return E_UNEXPECTED;
}
@@ -372,7 +372,7 @@ static HRESULT SAFEARRAY_CopyData(SAFEARRAY *psa, SAFEARRAY *dest)
/* destination is cleared automatically */
hRet = VariantCopy(dest_var, src_var);
if (FAILED(hRet)) FIXME("VariantCopy failed with 0x%08x, element %u\n", hRet, ulCellCount);
if (FAILED(hRet)) FIXME("VariantCopy failed with %#lx, element %lu.\n", hRet, ulCellCount);
src_var++;
dest_var++;
}
@@ -495,7 +495,7 @@ HRESULT WINAPI SafeArrayAllocDescriptor(UINT cDims, SAFEARRAY **ppsaOut)
(*ppsaOut)->cDims = cDims;
TRACE("(%d): %u bytes allocated for descriptor.\n", cDims, allocSize);
TRACE("%d: %lu bytes allocated for descriptor.\n", cDims, allocSize);
return S_OK;
}
@@ -569,7 +569,7 @@ HRESULT WINAPI SafeArrayAllocData(SAFEARRAY *psa)
if (psa->pvData)
{
hRet = S_OK;
TRACE("%u bytes allocated for data at %p (%u objects).\n",
TRACE("%lu bytes allocated for data at %p (%lu objects).\n",
ulSize * psa->cbElements, psa->pvData, ulSize);
}
else
@@ -676,7 +676,7 @@ SAFEARRAY* WINAPI SafeArrayCreateEx(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsa
*/
SAFEARRAY* WINAPI SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements)
{
TRACE("(%s,%d,%u)\n", debugstr_vt(vt), lLbound, cElements);
TRACE("%s, %ld, %lu.\n", debugstr_vt(vt), lLbound, cElements);
if (vt == VT_RECORD)
return NULL;
@@ -708,7 +708,7 @@ SAFEARRAY* WINAPI SafeArrayCreateVectorEx(VARTYPE vt, LONG lLbound, ULONG cEleme
IRecordInfo* iRecInfo = pvExtra;
SAFEARRAY* psa;
TRACE("(%s,%d,%u,%p)\n", debugstr_vt(vt), lLbound, cElements, pvExtra);
TRACE("%s, %ld, %lu, %p.\n", debugstr_vt(vt), lLbound, cElements, pvExtra);
if (vt == VT_RECORD)
{
@@ -886,7 +886,7 @@ HRESULT WINAPI SafeArrayPutElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData
VARIANT* lpDest = lpvDest;
hRet = VariantCopy(lpDest, lpVariant);
if (FAILED(hRet)) FIXME("VariantCopy failed with 0x%x\n", hRet);
if (FAILED(hRet)) FIXME("VariantCopy failed with %#lx.\n", hRet);
}
else if (psa->fFeatures & FADF_BSTR)
{
@@ -971,7 +971,7 @@ HRESULT WINAPI SafeArrayGetElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData
/* The original content of pvData is ignored. */
V_VT(lpDest) = VT_EMPTY;
hRet = VariantCopy(lpDest, lpVariant);
if (FAILED(hRet)) FIXME("VariantCopy failed with 0x%x\n", hRet);
if (FAILED(hRet)) FIXME("VariantCopy failed with %#lx.\n", hRet);
}
else if (psa->fFeatures & FADF_BSTR)
{
@@ -1113,8 +1113,8 @@ UINT WINAPI SafeArrayGetDim(SAFEARRAY *psa)
*/
UINT WINAPI SafeArrayGetElemsize(SAFEARRAY *psa)
{
TRACE("(%p) returning %d\n", psa, psa ? psa->cbElements : 0u);
return psa ? psa->cbElements : 0;
TRACE("%p, returning %ld.\n", psa, psa ? psa->cbElements : 0u);
return psa ? psa->cbElements : 0;
}
/*************************************************************************
@@ -1460,10 +1460,10 @@ HRESULT WINAPI SafeArrayRedim(SAFEARRAY *psa, SAFEARRAYBOUND *psabound)
TRACE("(%p,%p)\n", psa, psabound);
if (!psa || psa->fFeatures & FADF_FIXEDSIZE || !psabound)
if (!psa || !psabound)
return E_INVALIDARG;
if (psa->cLocks > 0)
if (psa->fFeatures & FADF_FIXEDSIZE || psa->cLocks)
return DISP_E_ARRAYISLOCKED;
hr = SafeArrayLock(psa);
dll/win32/oleaut32/thunks.c
+187
View File
@@ -0,0 +1,187 @@
/*
* oleaut32 thunking
*
* Copyright 2019, 2024 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*
*/
#if 0
#pragma makedep arm64ec_x64
#endif
#define COBJMACROS
#include <stdarg.h>
#include "windef.h"
#include "wine/asm.h"
#ifdef __i386__
__ASM_GLOBAL_FUNC( call_method,
"pushl %ebp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
__ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
"movl %esp,%ebp\n\t"
__ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
"pushl %esi\n\t"
__ASM_CFI(".cfi_rel_offset %esi,-4\n\t")
"pushl %edi\n\t"
__ASM_CFI(".cfi_rel_offset %edi,-8\n\t")
"movl 12(%ebp),%edx\n\t"
"movl %esp,%edi\n\t"
"shll $2,%edx\n\t"
"jz 1f\n\t"
"subl %edx,%edi\n\t"
"andl $~15,%edi\n\t"
"movl %edi,%esp\n\t"
"movl 12(%ebp),%ecx\n\t"
"movl 16(%ebp),%esi\n\t"
"cld\n\t"
"rep; movsl\n"
"1:\tcall *8(%ebp)\n\t"
"subl %esp,%edi\n\t"
"movl 20(%ebp),%ecx\n\t"
"movl %edi,(%ecx)\n\t"
"leal -8(%ebp),%esp\n\t"
"popl %edi\n\t"
__ASM_CFI(".cfi_same_value %edi\n\t")
"popl %esi\n\t"
__ASM_CFI(".cfi_same_value %esi\n\t")
"popl %ebp\n\t"
__ASM_CFI(".cfi_def_cfa %esp,4\n\t")
__ASM_CFI(".cfi_same_value %ebp\n\t")
"ret" )
__ASM_GLOBAL_FUNC( call_double_method,
"jmp " __ASM_NAME("call_method") )
#elif defined __x86_64__
__ASM_GLOBAL_FUNC( call_method,
"pushq %rbp\n\t"
__ASM_SEH(".seh_pushreg %rbp\n\t")
__ASM_CFI(".cfi_adjust_cfa_offset 8\n\t")
__ASM_CFI(".cfi_rel_offset %rbp,0\n\t")
"movq %rsp,%rbp\n\t"
__ASM_SEH(".seh_setframe %rbp,0\n\t")
__ASM_CFI(".cfi_def_cfa_register %rbp\n\t")
"pushq %rsi\n\t"
__ASM_SEH(".seh_pushreg %rsi\n\t")
__ASM_CFI(".cfi_rel_offset %rsi,-8\n\t")
"pushq %rdi\n\t"
__ASM_SEH(".seh_pushreg %rdi\n\t")
__ASM_CFI(".cfi_rel_offset %rdi,-16\n\t")
__ASM_SEH(".seh_endprologue\n\t")
"movq %rcx,%rax\n\t"
"movq $4,%rcx\n\t"
"cmp %rcx,%rdx\n\t"
"cmovgq %rdx,%rcx\n\t"
"leaq 0(,%rcx,8),%rdx\n\t"
"subq %rdx,%rsp\n\t"
"andq $~15,%rsp\n\t"
"movq %rsp,%rdi\n\t"
"movq %r8,%rsi\n\t"
"rep; movsq\n\t"
"movq 0(%rsp),%rcx\n\t"
"movq 8(%rsp),%rdx\n\t"
"movq 16(%rsp),%r8\n\t"
"movq 24(%rsp),%r9\n\t"
"movq 0(%rsp),%xmm0\n\t"
"movq 8(%rsp),%xmm1\n\t"
"movq 16(%rsp),%xmm2\n\t"
"movq 24(%rsp),%xmm3\n\t"
"callq *%rax\n\t"
"leaq -16(%rbp),%rsp\n\t"
"popq %rdi\n\t"
__ASM_CFI(".cfi_same_value %rdi\n\t")
"popq %rsi\n\t"
__ASM_CFI(".cfi_same_value %rsi\n\t")
__ASM_CFI(".cfi_def_cfa_register %rsp\n\t")
"popq %rbp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset -8\n\t")
__ASM_CFI(".cfi_same_value %rbp\n\t")
"ret" )
__ASM_GLOBAL_FUNC( call_double_method,
"jmp " __ASM_NAME("call_method") )
#elif defined __aarch64__
__ASM_GLOBAL_FUNC( call_method,
"stp x29, x30, [sp, #-16]!\n\t"
".seh_save_fplr_x 16\n\t"
"mov x29, sp\n\t"
".seh_set_fp\n\t"
".seh_endprologue\n\t"
"sub sp, sp, x1, lsl #3\n\t"
"cbz x1, 2f\n"
"1:\tsub x1, x1, #1\n\t"
"ldr x4, [x2, x1, lsl #3]\n\t"
"str x4, [sp, x1, lsl #3]\n\t"
"cbnz x1, 1b\n"
"2:\tmov x16, x0\n\t"
"mov x9, x3\n\t"
"ldp d0, d1, [x9]\n\t"
"ldp d2, d3, [x9, #0x10]\n\t"
"ldp d4, d5, [x9, #0x20]\n\t"
"ldp d6, d7, [x9, #0x30]\n\t"
"ldp x0, x1, [x9, #0x40]\n\t"
"ldp x2, x3, [x9, #0x50]\n\t"
"ldp x4, x5, [x9, #0x60]\n\t"
"ldp x6, x7, [x9, #0x70]\n\t"
"ldr x8, [x9, #0x80]\n\t"
"blr x16\n\t"
"mov sp, x29\n\t"
"ldp x29, x30, [sp], #16\n\t"
"ret" )
__ASM_GLOBAL_FUNC( call_float_method,
"b " __ASM_NAME("call_method") )
__ASM_GLOBAL_FUNC( call_double_method,
"b " __ASM_NAME("call_method") )
#elif defined __arm__
__ASM_GLOBAL_FUNC( call_method,
/* r0 = *func
* r1 = nb_stk_args
* r2 = *stk_args (pointer to 'nb_stk_args' DWORD values to push on stack)
* r3 = *reg_args (pointer to 8, 64-bit d0-d7 (double) values OR as 16, 32-bit s0-s15 (float) values, followed by 4, 32-bit (DWORD) r0-r3 values)
*/
"push {fp, lr}\n\t"
".seh_save_regs_w {fp,lr}\n\t"
"mov fp, sp\n\t"
".seh_save_sp fp\n\t"
".seh_endprologue\n\t"
"lsls r1, r1, #2\n\t" /* r1 = nb_stk_args * sizeof(DWORD) */
"beq 1f\n\t" /* Skip allocation if no stack args */
"add r2, r2, r1\n" /* Calculate ending address of incoming stack data */
"2:\tldr ip, [r2, #-4]!\n\t" /* Get next value */
"str ip, [sp, #-4]!\n\t" /* Push it on the stack */
"subs r1, r1, #4\n\t" /* Decrement count */
"bgt 2b\n\t" /* Loop till done */
"1:\n\t"
"vldm r3!, {s0-s15}\n\t" /* Load the s0-s15/d0-d7 arguments */
"mov ip, r0\n\t" /* Save the function call address to ip before we nuke r0 with arguments to pass */
"ldm r3, {r0-r3}\n\t" /* Load the r0-r3 arguments */
"blx ip\n\t" /* Call the target function */
"mov sp, fp\n\t" /* Clean the stack using fp */
"pop {fp, pc}" ) /* Restore fp and return */
__ASM_GLOBAL_FUNC( call_float_method,
"b " __ASM_NAME("call_method") )
__ASM_GLOBAL_FUNC( call_double_method,
"b " __ASM_NAME("call_method") )
#endif
dll/win32/oleaut32/typelib.c
+1018 -1288
View File
File diff suppressed because it is too large Load Diff
dll/win32/oleaut32/typelib.h
+6 -10
View File
@@ -309,10 +309,7 @@ typedef struct {
/*08*/ WORD res08; /* some kind of len/offset ?? */
/*0a*/ WORD first_blk; /* 1 based index into blk entries that
corresponds to first block in file */
/*0c*/ DWORD res0c; /* always 0x000204ff */
/*10*/ DWORD res10; /* always 0x00000000 */
/*14*/ DWORD res14; /* always 0x000000c0 */
/*18*/ DWORD res18; /* always 0x46000000 */
/*0c*/ GUID guid; /* always 000204ff-0000-0000-c000-000000000046 */
/*1c*/ DWORD res1c; /* always 0x00000044 */
/*20*/ DWORD res20; /* always 0xffff0000 */
} SLTG_Header;
@@ -325,16 +322,15 @@ typedef struct {
} SLTG_BlkEntry;
/* The order of the blocks in the file is given by starting at Block
entry firt_blk and stepping through using the next pointer */
entry first_blk and stepping through using the next pointer */
/* These then get followed by this magic */
typedef struct {
/*00*/ BYTE res00; /* always 0x01 */
/*01*/ CHAR CompObj_magic[8]; /* always "CompObj" */
/*00*/ CHAR CompObj_magic[9]; /* always "\1CompObj" */
/*09*/ CHAR dir_magic[4]; /* always "dir" */
} SLTG_Magic;
#define SLTG_COMPOBJ_MAGIC "CompObj"
#define SLTG_COMPOBJ_MAGIC "\1CompObj"
#define SLTG_DIR_MAGIC "dir"
/* Next we have SLTG_Header.nrOfFileBlks - 2 of Index strings. These
@@ -386,18 +382,18 @@ typedef struct {
/* we then get 0x40 bytes worth of 0xffff or small numbers followed by
nrOfFileBlks - 2 of these */
typedef struct {
WORD small_no;
SLTG_Name index_name; /* This refers to a name in the directory */
SLTG_Name other_name; /* Another one of these weird names */
WORD res1a; /* 0xffff */
WORD name_offs; /* offset to name in name table */
WORD hlpstr_len; /* if this is non-zero we get this many
WORD more_bytes; /* if this is non-zero we get this many
bytes before the next element, which seem
to reference the docstring of the type ? */
WORD res20; /* 0xffff */
DWORD helpcontext;
WORD res26; /* 0xffff */
GUID uuid;
WORD typekind;
} SLTG_OtherTypeInfo;
/* Next we get WORD 0x0003 followed by a DWORD which if we add to
dll/win32/oleaut32/usrmarshal.c
+86 -183
View File
@@ -23,8 +23,6 @@
#include <string.h>
#define COBJMACROS
#define NONAMELESSUNION
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
@@ -102,7 +100,7 @@ unsigned char * WINAPI CLEANLOCALSTORAGE_UserMarshal(ULONG *pFlags, unsigned cha
break;
default:
ERR("Unknown type %x\n", pstg->flags);
ERR("Unknown type %lx\n", pstg->flags);
}
*(VOID**)pstg->pStorage = NULL;
@@ -135,11 +133,11 @@ typedef struct
ULONG WINAPI BSTR_UserSize(ULONG *pFlags, ULONG Start, BSTR *pstr)
{
TRACE("(%x,%d,%p) => %p\n", *pFlags, Start, pstr, *pstr);
TRACE("%#lx, %lu, %p => %p\n", *pFlags, Start, pstr, *pstr);
if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
ALIGN_LENGTH(Start, 3);
Start += sizeof(bstr_wire_t) + ((SysStringByteLen(*pstr) + 1) & ~1);
TRACE("returning %d\n", Start);
TRACE("returning %ld\n", Start);
return Start;
}
@@ -148,7 +146,7 @@ unsigned char * WINAPI BSTR_UserMarshal(ULONG *pFlags, unsigned char *Buffer, BS
bstr_wire_t *header;
DWORD len = SysStringByteLen(*pstr);
TRACE("(%x,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
TRACE("%#lx, %p, %p => %p\n", *pFlags, Buffer, pstr, *pstr);
if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
ALIGN_POINTER(Buffer, 3);
@@ -168,12 +166,12 @@ unsigned char * WINAPI BSTR_UserMarshal(ULONG *pFlags, unsigned char *Buffer, BS
unsigned char * WINAPI BSTR_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
{
bstr_wire_t *header;
TRACE("(%x,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
TRACE("%#lx, %p, %p => %p\n", *pFlags, Buffer, pstr, *pstr);
ALIGN_POINTER(Buffer, 3);
header = (bstr_wire_t*)Buffer;
if(header->len != header->len2)
FIXME("len %08x != len2 %08x\n", header->len, header->len2);
FIXME("len %#lx != len2 %#lx\n", header->len, header->len2);
if (header->byte_len == 0xffffffff)
{
@@ -188,7 +186,7 @@ unsigned char * WINAPI BSTR_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer,
void WINAPI BSTR_UserFree(ULONG *pFlags, BSTR *pstr)
{
TRACE("(%x,%p) => %p\n", *pFlags, pstr, *pstr);
TRACE("%#lx, %p => %p\n", *pFlags, pstr, *pstr);
SysFreeString(*pstr);
*pstr = NULL;
}
@@ -268,11 +266,7 @@ static unsigned int get_type_alignment(ULONG *pFlags, VARTYPE vt)
}
/* WdtpInterfacePointer_UserSize takes care of 2 additional DWORDs to store marshalling buffer size */
#ifdef __REACTOS__
static unsigned interface_user_size(ULONG *pFlags, ULONG Start, REFIID riid, IUnknown *punk)
#else
static unsigned interface_variant_size(ULONG *pFlags, REFIID riid, IUnknown *punk)
#endif
{
ULONG size = 0;
@@ -286,12 +280,8 @@ static unsigned interface_variant_size(ULONG *pFlags, REFIID riid, IUnknown *pun
}
}
size += sizeof(ULONG);
TRACE("wire-size extra of interface variant is %d\n", size);
#ifdef __REACTOS__
TRACE("wire-size extra of interface variant is %ld.\n", size);
return Start + size;
#else
return size;
#endif
}
static ULONG wire_extra_user_size(ULONG *pFlags, ULONG Start, VARIANT *pvar)
@@ -312,29 +302,13 @@ static ULONG wire_extra_user_size(ULONG *pFlags, ULONG Start, VARIANT *pvar)
case VT_VARIANT | VT_BYREF:
return VARIANT_UserSize(pFlags, Start, V_VARIANTREF(pvar));
case VT_UNKNOWN:
#ifdef __REACTOS__
return interface_user_size(pFlags, Start, &IID_IUnknown, V_UNKNOWN(pvar));
#else
return Start + interface_variant_size(pFlags, &IID_IUnknown, V_UNKNOWN(pvar));
#endif
case VT_UNKNOWN | VT_BYREF:
#ifdef __REACTOS__
return interface_user_size(pFlags, Start, &IID_IUnknown, *V_UNKNOWNREF(pvar));
#else
return Start + interface_variant_size(pFlags, &IID_IUnknown, *V_UNKNOWNREF(pvar));
#endif
case VT_DISPATCH:
#ifdef __REACTOS__
return interface_user_size(pFlags, Start, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
#else
return Start + interface_variant_size(pFlags, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
#endif
case VT_DISPATCH | VT_BYREF:
#ifdef __REACTOS__
return interface_user_size(pFlags, Start, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
#else
return Start + interface_variant_size(pFlags, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
#endif
case VT_RECORD:
FIXME("wire-size record\n");
return Start;
@@ -348,14 +322,10 @@ static ULONG wire_extra_user_size(ULONG *pFlags, ULONG Start, VARIANT *pvar)
}
/* helper: called for VT_DISPATCH variants to marshal the IDispatch* into the buffer */
#ifdef __REACTOS__
static unsigned char* interface_user_marshal(ULONG *pFlags, unsigned char *Buffer,
#else
static unsigned char* interface_variant_marshal(ULONG *pFlags, unsigned char *Buffer,
#endif
REFIID riid, IUnknown *punk)
{
TRACE("pFlags=%d, Buffer=%p, pUnk=%p\n", *pFlags, Buffer, punk);
TRACE("%#lx, %p, %p.\n", *pFlags, Buffer, punk);
/* first DWORD is used to store pointer itself, truncated on win64 */
if(!punk)
@@ -373,16 +343,12 @@ static unsigned char* interface_variant_marshal(ULONG *pFlags, unsigned char *Bu
}
/* helper: called for VT_DISPATCH / VT_UNKNOWN variants to unmarshal the buffer */
#ifdef __REACTOS__
static unsigned char *interface_user_unmarshal(ULONG *pFlags, unsigned char *Buffer,
#else
static unsigned char *interface_variant_unmarshal(ULONG *pFlags, unsigned char *Buffer,
#endif
REFIID riid, IUnknown **ppunk)
{
DWORD ptr;
TRACE("pFlags=%d, Buffer=%p, ppUnk=%p\n", *pFlags, Buffer, ppunk);
TRACE("%#lx, %p, %p.\n", *pFlags, Buffer, ppunk);
/* skip pointer part itself */
ptr = *(DWORD*)Buffer;
@@ -397,7 +363,7 @@ static unsigned char *interface_variant_unmarshal(ULONG *pFlags, unsigned char *
ULONG WINAPI VARIANT_UserSize(ULONG *pFlags, ULONG Start, VARIANT *pvar)
{
int align;
TRACE("(%x,%d,%p)\n", *pFlags, Start, pvar);
TRACE("%#lx, %lu, %p.\n", *pFlags, Start, pvar);
TRACE("vt=%04x\n", V_VT(pvar));
ALIGN_LENGTH(Start, 7);
@@ -413,7 +379,7 @@ ULONG WINAPI VARIANT_UserSize(ULONG *pFlags, ULONG Start, VARIANT *pvar)
Start += get_type_size(pFlags, V_VT(pvar));
Start = wire_extra_user_size(pFlags, Start, pvar);
TRACE("returning %d\n", Start);
TRACE("returning %ld\n", Start);
return Start;
}
@@ -424,7 +390,7 @@ unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer,
int align;
unsigned char *Pos;
TRACE("(%x,%p,%p)\n", *pFlags, Buffer, pvar);
TRACE("%#lx, %p, %p.\n", *pFlags, Buffer, pvar);
TRACE("vt=%04x\n", V_VT(pvar));
ALIGN_POINTER(Buffer, 7);
@@ -433,11 +399,17 @@ unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer,
header->clSize = 0; /* fixed up at the end */
header->rpcReserved = 0;
header->vt = pvar->n1.n2.vt;
header->vt = V_VT(pvar);
#ifdef __REACTOS__
header->wReserved1 = pvar->n1.n2.wReserved1;
header->wReserved2 = pvar->n1.n2.wReserved2;
header->wReserved3 = pvar->n1.n2.wReserved3;
header->switch_is = pvar->n1.n2.vt;
#else
header->wReserved1 = pvar->wReserved1;
header->wReserved2 = pvar->wReserved2;
header->wReserved3 = pvar->wReserved3;
#endif
header->switch_is = V_VT(pvar);
if(header->switch_is & VT_ARRAY)
header->switch_is &= ~VT_TYPEMASK;
@@ -452,7 +424,7 @@ unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer,
Pos += 4;
if((header->vt & VT_TYPEMASK) != VT_VARIANT)
{
memcpy(Pos, pvar->n1.n2.n3.byref, type_size);
memcpy(Pos, V_BYREF(pvar), type_size);
Pos += type_size;
}
else
@@ -466,7 +438,7 @@ unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer,
if((header->vt & VT_TYPEMASK) == VT_DECIMAL)
memcpy(Pos, pvar, type_size);
else
memcpy(Pos, &pvar->n1.n2.n3, type_size);
memcpy(Pos, &V_UI8(pvar), type_size);
Pos += type_size;
}
@@ -491,32 +463,16 @@ unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer,
Pos = VARIANT_UserMarshal(pFlags, Pos, V_VARIANTREF(pvar));
break;
case VT_UNKNOWN:
#ifdef __REACTOS__
Pos = interface_user_marshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWN(pvar));
#else
Pos = interface_variant_marshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWN(pvar));
#endif
break;
case VT_UNKNOWN | VT_BYREF:
#ifdef __REACTOS__
Pos = interface_user_marshal(pFlags, Pos, &IID_IUnknown, *V_UNKNOWNREF(pvar));
#else
Pos = interface_variant_marshal(pFlags, Pos, &IID_IUnknown, *V_UNKNOWNREF(pvar));
#endif
break;
case VT_DISPATCH:
#ifdef __REACTOS__
Pos = interface_user_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
#else
Pos = interface_variant_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
#endif
break;
case VT_DISPATCH | VT_BYREF:
#ifdef __REACTOS__
Pos = interface_user_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
#else
Pos = interface_variant_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
#endif
break;
case VT_RECORD:
FIXME("handle BRECORD by val\n");
@@ -527,7 +483,7 @@ unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer,
}
}
header->clSize = ((Pos - Buffer) + 7) >> 3;
TRACE("marshalled size=%d\n", header->clSize);
TRACE("marshalled size %ld\n", header->clSize);
return Pos;
}
@@ -538,7 +494,7 @@ unsigned char * WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffe
int align;
unsigned char *Pos;
TRACE("(%x,%p,%p)\n", *pFlags, Buffer, pvar);
TRACE("%#lx, %p, %p.\n", *pFlags, Buffer, pvar);
ALIGN_POINTER(Buffer, 7);
@@ -554,7 +510,10 @@ unsigned char * WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffe
ULONG mem_size;
Pos += 4;
switch (header->vt & ~VT_BYREF)
/* byref array needs to allocate a SAFEARRAY pointer */
if (header->vt & VT_ARRAY)
mem_size = sizeof(void *);
else switch (header->vt & ~VT_BYREF)
{
/* these types have a different memory size compared to wire size */
case VT_UNKNOWN:
@@ -608,14 +567,20 @@ unsigned char * WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffe
else if((header->vt & VT_TYPEMASK) == VT_DECIMAL)
memcpy(pvar, Pos, type_size);
else
memcpy(&pvar->n1.n2.n3, Pos, type_size);
memcpy(&V_UI8(pvar), Pos, type_size);
Pos += type_size;
}
pvar->n1.n2.vt = header->vt;
V_VT(pvar) = header->vt;
#ifdef __REACTOS__
pvar->n1.n2.wReserved1 = header->wReserved1;
pvar->n1.n2.wReserved2 = header->wReserved2;
pvar->n1.n2.wReserved3 = header->wReserved3;
#else
pvar->wReserved1 = header->wReserved1;
pvar->wReserved2 = header->wReserved2;
pvar->wReserved3 = header->wReserved3;
#endif
if(header->vt & VT_ARRAY)
{
@@ -638,32 +603,16 @@ unsigned char * WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffe
Pos = VARIANT_UserUnmarshal(pFlags, Pos, V_VARIANTREF(pvar));
break;
case VT_UNKNOWN:
#ifdef __REACTOS__
Pos = interface_user_unmarshal(pFlags, Pos, &IID_IUnknown, &V_UNKNOWN(pvar));
#else
Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IUnknown, &V_UNKNOWN(pvar));
#endif
break;
case VT_UNKNOWN | VT_BYREF:
#ifdef __REACTOS__
Pos = interface_user_unmarshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWNREF(pvar));
#else
Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWNREF(pvar));
#endif
break;
case VT_DISPATCH:
#ifdef __REACTOS__
Pos = interface_user_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)&V_DISPATCH(pvar));
#else
Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)&V_DISPATCH(pvar));
#endif
break;
case VT_DISPATCH | VT_BYREF:
#ifdef __REACTOS__
Pos = interface_user_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)V_DISPATCHREF(pvar));
#else
Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)V_DISPATCHREF(pvar));
#endif
break;
case VT_RECORD:
FIXME("handle BRECORD by val\n");
@@ -681,10 +630,10 @@ void WINAPI VARIANT_UserFree(ULONG *pFlags, VARIANT *pvar)
VARTYPE vt = V_VT(pvar);
PVOID ref = NULL;
TRACE("(%x,%p)\n", *pFlags, pvar);
TRACE("%#lx, %p.\n", *pFlags, pvar);
TRACE("vt=%04x\n", V_VT(pvar));
if (vt & VT_BYREF) ref = pvar->n1.n2.n3.byref;
if (vt & VT_BYREF) ref = V_BYREF(pvar);
VariantClear(pvar);
if (!ref) return;
@@ -797,39 +746,24 @@ static inline SF_TYPE SAFEARRAY_GetUnionType(SAFEARRAY *psa)
static DWORD elem_wire_size(LPSAFEARRAY lpsa, SF_TYPE sftype)
{
#ifdef __REACTOS__
switch (sftype)
{
case SF_BSTR:
case SF_HAVEIID:
case SF_UNKNOWN:
case SF_DISPATCH:
#else
if (sftype == SF_BSTR)
#endif
return sizeof(DWORD);
#ifdef __REACTOS__
case SF_VARIANT:
#else
else if (sftype == SF_VARIANT)
#endif
return sizeof(variant_wire_t) - sizeof(DWORD);
#ifdef __REACTOS__
default:
#else
else
#endif
return lpsa->cbElements;
#ifdef __REACTOS__
}
#endif
}
static DWORD elem_mem_size(wireSAFEARRAY wiresa, SF_TYPE sftype)
{
#ifdef __REACTOS__
switch (sftype)
{
case SF_HAVEIID:
@@ -838,34 +772,21 @@ static DWORD elem_mem_size(wireSAFEARRAY wiresa, SF_TYPE sftype)
return sizeof(void *);
case SF_BSTR:
#else
if (sftype == SF_BSTR)
#endif
return sizeof(BSTR);
#ifdef __REACTOS__
case SF_VARIANT:
#else
else if (sftype == SF_VARIANT)
#endif
return sizeof(VARIANT);
#ifdef __REACTOS__
default:
#else
else
#endif
return wiresa->cbElements;
#ifdef __REACTOS__
}
#endif
}
ULONG WINAPI LPSAFEARRAY_UserSize(ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY *ppsa)
{
ULONG size = StartingSize;
TRACE("("); dump_user_flags(pFlags); TRACE(", %d, %p\n", StartingSize, *ppsa);
TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, *ppsa);
ALIGN_LENGTH(size, 3);
size += sizeof(ULONG);
@@ -905,7 +826,6 @@ ULONG WINAPI LPSAFEARRAY_UserSize(ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY
case SF_DISPATCH:
case SF_UNKNOWN:
case SF_HAVEIID:
#ifdef __REACTOS__
{
IUnknown **lpUnk;
GUID guid;
@@ -920,13 +840,8 @@ ULONG WINAPI LPSAFEARRAY_UserSize(ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY
for (lpUnk = psa->pvData; ulCellCount; ulCellCount--, lpUnk++)
size = interface_user_size(pFlags, size, &guid, *lpUnk);
#else
FIXME("size interfaces\n");
#endif
break;
#ifdef __REACTOS__
}
#endif
case SF_VARIANT:
{
VARIANT* lpVariant;
@@ -1000,11 +915,7 @@ unsigned char * WINAPI LPSAFEARRAY_UserMarshal(ULONG *pFlags, unsigned char *Buf
Buffer += sizeof(ULONG);
hr = SafeArrayGetVartype(psa, &vt);
#ifdef __REACTOS__
if ((psa->fFeatures & FADF_HAVEIID) || FAILED(hr)) vt = 0;
#else
if (FAILED(hr)) vt = 0;
#endif
*(ULONG *)Buffer = (USHORT)psa->cLocks | (vt << 16);
Buffer += sizeof(ULONG);
@@ -1050,7 +961,6 @@ unsigned char * WINAPI LPSAFEARRAY_UserMarshal(ULONG *pFlags, unsigned char *Buf
case SF_DISPATCH:
case SF_UNKNOWN:
case SF_HAVEIID:
#ifdef __REACTOS__
{
IUnknown **lpUnk;
const GUID *iid;
@@ -1065,13 +975,8 @@ unsigned char * WINAPI LPSAFEARRAY_UserMarshal(ULONG *pFlags, unsigned char *Buf
for (lpUnk = psa->pvData; ulCellCount; ulCellCount--, lpUnk++)
Buffer = interface_user_marshal(pFlags, Buffer, iid, *lpUnk);
#else
FIXME("marshal interfaces\n");
#endif
break;
#ifdef __REACTOS__
}
#endif
case SF_VARIANT:
{
VARIANT* lpVariant;
@@ -1247,7 +1152,6 @@ unsigned char * WINAPI LPSAFEARRAY_UserUnmarshal(ULONG *pFlags, unsigned char *B
case SF_DISPATCH:
case SF_UNKNOWN:
case SF_HAVEIID:
#ifdef __REACTOS__
{
IUnknown **lpUnk;
const GUID *iid;
@@ -1262,13 +1166,8 @@ unsigned char * WINAPI LPSAFEARRAY_UserUnmarshal(ULONG *pFlags, unsigned char *B
for (lpUnk = (*ppsa)->pvData; cell_count; cell_count--, lpUnk++)
Buffer = interface_user_unmarshal(pFlags, Buffer, iid, lpUnk);
#else
FIXME("marshal interfaces\n");
#endif
break;
#ifdef __REACTOS__
}
#endif
case SF_VARIANT:
{
VARIANT* lpVariant;
@@ -1362,7 +1261,7 @@ HRESULT CALLBACK IDispatch_Invoke_Proxy(
UINT uArgErr;
EXCEPINFO ExcepInfo;
TRACE("(%p)->(%d,%s,%x,%x,%p,%p,%p,%p)\n", This,
TRACE("%p, %ld, %s, %#lx, %x, %p, %p, %p, %p.\n", This,
dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult,
pExcepInfo, puArgErr);
@@ -1552,12 +1451,12 @@ static void free_embedded_arraydesc(ARRAYDESC *adesc)
{
case VT_PTR:
case VT_SAFEARRAY:
free_embedded_typedesc(adesc->tdescElem.u.lptdesc);
CoTaskMemFree(adesc->tdescElem.u.lptdesc);
free_embedded_typedesc(adesc->tdescElem.lptdesc);
CoTaskMemFree(adesc->tdescElem.lptdesc);
break;
case VT_CARRAY:
free_embedded_arraydesc(adesc->tdescElem.u.lpadesc);
CoTaskMemFree(adesc->tdescElem.u.lpadesc);
free_embedded_arraydesc(adesc->tdescElem.lpadesc);
CoTaskMemFree(adesc->tdescElem.lpadesc);
break;
}
}
@@ -1568,12 +1467,12 @@ static void free_embedded_typedesc(TYPEDESC *tdesc)
{
case VT_PTR:
case VT_SAFEARRAY:
free_embedded_typedesc(tdesc->u.lptdesc);
CoTaskMemFree(tdesc->u.lptdesc);
free_embedded_typedesc(tdesc->lptdesc);
CoTaskMemFree(tdesc->lptdesc);
break;
case VT_CARRAY:
free_embedded_arraydesc(tdesc->u.lpadesc);
CoTaskMemFree(tdesc->u.lpadesc);
free_embedded_arraydesc(tdesc->lpadesc);
CoTaskMemFree(tdesc->lpadesc);
break;
}
}
@@ -1581,8 +1480,8 @@ static void free_embedded_typedesc(TYPEDESC *tdesc)
static void free_embedded_elemdesc(ELEMDESC *edesc)
{
free_embedded_typedesc(&edesc->tdesc);
if(edesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
CoTaskMemFree(edesc->u.paramdesc.pparamdescex);
if(edesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
CoTaskMemFree(edesc->paramdesc.pparamdescex);
}
/* ITypeComp */
@@ -1602,7 +1501,7 @@ HRESULT CALLBACK ITypeComp_Bind_Proxy(
VARDESC *vardesc;
HRESULT hr;
TRACE("(%p, %s, %#x, %#x, %p, %p, %p)\n", This, debugstr_w(name), lHashVal, flags, ti,
TRACE("%p, %s, %#lx, %#x, %p, %p, %p.\n", This, debugstr_w(name), lHashVal, flags, ti,
desckind, bindptr);
*desckind = DESCKIND_NONE;
@@ -1648,7 +1547,7 @@ HRESULT __RPC_STUB ITypeComp_Bind_Stub(
BINDPTR bindptr;
HRESULT hr;
TRACE("(%p, %s, %#x, %#x, %p, %p, %p, %p, %p, %p)\n", This, debugstr_w(name),
TRACE("%p, %s, %#lx, %#x, %p, %p, %p, %p, %p, %p.\n", This, debugstr_w(name),
lHashVal, flags, ti, desckind, funcdesc, vardesc, typecomp, stg);
memset(stg, 0, sizeof(*stg));
@@ -1700,7 +1599,7 @@ HRESULT CALLBACK ITypeComp_BindType_Proxy(
{
HRESULT hr;
TRACE("(%p, %s, %#x, %p, %p)\n", This, debugstr_w(name), lHashVal, ti, typecomp);
TRACE("%p, %s, %#lx, %p, %p.\n", This, debugstr_w(name), lHashVal, ti, typecomp);
hr = ITypeComp_RemoteBindType_Proxy(This, name, lHashVal, ti);
if (hr == S_OK)
@@ -1720,7 +1619,7 @@ HRESULT __RPC_STUB ITypeComp_BindType_Stub(
ITypeComp *typecomp = NULL;
HRESULT hr;
TRACE("(%p, %s, %#x, %p)\n", This, debugstr_w(name), lHashVal, ti);
TRACE("%p, %s, %#lx, %p.\n", This, debugstr_w(name), lHashVal, ti);
hr = ITypeComp_BindType(This, name, lHashVal, ti, &typecomp);
@@ -1843,7 +1742,7 @@ HRESULT CALLBACK ITypeInfo_GetNames_Proxy(
UINT cMaxNames,
UINT* pcNames)
{
TRACE("(%p, %08x, %p, %d, %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
TRACE("%p, %#lx, %p, %d, %p.\n", This, memid, rgBstrNames, cMaxNames, pcNames);
return ITypeInfo_RemoteGetNames_Proxy(This, memid, rgBstrNames, cMaxNames, pcNames);
}
@@ -1855,7 +1754,7 @@ HRESULT __RPC_STUB ITypeInfo_GetNames_Stub(
UINT cMaxNames,
UINT* pcNames)
{
TRACE("(%p, %08x, %p, %d, %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
TRACE("%p, %#lx, %p, %d, %p.\n", This, memid, rgBstrNames, cMaxNames, pcNames);
return ITypeInfo_GetNames(This, memid, rgBstrNames, cMaxNames, pcNames);
}
@@ -1905,7 +1804,8 @@ HRESULT CALLBACK ITypeInfo_GetDocumentation_Proxy(ITypeInfo *This, MEMBERID memi
DWORD dummy_help_context, flags = 0;
BSTR dummy_name, dummy_doc_string, dummy_help_file;
HRESULT hr;
TRACE("(%p, %08x, %p, %p, %p, %p)\n", This, memid, name, doc_string, help_context, help_file);
TRACE("%p, %#lx, %p, %p, %p, %p.\n", This, memid, name, doc_string, help_context, help_file);
if(!name) name = &dummy_name;
else flags = 1;
@@ -1930,7 +1830,7 @@ HRESULT __RPC_STUB ITypeInfo_GetDocumentation_Stub(ITypeInfo *This, MEMBERID mem
DWORD flags, BSTR *name, BSTR *doc_string,
DWORD *help_context, BSTR *help_file)
{
TRACE("(%p, %08x, %08x, %p, %p, %p, %p)\n", This, memid, flags, name, doc_string, help_context, help_file);
TRACE("%p, %#lx, %#lx, %p, %p, %p, %p.\n", This, memid, flags, name, doc_string, help_context, help_file);
*name = *doc_string = *help_file = NULL;
*help_context = 0;
@@ -1951,7 +1851,8 @@ HRESULT CALLBACK ITypeInfo_GetDllEntry_Proxy(ITypeInfo *This, MEMBERID memid,
BSTR dummy_dll_name, dummy_name;
WORD dummy_ordinal;
HRESULT hr;
TRACE("(%p, %08x, %x, %p, %p, %p)\n", This, memid, invkind, dll_name, name, ordinal);
TRACE("%p, %#lx, %#x, %p, %p, %p.\n", This, memid, invkind, dll_name, name, ordinal);
if(!dll_name) dll_name = &dummy_dll_name;
else flags = 1;
@@ -1974,7 +1875,7 @@ HRESULT __RPC_STUB ITypeInfo_GetDllEntry_Stub(ITypeInfo *This, MEMBERID memid,
BSTR *dll_name, BSTR *name,
WORD *ordinal)
{
TRACE("(%p, %08x, %x, %p, %p, %p)\n", This, memid, invkind, dll_name, name, ordinal);
TRACE("%p, %#lx, %x, %p, %p, %p.\n", This, memid, invkind, dll_name, name, ordinal);
*dll_name = *name = NULL;
*ordinal = 0;
@@ -2108,7 +2009,7 @@ void CALLBACK ITypeInfo_ReleaseVarDesc_Proxy(
CoTaskMemFree(pVarDesc->lpstrSchema);
if(pVarDesc->varkind == VAR_CONST)
CoTaskMemFree(pVarDesc->u.lpvarValue);
CoTaskMemFree(pVarDesc->lpvarValue);
free_embedded_elemdesc(&pVarDesc->elemdescVar);
CoTaskMemFree(pVarDesc);
@@ -2131,7 +2032,8 @@ HRESULT CALLBACK ITypeInfo2_GetDocumentation2_Proxy(ITypeInfo2 *This, MEMBERID m
DWORD dummy_help_context, flags = 0;
BSTR dummy_help_string, dummy_help_dll;
HRESULT hr;
TRACE("(%p, %08x, %08x, %p, %p, %p)\n", This, memid, lcid, help_string, help_context, help_dll);
TRACE("%p, %#lx, %#lx, %p, %p, %p.\n", This, memid, lcid, help_string, help_context, help_dll);
if(!help_string) help_string = &dummy_help_string;
else flags = 1;
@@ -2154,7 +2056,7 @@ HRESULT __RPC_STUB ITypeInfo2_GetDocumentation2_Stub(ITypeInfo2 *This, MEMBERID
BSTR *help_string, DWORD *help_context,
BSTR *help_dll)
{
TRACE("(%p, %08x, %08x, %08x, %p, %p, %p)\n", This, memid, lcid, flags, help_string, help_context, help_dll);
TRACE("%p, %#lx, %#lx, %#lx, %p, %p, %p.\n", This, memid, lcid, flags, help_string, help_context, help_dll);
*help_string = *help_dll = NULL;
*help_context = 0;
@@ -2253,7 +2155,7 @@ HRESULT __RPC_STUB ITypeLib_GetDocumentation_Stub(ITypeLib *This, INT index, DWO
BSTR *name, BSTR *doc_string,
DWORD *help_context, BSTR *help_file)
{
TRACE("(%p, %d, %08x, %p, %p, %p, %p)\n", This, index, flags, name, doc_string, help_context, help_file);
TRACE("%p, %d, %#lx, %p, %p, %p, %p.\n", This, index, flags, name, doc_string, help_context, help_file);
*name = *doc_string = *help_file = NULL;
*help_context = 0;
@@ -2355,7 +2257,8 @@ HRESULT CALLBACK ITypeLib2_GetDocumentation2_Proxy(ITypeLib2 *This, INT index,
DWORD dummy_help_context, flags = 0;
BSTR dummy_help_string, dummy_help_dll;
HRESULT hr;
TRACE("(%p, %d, %08x, %p, %p, %p)\n", This, index, lcid, help_string, help_context, help_dll);
TRACE("%p, %d, %#lx, %p, %p, %p.\n", This, index, lcid, help_string, help_context, help_dll);
if(!help_string) help_string = &dummy_help_string;
else flags = 1;
@@ -2377,7 +2280,7 @@ HRESULT __RPC_STUB ITypeLib2_GetDocumentation2_Stub(ITypeLib2 *This, INT index,
DWORD flags, BSTR *help_string,
DWORD *help_context, BSTR *help_dll)
{
TRACE("(%p, %d, %08x, %08x, %p, %p, %p)\n", This, index, lcid, flags, help_string, help_context, help_dll);
TRACE("%p, %d, %#lx, %#lx, %p, %p, %p.\n", This, index, lcid, flags, help_string, help_context, help_dll);
*help_string = *help_dll = NULL;
*help_context = 0;
@@ -2435,10 +2338,10 @@ HRESULT __RPC_STUB IPropertyBag_Read_Stub(
DWORD varType,
IUnknown *pUnkObj)
{
static const WCHAR emptyWstr[] = {0};
IDispatch *disp;
HRESULT hr;
TRACE("(%p, %s, %p, %p, %x, %p)\n", This, debugstr_w(pszPropName), pVar,
TRACE("%p, %s, %p, %p, %lx, %p.\n", This, debugstr_w(pszPropName), pVar,
pErrorLog, varType, pUnkObj);
if(varType & (VT_BYREF | VT_ARRAY | VT_VECTOR))
@@ -2461,7 +2364,7 @@ HRESULT __RPC_STUB IPropertyBag_Read_Stub(
V_UNKNOWN(pVar) = pUnkObj;
break;
case VT_BSTR:
V_BSTR(pVar) = SysAllocString(emptyWstr);
V_BSTR(pVar) = SysAllocString(L"");
break;
case VT_SAFEARRAY:
FIXME("Safearray support not yet implemented.\n");
@@ -2517,7 +2420,7 @@ HRESULT CALLBACK IEnumConnections_Next_Proxy(
{
ULONG fetched;
TRACE("(%u, %p %p)\n", cConnections, rgcd, pcFetched);
TRACE("%lu, %p, %p.\n", cConnections, rgcd, pcFetched);
if (!pcFetched)
pcFetched = &fetched;
@@ -2533,7 +2436,7 @@ HRESULT __RPC_STUB IEnumConnections_Next_Stub(
{
HRESULT hr;
TRACE("(%u, %p, %p)\n", cConnections, rgcd, pcFetched);
TRACE("%lu, %p, %p.\n", cConnections, rgcd, pcFetched);
*pcFetched = 0;
hr = IEnumConnections_Next(This, cConnections, rgcd, pcFetched);
@@ -2551,7 +2454,7 @@ HRESULT CALLBACK IEnumConnectionPoints_Next_Proxy(
{
ULONG fetched;
TRACE("(%u, %p %p)\n", cConnections, ppCP, pcFetched);
TRACE("%lu, %p %p.\n", cConnections, ppCP, pcFetched);
if (!pcFetched)
pcFetched = &fetched;
@@ -2567,7 +2470,7 @@ HRESULT __RPC_STUB IEnumConnectionPoints_Next_Stub(
{
HRESULT hr;
TRACE("(%u, %p, %p)\n", cConnections, ppCP, pcFetched);
TRACE("%lu, %p, %p.\n", cConnections, ppCP, pcFetched);
*pcFetched = 0;
hr = IEnumConnectionPoints_Next(This, cConnections, ppCP, pcFetched);
@@ -2582,7 +2485,7 @@ HRESULT CALLBACK IPersistMemory_Load_Proxy(
LPVOID pMem,
ULONG cbSize)
{
TRACE("(%p, %u)\n", pMem, cbSize);
TRACE("%p, %lu.\n", pMem, cbSize);
if (!pMem)
return E_POINTER;
@@ -2595,7 +2498,7 @@ HRESULT __RPC_STUB IPersistMemory_Load_Stub(
BYTE *pMem,
ULONG cbSize)
{
TRACE("(%p, %u)\n", pMem, cbSize);
TRACE("%p, %lu.\n", pMem, cbSize);
return IPersistMemory_Load(This, pMem, cbSize);
}
@@ -2605,7 +2508,7 @@ HRESULT CALLBACK IPersistMemory_Save_Proxy(
BOOL fClearDirty,
ULONG cbSize)
{
TRACE("(%p, %d, %u)\n", pMem, fClearDirty, cbSize);
TRACE("%p, %d, %lu.\n", pMem, fClearDirty, cbSize);
if (!pMem)
return E_POINTER;
@@ -2619,7 +2522,7 @@ HRESULT __RPC_STUB IPersistMemory_Save_Stub(
BOOL fClearDirty,
ULONG cbSize)
{
TRACE("(%p, %d, %u)\n", pMem, fClearDirty, cbSize);
TRACE("%p, %d, %lu.\n", pMem, fClearDirty, cbSize);
return IPersistMemory_Save(This, pMem, fClearDirty, cbSize);
}
@@ -2627,7 +2530,7 @@ void CALLBACK IAdviseSinkEx_OnViewStatusChange_Proxy(
IAdviseSinkEx* This,
DWORD dwViewStatus)
{
TRACE("(%p, 0x%08x)\n", This, dwViewStatus);
TRACE("%p, %#lx.\n", This, dwViewStatus);
IAdviseSinkEx_RemoteOnViewStatusChange_Proxy(This, dwViewStatus);
}
@@ -2635,7 +2538,7 @@ HRESULT __RPC_STUB IAdviseSinkEx_OnViewStatusChange_Stub(
IAdviseSinkEx* This,
DWORD dwViewStatus)
{
TRACE("(%p, 0x%08x)\n", This, dwViewStatus);
TRACE("%p, %#lx.\n", This, dwViewStatus);
IAdviseSinkEx_OnViewStatusChange(This, dwViewStatus);
return S_OK;
}
@@ -2648,7 +2551,7 @@ HRESULT CALLBACK IEnumOleUndoUnits_Next_Proxy(
{
ULONG fetched;
TRACE("(%u, %p %p)\n", cElt, rgElt, pcEltFetched);
TRACE("%lu, %p %p.\n", cElt, rgElt, pcEltFetched);
if (!pcEltFetched)
pcEltFetched = &fetched;
@@ -2664,7 +2567,7 @@ HRESULT __RPC_STUB IEnumOleUndoUnits_Next_Stub(
{
HRESULT hr;
TRACE("(%u, %p, %p)\n", cElt, rgElt, pcEltFetched);
TRACE("%lu, %p, %p.\n", cElt, rgElt, pcEltFetched);
*pcEltFetched = 0;
hr = IEnumOleUndoUnits_Next(This, cElt, rgElt, pcEltFetched);
dll/win32/oleaut32/varformat.c
+99 -84
View File
@@ -44,10 +44,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(variant);
*/
#define LCID_US MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT)
static const WCHAR szPercent_d[] = { '%','d','\0' };
static const WCHAR szPercentZeroTwo_d[] = { '%','0','2','d','\0' };
static const WCHAR szPercentZeroStar_d[] = { '%','0','*','d','\0' };
/******************************************************************************
* Variant-Formats {OLEAUT32}
*
@@ -272,7 +268,6 @@ typedef struct tagFMT_DATE_HEADER
#define FMT_STR_COPY_SKIP 0x41 /* Copy len chars or skip if no char */
/* Named Formats and their tokenised values */
static const WCHAR szGeneralDate[] = { 'G','e','n','e','r','a','l',' ','D','a','t','e','\0' };
static const BYTE fmtGeneralDate[0x0a] =
{
0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -280,7 +275,6 @@ static const BYTE fmtGeneralDate[0x0a] =
FMT_DATE_GENERAL,FMT_GEN_END
};
static const WCHAR szShortDate[] = { 'S','h','o','r','t',' ','D','a','t','e','\0' };
static const BYTE fmtShortDate[0x0a] =
{
0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -288,7 +282,6 @@ static const BYTE fmtShortDate[0x0a] =
FMT_DATE_SHORT,FMT_GEN_END
};
static const WCHAR szMediumDate[] = { 'M','e','d','i','u','m',' ','D','a','t','e','\0' };
static const BYTE fmtMediumDate[0x0a] =
{
0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -296,7 +289,6 @@ static const BYTE fmtMediumDate[0x0a] =
FMT_DATE_MEDIUM,FMT_GEN_END
};
static const WCHAR szLongDate[] = { 'L','o','n','g',' ','D','a','t','e','\0' };
static const BYTE fmtLongDate[0x0a] =
{
0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -304,7 +296,6 @@ static const BYTE fmtLongDate[0x0a] =
FMT_DATE_LONG,FMT_GEN_END
};
static const WCHAR szShortTime[] = { 'S','h','o','r','t',' ','T','i','m','e','\0' };
static const BYTE fmtShortTime[0x0c] =
{
0x0c,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -312,7 +303,6 @@ static const BYTE fmtShortTime[0x0c] =
FMT_DATE_TIME_UNK2,FMT_DATE_TIME_SEP,FMT_DATE_MIN_0,FMT_GEN_END
};
static const WCHAR szMediumTime[] = { 'M','e','d','i','u','m',' ','T','i','m','e','\0' };
static const BYTE fmtMediumTime[0x11] =
{
0x11,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -321,7 +311,6 @@ static const BYTE fmtMediumTime[0x11] =
FMT_GEN_INLINE,0x01,' ','\0',FMT_DATE_AMPM_SYS1,FMT_GEN_END
};
static const WCHAR szLongTime[] = { 'L','o','n','g',' ','T','i','m','e','\0' };
static const BYTE fmtLongTime[0x0d] =
{
0x0a,FMT_TYPE_DATE,sizeof(FMT_SHORT_HEADER),
@@ -329,7 +318,6 @@ static const BYTE fmtLongTime[0x0d] =
FMT_DATE_TIME_SYS,FMT_GEN_END
};
static const WCHAR szTrueFalse[] = { 'T','r','u','e','/','F','a','l','s','e','\0' };
static const BYTE fmtTrueFalse[0x0d] =
{
0x0d,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -337,7 +325,6 @@ static const BYTE fmtTrueFalse[0x0d] =
FMT_NUM_TRUE_FALSE,FMT_GEN_END
};
static const WCHAR szYesNo[] = { 'Y','e','s','/','N','o','\0' };
static const BYTE fmtYesNo[0x0d] =
{
0x0d,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -345,7 +332,6 @@ static const BYTE fmtYesNo[0x0d] =
FMT_NUM_YES_NO,FMT_GEN_END
};
static const WCHAR szOnOff[] = { 'O','n','/','O','f','f','\0' };
static const BYTE fmtOnOff[0x0d] =
{
0x0d,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -353,13 +339,11 @@ static const BYTE fmtOnOff[0x0d] =
FMT_NUM_ON_OFF,FMT_GEN_END
};
static const WCHAR szGeneralNumber[] = { 'G','e','n','e','r','a','l',' ','N','u','m','b','e','r','\0' };
static const BYTE fmtGeneralNumber[sizeof(FMT_HEADER)] =
{
sizeof(FMT_HEADER),FMT_TYPE_GENERAL,sizeof(FMT_HEADER),0x0,0x0,0x0
};
static const WCHAR szCurrency[] = { 'C','u','r','r','e','n','c','y','\0' };
static const BYTE fmtCurrency[0x26] =
{
0x26,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x12,0x0,0x0,
@@ -374,7 +358,6 @@ static const BYTE fmtCurrency[0x26] =
FMT_GEN_END
};
static const WCHAR szFixed[] = { 'F','i','x','e','d','\0' };
static const BYTE fmtFixed[0x11] =
{
0x11,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -382,7 +365,6 @@ static const BYTE fmtFixed[0x11] =
FMT_NUM_COPY_ZERO,0x1,FMT_NUM_DECIMAL,FMT_NUM_COPY_ZERO,0x2,FMT_GEN_END
};
static const WCHAR szStandard[] = { 'S','t','a','n','d','a','r','d','\0' };
static const BYTE fmtStandard[0x11] =
{
0x11,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -390,7 +372,6 @@ static const BYTE fmtStandard[0x11] =
FMT_NUM_COPY_ZERO,0x1,FMT_NUM_DECIMAL,FMT_NUM_COPY_ZERO,0x2,FMT_GEN_END
};
static const WCHAR szPercent[] = { 'P','e','r','c','e','n','t','\0' };
static const BYTE fmtPercent[0x15] =
{
0x15,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -399,7 +380,6 @@ static const BYTE fmtPercent[0x15] =
FMT_GEN_INLINE,0x1,'%','\0',FMT_GEN_END
};
static const WCHAR szScientific[] = { 'S','c','i','e','n','t','i','f','i','c','\0' };
static const BYTE fmtScientific[0x13] =
{
0x13,FMT_TYPE_NUMBER,sizeof(FMT_HEADER),0x0,0x0,0x0,
@@ -416,22 +396,22 @@ typedef struct tagNAMED_FORMAT
/* Format name to tokenised format. Must be kept sorted by name */
static const NAMED_FORMAT VARIANT_NamedFormats[] =
{
{ szCurrency, fmtCurrency },
{ szFixed, fmtFixed },
{ szGeneralDate, fmtGeneralDate },
{ szGeneralNumber, fmtGeneralNumber },
{ szLongDate, fmtLongDate },
{ szLongTime, fmtLongTime },
{ szMediumDate, fmtMediumDate },
{ szMediumTime, fmtMediumTime },
{ szOnOff, fmtOnOff },
{ szPercent, fmtPercent },
{ szScientific, fmtScientific },
{ szShortDate, fmtShortDate },
{ szShortTime, fmtShortTime },
{ szStandard, fmtStandard },
{ szTrueFalse, fmtTrueFalse },
{ szYesNo, fmtYesNo }
{ L"Currency", fmtCurrency },
{ L"Fixed", fmtFixed },
{ L"General Date", fmtGeneralDate },
{ L"General Number", fmtGeneralNumber },
{ L"Long Date", fmtLongDate },
{ L"Long Time", fmtLongTime },
{ L"Medium Date", fmtMediumDate },
{ L"Medium Time", fmtMediumTime },
{ L"On/Off", fmtOnOff },
{ L"Percent", fmtPercent },
{ L"Scientific", fmtScientific },
{ L"Short Date", fmtShortDate },
{ L"Short Time", fmtShortTime },
{ L"Standard", fmtStandard },
{ L"True/False", fmtTrueFalse },
{ L"Yes/No", fmtYesNo }
};
typedef const NAMED_FORMAT *LPCNAMED_FORMAT;
@@ -512,7 +492,7 @@ HRESULT WINAPI VarTokenizeFormatString(LPOLESTR lpszFormat, LPBYTE rgbTok,
DWORD fmt_state = 0;
LPCWSTR pFormat = lpszFormat;
TRACE("(%s,%p,%d,%d,%d,0x%08x,%p)\n", debugstr_w(lpszFormat), rgbTok, cbTok,
TRACE("%s, %p, %d, %d, %d, %#lx, %p.\n", debugstr_w(lpszFormat), rgbTok, cbTok,
nFirstDay, nFirstWeek, lcid, pcbActual);
if (!rgbTok ||
@@ -760,7 +740,7 @@ HRESULT WINAPI VarTokenizeFormatString(LPOLESTR lpszFormat, LPBYTE rgbTok,
TRACE("time sep\n");
}
else if ((*pFormat == 'a' || *pFormat == 'A') &&
!_wcsnicmp(pFormat, szAMPM, ARRAY_SIZE(szAMPM)))
!wcsnicmp(pFormat, szAMPM, ARRAY_SIZE(szAMPM)))
{
/* Date formats: System AM/PM designation
* Other formats: Literal
@@ -983,7 +963,7 @@ HRESULT WINAPI VarTokenizeFormatString(LPOLESTR lpszFormat, LPBYTE rgbTok,
fmt_state &= ~FMT_STATE_OPEN_COPY;
}
else if ((*pFormat == 't' || *pFormat == 'T') &&
!_wcsnicmp(pFormat, szTTTTT, ARRAY_SIZE(szTTTTT)))
!wcsnicmp(pFormat, szTTTTT, ARRAY_SIZE(szTTTTT)))
{
/* Date formats: System time specifier
* Other formats: Literal
@@ -1182,7 +1162,7 @@ static HRESULT VARIANT_FormatNumber(LPVARIANT pVarIn, LPOLESTR lpszFormat,
const BYTE* pToken = NULL;
HRESULT hRes = S_OK;
TRACE("(%s,%s,%p,0x%08x,%p,0x%08x)\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
TRACE("%s, %s, %p, %#lx, %p, %#lx.\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
rgbTok, dwFlags, pbstrOut, lcid);
V_VT(&vString) = VT_EMPTY;
@@ -1415,13 +1395,13 @@ VARIANT_FormatNumber_Bool:
if (exponent < 0)
{
*pBuff++ = '-';
swprintf(pBuff, szPercentZeroStar_d, pToken[1], -exponent);
swprintf(pBuff, ARRAY_SIZE(buff) - (pBuff - buff), L"%0*d", pToken[1], -exponent);
}
else
{
if (*pToken == FMT_NUM_EXP_POS_L || *pToken == FMT_NUM_EXP_POS_U)
*pBuff++ = '+';
swprintf(pBuff, szPercentZeroStar_d, pToken[1], exponent);
swprintf(pBuff, ARRAY_SIZE(buff) - (pBuff - buff), L"%0*d", pToken[1], exponent);
}
while (*pBuff)
pBuff++;
@@ -1590,7 +1570,7 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
const BYTE* pToken = NULL;
HRESULT hRes;
TRACE("(%s,%s,%p,0x%08x,%p,0x%08x)\n", debugstr_variant(pVarIn),
TRACE("%s, %s, %p, %#lx, %p, %#lx.\n", debugstr_variant(pVarIn),
debugstr_w(lpszFormat), rgbTok, dwFlags, pbstrOut, lcid);
V_VT(&vDate) = VT_EMPTY;
@@ -1605,8 +1585,34 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
USHORT usFlags = dwFlags & VARIANT_CALENDAR_HIJRI ? VAR_CALENDAR_HIJRI : 0;
hRes = VariantChangeTypeEx(&vDate, pVarIn, lcid, usFlags, VT_DATE);
/* 31809.40 and similar are treated as invalid by coercion functions but
* it simply is a DATE in string form as far as VarFormat is concerned
*/
if (FAILED(hRes))
return hRes;
{
if (V_TYPE(pVarIn) == VT_BSTR)
{
DATE out;
OLECHAR *endptr = NULL;
/* Try consume the string with wcstod */
double tmp = wcstod(V_BSTR(pVarIn), &endptr);
/* Not a double in string form */
if (*endptr)
return hRes;
hRes = VarDateFromR8(tmp, &out);
if (FAILED(hRes))
return hRes;
V_VT(&vDate) = VT_DATE;
V_DATE(&vDate) = out;
}
else
return hRes;
}
dateHeader = (FMT_DATE_HEADER*)(rgbTok + FmtGetPositive(header));
}
@@ -1697,12 +1703,12 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
break;
case FMT_DATE_DAY:
szPrintFmt = szPercent_d;
szPrintFmt = L"%d";
dwVal = udate.st.wDay;
break;
case FMT_DATE_DAY_0:
szPrintFmt = szPercentZeroTwo_d;
szPrintFmt = L"%02d";
dwVal = udate.st.wDay;
break;
@@ -1736,7 +1742,7 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
break;
case FMT_DATE_DAY_WEEK:
szPrintFmt = szPercent_d;
szPrintFmt = L"%d";
if (pToken[1])
dwVal = udate.st.wDayOfWeek + 2 - pToken[1];
else
@@ -1749,19 +1755,19 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
break;
case FMT_DATE_WEEK_YEAR:
szPrintFmt = szPercent_d;
szPrintFmt = L"%d";
dwVal = udate.wDayOfYear / 7 + 1;
pToken += 2;
FIXME("Ignoring nFirstDay of %d, nFirstWeek of %d\n", pToken[0], pToken[1]);
break;
case FMT_DATE_MON:
szPrintFmt = szPercent_d;
szPrintFmt = L"%d";
dwVal = udate.st.wMonth;
break;
case FMT_DATE_MON_0:
szPrintFmt = szPercentZeroTwo_d;
szPrintFmt = L"%02d";
dwVal = udate.st.wMonth;
break;
@@ -1780,58 +1786,58 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
break;
case FMT_DATE_YEAR_DOY:
szPrintFmt = szPercent_d;
szPrintFmt = L"%d";
dwVal = udate.wDayOfYear;
break;
case FMT_DATE_YEAR_0:
szPrintFmt = szPercentZeroTwo_d;
szPrintFmt = L"%02d";
dwVal = udate.st.wYear % 100;
break;
case FMT_DATE_YEAR_LONG:
szPrintFmt = szPercent_d;
szPrintFmt = L"%d";
dwVal = udate.st.wYear;
break;
case FMT_DATE_MIN:
szPrintFmt = szPercent_d;
szPrintFmt = L"%d";
dwVal = udate.st.wMinute;
break;
case FMT_DATE_MIN_0:
szPrintFmt = szPercentZeroTwo_d;
szPrintFmt = L"%02d";
dwVal = udate.st.wMinute;
break;
case FMT_DATE_SEC:
szPrintFmt = szPercent_d;
szPrintFmt = L"%d";
dwVal = udate.st.wSecond;
break;
case FMT_DATE_SEC_0:
szPrintFmt = szPercentZeroTwo_d;
szPrintFmt = L"%02d";
dwVal = udate.st.wSecond;
break;
case FMT_DATE_HOUR:
szPrintFmt = szPercent_d;
szPrintFmt = L"%d";
dwVal = udate.st.wHour;
break;
case FMT_DATE_HOUR_0:
case FMT_DATE_TIME_UNK2:
szPrintFmt = szPercentZeroTwo_d;
szPrintFmt = L"%02d";
dwVal = udate.st.wHour;
break;
case FMT_DATE_HOUR_12:
szPrintFmt = szPercent_d;
szPrintFmt = L"%d";
dwVal = udate.st.wHour ? udate.st.wHour > 12 ? udate.st.wHour - 12 : udate.st.wHour : 12;
break;
case FMT_DATE_HOUR_12_0:
szPrintFmt = szPercentZeroTwo_d;
szPrintFmt = L"%02d";
dwVal = udate.st.wHour ? udate.st.wHour > 12 ? udate.st.wHour - 12 : udate.st.wHour : 12;
break;
@@ -1894,7 +1900,7 @@ static HRESULT VARIANT_FormatDate(LPVARIANT pVarIn, LPOLESTR lpszFormat,
}
else if (szPrintFmt)
{
swprintf(pBuff, szPrintFmt, dwVal);
swprintf(pBuff, ARRAY_SIZE(buff) - (pBuff - buff), szPrintFmt, dwVal);
while (*pBuff)
pBuff++;
}
@@ -1918,7 +1924,7 @@ static HRESULT VARIANT_FormatString(LPVARIANT pVarIn, LPOLESTR lpszFormat,
LPBYTE rgbTok, ULONG dwFlags,
BSTR *pbstrOut, LCID lcid)
{
static WCHAR szEmpty[] = { '\0' };
static WCHAR szEmpty[] = L"";
WCHAR buff[256], *pBuff = buff;
WCHAR *pSrc;
FMT_HEADER *header = (FMT_HEADER*)rgbTok;
@@ -1929,7 +1935,7 @@ static HRESULT VARIANT_FormatString(LPVARIANT pVarIn, LPOLESTR lpszFormat,
BOOL bUpper = FALSE;
HRESULT hRes = S_OK;
TRACE("%s,%s,%p,0x%08x,%p,0x%08x)\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
TRACE("%s, %s, %p, %#lx, %p, %#lx.\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
rgbTok, dwFlags, pbstrOut, lcid);
V_VT(&vStr) = VT_EMPTY;
@@ -2055,7 +2061,7 @@ HRESULT WINAPI VarFormatFromTokens(LPVARIANT pVarIn, LPOLESTR lpszFormat,
VARIANT vTmp;
HRESULT hres;
TRACE("(%p,%s,%p,%x,%p,0x%08x)\n", pVarIn, debugstr_w(lpszFormat),
TRACE("%p, %s, %p, %#lx, %p, %#lx.\n", pVarIn, debugstr_w(lpszFormat),
rgbTok, dwFlags, pbstrOut, lcid);
if (!pbstrOut)
@@ -2142,7 +2148,7 @@ HRESULT WINAPI VarFormat(LPVARIANT pVarIn, LPOLESTR lpszFormat,
BYTE buff[256];
HRESULT hres;
TRACE("(%s,%s,%d,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
TRACE("%s, %s, %d, %d, %#lx, %p.\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
nFirstDay, nFirstWeek, dwFlags, pbstrOut);
if (!pbstrOut)
@@ -2154,7 +2160,7 @@ HRESULT WINAPI VarFormat(LPVARIANT pVarIn, LPOLESTR lpszFormat,
if (SUCCEEDED(hres))
hres = VarFormatFromTokens(pVarIn, lpszFormat, buff, dwFlags,
pbstrOut, LOCALE_USER_DEFAULT);
TRACE("returning 0x%08x, %s\n", hres, debugstr_w(*pbstrOut));
TRACE("returning %#lx, %s\n", hres, debugstr_w(*pbstrOut));
return hres;
}
@@ -2189,10 +2195,10 @@ HRESULT WINAPI VarFormat(LPVARIANT pVarIn, LPOLESTR lpszFormat,
*/
HRESULT WINAPI VarFormatDateTime(LPVARIANT pVarIn, INT nFormat, ULONG dwFlags, BSTR *pbstrOut)
{
static WCHAR szEmpty[] = { '\0' };
static WCHAR szEmpty[] = L"";
const BYTE* lpFmt = NULL;
TRACE("%s,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), nFormat, dwFlags, pbstrOut);
TRACE("%s, %d, %#lx, %p.\n", debugstr_variant(pVarIn), nFormat, dwFlags, pbstrOut);
if (!pVarIn || !pbstrOut || nFormat < 0 || nFormat > 4)
return E_INVALIDARG;
@@ -2244,7 +2250,7 @@ HRESULT WINAPI VarFormatNumber(LPVARIANT pVarIn, INT nDigits, INT nLeading, INT
HRESULT hRet;
VARIANT vStr;
TRACE("(%s,%d,%d,%d,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), nDigits, nLeading,
TRACE("%s, %d, %d, %d, %d, %#lx, %p.\n", debugstr_variant(pVarIn), nDigits, nLeading,
nParens, nGrouping, dwFlags, pbstrOut);
if (!pVarIn || !pbstrOut || nDigits > 9)
@@ -2345,13 +2351,11 @@ HRESULT WINAPI VarFormatNumber(LPVARIANT pVarIn, INT nDigits, INT nLeading, INT
HRESULT WINAPI VarFormatPercent(LPVARIANT pVarIn, INT nDigits, INT nLeading, INT nParens,
INT nGrouping, ULONG dwFlags, BSTR *pbstrOut)
{
static const WCHAR szPercent[] = { '%','\0' };
static const WCHAR szPercentBracket[] = { '%',')','\0' };
WCHAR buff[256];
HRESULT hRet;
VARIANT vDbl;
TRACE("(%s,%d,%d,%d,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), nDigits, nLeading,
TRACE("%s, %d, %d, %d, %d, %#lx, %p.\n", debugstr_variant(pVarIn), nDigits, nLeading,
nParens, nGrouping, dwFlags, pbstrOut);
if (!pVarIn || !pbstrOut || nDigits > 9)
@@ -2382,7 +2386,7 @@ HRESULT WINAPI VarFormatPercent(LPVARIANT pVarIn, INT nDigits, INT nLeading, INT
dwLen -= bBracket;
memcpy(buff, *pbstrOut, dwLen * sizeof(WCHAR));
lstrcpyW(buff + dwLen, bBracket ? szPercentBracket : szPercent);
lstrcpyW(buff + dwLen, bBracket ? L"%)" : L"%");
SysFreeString(*pbstrOut);
*pbstrOut = SysAllocString(buff);
if (!*pbstrOut)
@@ -2423,8 +2427,9 @@ HRESULT WINAPI VarFormatCurrency(LPVARIANT pVarIn, INT nDigits, INT nLeading,
{
HRESULT hRet;
VARIANT vStr;
CY cy;
TRACE("(%s,%d,%d,%d,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), nDigits, nLeading,
TRACE("%s, %d, %d, %d, %d, %#lx, %p.\n", debugstr_variant(pVarIn), nDigits, nLeading,
nParens, nGrouping, dwFlags, pbstrOut);
if (!pVarIn || !pbstrOut || nDigits > 9)
@@ -2432,8 +2437,18 @@ HRESULT WINAPI VarFormatCurrency(LPVARIANT pVarIn, INT nDigits, INT nLeading,
*pbstrOut = NULL;
V_VT(&vStr) = VT_EMPTY;
hRet = VariantCopyInd(&vStr, pVarIn);
if (V_VT(pVarIn) == VT_BSTR || V_VT(pVarIn) == (VT_BSTR | VT_BYREF))
{
hRet = VarCyFromStr(V_ISBYREF(pVarIn) ? *V_BSTRREF(pVarIn) : V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &cy);
if (FAILED(hRet)) return hRet;
V_VT(&vStr) = VT_CY;
V_CY(&vStr) = cy;
}
else
{
V_VT(&vStr) = VT_EMPTY;
hRet = VariantCopyInd(&vStr, pVarIn);
}
if (SUCCEEDED(hRet))
hRet = VariantChangeTypeEx(&vStr, &vStr, LOCALE_USER_DEFAULT, 0, VT_BSTR);
@@ -2523,7 +2538,7 @@ HRESULT WINAPI VarMonthName(INT iMonth, INT fAbbrev, ULONG dwFlags, BSTR *pbstrO
return E_INVALIDARG;
if (dwFlags)
FIXME("Does not support dwFlags 0x%x, ignoring.\n", dwFlags);
FIXME("Does not support flags %#lx, ignoring.\n", dwFlags);
if (fAbbrev)
localeValue = LOCALE_SABBREVMONTHNAME1 + iMonth - 1;
@@ -2532,7 +2547,7 @@ HRESULT WINAPI VarMonthName(INT iMonth, INT fAbbrev, ULONG dwFlags, BSTR *pbstrO
size = GetLocaleInfoW(LOCALE_USER_DEFAULT,localeValue, NULL, 0);
if (!size) {
ERR("GetLocaleInfo 0x%x failed.\n", localeValue);
ERR("GetLocaleInfo %#lx failed.\n", localeValue);
return HRESULT_FROM_WIN32(GetLastError());
}
*pbstrOut = SysAllocStringLen(NULL,size - 1);
@@ -2540,7 +2555,7 @@ HRESULT WINAPI VarMonthName(INT iMonth, INT fAbbrev, ULONG dwFlags, BSTR *pbstrO
return E_OUTOFMEMORY;
size = GetLocaleInfoW(LOCALE_USER_DEFAULT,localeValue, *pbstrOut, size);
if (!size) {
ERR("GetLocaleInfo of 0x%x failed in 2nd stage?!\n", localeValue);
ERR("GetLocaleInfo of %#lx failed in 2nd stage?!\n", localeValue);
SysFreeString(*pbstrOut);
return HRESULT_FROM_WIN32(GetLastError());
}
@@ -2580,7 +2595,7 @@ HRESULT WINAPI VarWeekdayName(INT iWeekday, INT fAbbrev, INT iFirstDay,
return E_INVALIDARG;
if (dwFlags)
FIXME("Does not support dwFlags 0x%x, ignoring.\n", dwFlags);
FIXME("Does not support flags %#lx, ignoring.\n", dwFlags);
/* If we have to use the default firstDay, find which one it is */
if (iFirstDay == 0) {
@@ -2589,7 +2604,7 @@ HRESULT WINAPI VarWeekdayName(INT iWeekday, INT fAbbrev, INT iFirstDay,
size = GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue,
(LPWSTR)&firstDay, sizeof(firstDay) / sizeof(WCHAR));
if (!size) {
ERR("GetLocaleInfo 0x%x failed.\n", localeValue);
ERR("GetLocaleInfo %#lx failed.\n", localeValue);
return HRESULT_FROM_WIN32(GetLastError());
}
iFirstDay = firstDay + 2;
@@ -2602,7 +2617,7 @@ HRESULT WINAPI VarWeekdayName(INT iWeekday, INT fAbbrev, INT iFirstDay,
/* Determine the size of the data, allocate memory and retrieve the data */
size = GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue, NULL, 0);
if (!size) {
ERR("GetLocaleInfo 0x%x failed.\n", localeValue);
ERR("GetLocaleInfo %#lx failed.\n", localeValue);
return HRESULT_FROM_WIN32(GetLastError());
}
*pbstrOut = SysAllocStringLen(NULL, size - 1);
@@ -2610,7 +2625,7 @@ HRESULT WINAPI VarWeekdayName(INT iWeekday, INT fAbbrev, INT iFirstDay,
return E_OUTOFMEMORY;
size = GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue, *pbstrOut, size);
if (!size) {
ERR("GetLocaleInfo 0x%x failed in 2nd stage?!\n", localeValue);
ERR("GetLocaleInfo %#lx failed in 2nd stage?!\n", localeValue);
SysFreeString(*pbstrOut);
return HRESULT_FROM_WIN32(GetLastError());
}
dll/win32/oleaut32/variant.c
+255 -195
View File
@@ -30,9 +30,6 @@
#include <stdarg.h>
#define COBJMACROS
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
@@ -42,14 +39,6 @@
WINE_DEFAULT_DEBUG_CHANNEL(variant);
static CRITICAL_SECTION cache_cs;
static CRITICAL_SECTION_DEBUG critsect_debug =
{
0, 0, &cache_cs,
{ &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
0, 0, { (DWORD_PTR)(__FILE__ ": cache_cs") }
};
static CRITICAL_SECTION cache_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
/* Convert a variant from one type to another */
static inline HRESULT VARIANT_Coerce(VARIANTARG* pd, LCID lcid, USHORT wFlags,
@@ -59,7 +48,7 @@ static inline HRESULT VARIANT_Coerce(VARIANTARG* pd, LCID lcid, USHORT wFlags,
VARTYPE vtFrom = V_TYPE(ps);
DWORD dwFlags = 0;
TRACE("(%s,0x%08x,0x%04x,%s,%s)\n", debugstr_variant(pd), lcid, wFlags,
TRACE("%s, %#lx, 0x%04x, %s, %s.\n", debugstr_variant(pd), lcid, wFlags,
debugstr_variant(ps), debugstr_vt(vt));
if (vt == VT_BSTR || vtFrom == VT_BSTR)
@@ -436,13 +425,13 @@ static inline HRESULT VARIANT_Coerce(VARIANTARG* pd, LCID lcid, USHORT wFlags,
{
case VT_EMPTY:
case VT_BOOL:
DEC_SIGNSCALE(&V_DECIMAL(pd)) = SIGNSCALE(DECIMAL_POS,0);
DEC_HI32(&V_DECIMAL(pd)) = 0;
DEC_MID32(&V_DECIMAL(pd)) = 0;
V_DECIMAL(pd).sign = DECIMAL_POS;
V_DECIMAL(pd).scale = 0;
V_DECIMAL(pd).Hi32 = 0;
/* VarDecFromBool() coerces to -1/0, ChangeTypeEx() coerces to 1/0.
* VT_NULL and VT_EMPTY always give a 0 value.
*/
DEC_LO32(&V_DECIMAL(pd)) = vtFrom == VT_BOOL && V_BOOL(ps) ? 1 : 0;
V_DECIMAL(pd).Lo64 = vtFrom == VT_BOOL && V_BOOL(ps) ? 1 : 0;
return S_OK;
case VT_I1: return VarDecFromI1(V_I1(ps), &V_DECIMAL(pd));
case VT_I2: return VarDecFromI2(V_I2(ps), &V_DECIMAL(pd));
@@ -514,13 +503,13 @@ static inline HRESULT VARIANT_CoerceArray(VARIANTARG* pd, VARIANTARG* ps, VARTYP
static HRESULT VARIANT_FetchDispatchValue(LPVARIANT pvDispatch, LPVARIANT pValue)
{
DISPPARAMS params = { 0 };
HRESULT hres;
static DISPPARAMS emptyParams = { NULL, NULL, 0, 0 };
if ((V_VT(pvDispatch) & VT_TYPEMASK) == VT_DISPATCH) {
if (NULL == V_DISPATCH(pvDispatch)) return DISP_E_TYPEMISMATCH;
hres = IDispatch_Invoke(V_DISPATCH(pvDispatch), DISPID_VALUE, &IID_NULL,
LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &emptyParams, pValue,
LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &params, pValue,
NULL, NULL);
} else {
hres = DISP_E_TYPEMISMATCH;
@@ -553,24 +542,13 @@ static inline HRESULT VARIANT_ValidateType(VARTYPE vt)
/******************************************************************************
* VariantInit [OLEAUT32.8]
*
* Initialise a variant.
*
* PARAMS
* pVarg [O] Variant to initialise
*
* RETURNS
* Nothing.
*
* NOTES
* This function simply sets the type of the variant to VT_EMPTY. It does not
* free any existing value, use VariantClear() for that.
* Since Windows 8.1 whole structure is initialized, before that only type field was reset to VT_EMPTY.
*/
void WINAPI VariantInit(VARIANTARG* pVarg)
{
TRACE("(%p)\n", pVarg);
TRACE("(%p)\n", pVarg);
/* Win8.1 zeroes whole struct. Previous implementations don't set any other fields. */
V_VT(pVarg) = VT_EMPTY;
memset(pVarg, 0, sizeof(*pVarg));
}
HRESULT VARIANT_ClearInd(VARIANTARG *pVarg)
@@ -607,11 +585,11 @@ HRESULT VARIANT_ClearInd(VARIANTARG *pVarg)
case VT_RECORD:
case VT_RECORD | VT_BYREF:
{
struct __tagBRECORD* pBr = &V_UNION(pVarg,brecVal);
if (pBr->pRecInfo)
IRecordInfo *rec_info = V_RECORDINFO(pVarg);
if (rec_info)
{
IRecordInfo_RecordClear(pBr->pRecInfo, pBr->pvRecord);
IRecordInfo_Release(pBr->pRecInfo);
IRecordInfo_RecordClear(rec_info, V_RECORD(pVarg));
IRecordInfo_Release(rec_info);
}
break;
}
@@ -667,11 +645,11 @@ HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG* pVarg)
}
else if (V_VT(pVarg) == VT_RECORD)
{
struct __tagBRECORD* pBr = &V_UNION(pVarg,brecVal);
if (pBr->pRecInfo)
IRecordInfo *rec_info = V_RECORDINFO(pVarg);
if (rec_info)
{
IRecordInfo_RecordClear(pBr->pRecInfo, pBr->pvRecord);
IRecordInfo_Release(pBr->pRecInfo);
IRecordInfo_RecordClear(rec_info, V_RECORD(pVarg));
IRecordInfo_Release(rec_info);
}
}
else if (V_VT(pVarg) == VT_DISPATCH ||
@@ -689,32 +667,30 @@ HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG* pVarg)
/******************************************************************************
* Copy an IRecordInfo object contained in a variant.
*/
static HRESULT VARIANT_CopyIRecordInfo(VARIANT *dest, VARIANT *src)
static HRESULT VARIANT_CopyIRecordInfo(VARIANT *dest, const VARIANT *src)
{
struct __tagBRECORD *dest_rec = &V_UNION(dest, brecVal);
struct __tagBRECORD *src_rec = &V_UNION(src, brecVal);
IRecordInfo *src_info = V_RECORDINFO(src);
HRESULT hr = S_OK;
ULONG size;
if (!src_rec->pRecInfo)
if (!src_info)
{
if (src_rec->pvRecord) return E_INVALIDARG;
if (V_RECORD(src)) return E_INVALIDARG;
return S_OK;
}
hr = IRecordInfo_GetSize(src_rec->pRecInfo, &size);
hr = IRecordInfo_GetSize(src_info, &size);
if (FAILED(hr)) return hr;
/* This could look cleaner if only RecordCreate() was used, but native doesn't use it.
Memory should be allocated in a same way as RecordCreate() does, so RecordDestroy()
/* Windows does not use RecordCreate() here, memory should be allocated in compatible way so RecordDestroy()
could free it later. */
dest_rec->pvRecord = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
if (!dest_rec->pvRecord) return E_OUTOFMEMORY;
V_RECORD(dest) = CoTaskMemAlloc(size);
if (!V_RECORD(dest)) return E_OUTOFMEMORY;
if (size)
memset(V_RECORD(dest), 0, size);
dest_rec->pRecInfo = src_rec->pRecInfo;
IRecordInfo_AddRef(src_rec->pRecInfo);
return IRecordInfo_RecordCopy(src_rec->pRecInfo, src_rec->pvRecord, dest_rec->pvRecord);
IRecordInfo_AddRef(V_RECORDINFO(dest) = src_info);
return IRecordInfo_RecordCopy(src_info, V_RECORD(src), V_RECORD(dest));
}
/******************************************************************************
@@ -745,7 +721,7 @@ static HRESULT VARIANT_CopyIRecordInfo(VARIANT *dest, VARIANT *src)
* reference count increased using IUnknown_AddRef().
* - For all by-reference types, only the referencing pointer is copied.
*/
HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, VARIANTARG* pvargSrc)
HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, const VARIANTARG* pvargSrc)
{
HRESULT hres = S_OK;
@@ -844,9 +820,10 @@ static inline size_t VARIANT_DataSize(const VARIANT* pv)
* pvargDest is always cleared using VariantClear() before pvargSrc is copied
* to it. If clearing pvargDest fails, so does this function.
*/
HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc)
HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, const VARIANTARG* pvargSrc)
{
VARIANTARG vTmp, *pSrc = pvargSrc;
const VARIANTARG *pSrc = pvargSrc;
VARIANTARG vTmp;
VARTYPE vt;
HRESULT hres = S_OK;
@@ -920,7 +897,7 @@ HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc)
}
else if (V_VT(pSrc) == (VT_DECIMAL|VT_BYREF))
{
memcpy(&DEC_SCALE(&V_DECIMAL(pvargDest)), &DEC_SCALE(V_DECIMALREF(pSrc)),
memcpy(&V_DECIMAL(pvargDest).scale, &V_DECIMALREF(pSrc)->scale,
sizeof(DECIMAL) - sizeof(USHORT));
}
else
@@ -934,9 +911,9 @@ HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc)
VariantCopyInd_Return:
if (pSrc != pvargSrc)
VariantClear(pSrc);
VariantClear(&vTmp);
TRACE("returning 0x%08x, %s\n", hres, debugstr_variant(pvargDest));
TRACE("returning %#lx, %s\n", hres, debugstr_variant(pvargDest));
return hres;
}
@@ -959,7 +936,7 @@ VariantCopyInd_Return:
* The LCID used for the conversion is LOCALE_USER_DEFAULT.
* See VariantChangeTypeEx.
*/
HRESULT WINAPI DECLSPEC_HOTPATCH VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
HRESULT WINAPI DECLSPEC_HOTPATCH VariantChangeType(VARIANTARG* pvargDest, const VARIANTARG* pvargSrc,
USHORT wFlags, VARTYPE vt)
{
return VariantChangeTypeEx( pvargDest, pvargSrc, LOCALE_USER_DEFAULT, wFlags, vt );
@@ -985,12 +962,12 @@ HRESULT WINAPI DECLSPEC_HOTPATCH VariantChangeType(VARIANTARG* pvargDest, VARIAN
* pvargDest and pvargSrc can point to the same variant to perform an in-place
* conversion. If the conversion is successful, pvargSrc will be freed.
*/
HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, const VARIANTARG* pvargSrc,
LCID lcid, USHORT wFlags, VARTYPE vt)
{
HRESULT res = S_OK;
TRACE("(%s,%s,0x%08x,0x%04x,%s)\n", debugstr_variant(pvargDest),
TRACE("%s, %s, %#lx, 0x%04x, %s.\n", debugstr_variant(pvargDest),
debugstr_variant(pvargSrc), lcid, wFlags, debugstr_vt(vt));
if (vt == VT_CLSID)
@@ -1039,7 +1016,7 @@ HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
}
}
TRACE("returning 0x%08x, %s\n", res, debugstr_variant(pvargDest));
TRACE("returning %#lx, %s\n", res, debugstr_variant(pvargDest));
return res;
}
@@ -1123,11 +1100,11 @@ static HRESULT VARIANT_RollUdate(UDATE *lpUd)
if (iYear > 9999 || iYear < -9999)
return E_INVALIDARG; /* Invalid value */
/* Year 0 to 29 are treated as 2000 + year */
if (iYear >= 0 && iYear < 30)
/* Years 0 to 49 are treated as 2000 + year, see also VARIANT_MakeDate() */
if (0 <= iYear && iYear <= 49)
iYear += 2000;
/* Remaining years < 100 are treated as 1900 + year */
else if (iYear >= 30 && iYear < 100)
/* Remaining years 50 to 99 are treated as 1900 + year */
else if (50 <= iYear && iYear <= 99)
iYear += 1900;
iMinute += iSecond / 60;
@@ -1347,7 +1324,7 @@ HRESULT WINAPI VarDateFromUdateEx(UDATE *pUdateIn, LCID lcid, ULONG dwFlags, DAT
UDATE ud;
double dateVal = 0;
TRACE("(%p->%d/%d/%d %d:%d:%d:%d %d %d,0x%08x,0x%08x,%p)\n", pUdateIn,
TRACE("%p, %d/%d/%d, %d:%d:%d:%d, %#x, %d, %#lx, %#lx, %p.\n", pUdateIn,
pUdateIn->st.wMonth, pUdateIn->st.wDay, pUdateIn->st.wYear,
pUdateIn->st.wHour, pUdateIn->st.wMinute, pUdateIn->st.wSecond,
pUdateIn->st.wMilliseconds, pUdateIn->st.wDayOfWeek,
@@ -1356,7 +1333,7 @@ HRESULT WINAPI VarDateFromUdateEx(UDATE *pUdateIn, LCID lcid, ULONG dwFlags, DAT
if (lcid != MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT))
FIXME("lcid possibly not handled, treating as en-us\n");
if (dwFlags & ~(VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY))
FIXME("unsupported flags: %x\n", dwFlags);
FIXME("unsupported flags: %lx\n", dwFlags);
ud = *pUdateIn;
@@ -1434,7 +1411,7 @@ HRESULT WINAPI VarUdateFromDate(DATE dateIn, ULONG dwFlags, UDATE *lpUdate)
double datePart, timePart;
int julianDays;
TRACE("(%g,0x%08x,%p)\n", dateIn, dwFlags, lpUdate);
TRACE("%g, %#lx, %p.\n", dateIn, dwFlags, lpUdate);
if (dateIn <= (DATE_MIN - 1.0) || dateIn >= (DATE_MAX + 1.0))
return E_INVALIDARG;
@@ -1506,36 +1483,34 @@ HRESULT WINAPI VarUdateFromDate(DATE dateIn, ULONG dwFlags, UDATE *lpUdate)
return S_OK;
}
/* The localised characters that make up a valid number */
typedef struct tagVARIANT_NUMBER_CHARS
{
WCHAR cNegativeSymbol;
WCHAR cPositiveSymbol;
WCHAR cDecimalPoint;
WCHAR cDigitSeparator;
DWORD sCurrencyLen;
WCHAR sCurrency[8];
WCHAR cCurrencyDecimalPoint;
WCHAR cCurrencyDigitSeparator;
} VARIANT_NUMBER_CHARS;
#define GET_NUMBER_TEXT(fld,name) \
buff[0] = 0; \
if (!GetLocaleInfoW(lcid, lctype|fld, buff, 2)) \
if (!GetLocaleInfoW(lcid, lctype|fld, buff, ARRAY_SIZE(buff))) \
WARN("buffer too small for " #fld "\n"); \
else \
if (buff[0]) lpChars->name = buff[0]; \
TRACE("lcid 0x%x, " #name "=%d '%c'\n", lcid, lpChars->name, lpChars->name)
TRACE("lcid 0x%lx, " #name "=%s\n", lcid, wine_dbgstr_wn(&lpChars->name, 1))
/* Get the valid number characters for an lcid */
static void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS *lpChars, LCID lcid, DWORD dwFlags)
{
static const VARIANT_NUMBER_CHARS defaultChars = { '-','+','.',',','$',0,'.',',' };
static VARIANT_NUMBER_CHARS lastChars;
static LCID lastLcid = -1;
static DWORD lastFlags = 0;
static const VARIANT_NUMBER_CHARS defaultChars = { '-','+','.',0,1,{'$',0},0,',' };
LCTYPE lctype = dwFlags & LOCALE_NOUSEROVERRIDE;
WCHAR buff[4];
/* To make caching thread-safe, a critical section is needed */
EnterCriticalSection(&cache_cs);
/* Asking for default locale entries is very expensive: It is a registry
server call. So cache one locally, as Microsoft does it too */
if(lcid == lastLcid && dwFlags == lastFlags)
{
memcpy(lpChars, &lastChars, sizeof(defaultChars));
LeaveCriticalSection(&cache_cs);
return;
}
memcpy(lpChars, &defaultChars, sizeof(defaultChars));
GET_NUMBER_TEXT(LOCALE_SNEGATIVESIGN, cNegativeSymbol);
GET_NUMBER_TEXT(LOCALE_SPOSITIVESIGN, cPositiveSymbol);
@@ -1544,22 +1519,16 @@ static void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS *lpChars, LCID
GET_NUMBER_TEXT(LOCALE_SMONDECIMALSEP, cCurrencyDecimalPoint);
GET_NUMBER_TEXT(LOCALE_SMONTHOUSANDSEP, cCurrencyDigitSeparator);
/* Local currency symbols are often 2 characters */
lpChars->cCurrencyLocal2 = '\0';
switch(GetLocaleInfoW(lcid, lctype|LOCALE_SCURRENCY, buff, ARRAY_SIZE(buff)))
if (!GetLocaleInfoW(lcid, lctype|LOCALE_SCURRENCY, lpChars->sCurrency, ARRAY_SIZE(lpChars->sCurrency)))
{
case 3: lpChars->cCurrencyLocal2 = buff[1]; /* Fall through */
case 2: lpChars->cCurrencyLocal = buff[0];
break;
default: WARN("buffer too small for LOCALE_SCURRENCY\n");
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
WARN("buffer too small for LOCALE_SCURRENCY\n");
*lpChars->sCurrency = 0;
}
TRACE("lcid 0x%x, cCurrencyLocal =%d,%d '%c','%c'\n", lcid, lpChars->cCurrencyLocal,
lpChars->cCurrencyLocal2, lpChars->cCurrencyLocal, lpChars->cCurrencyLocal2);
memcpy(&lastChars, lpChars, sizeof(defaultChars));
lastLcid = lcid;
lastFlags = dwFlags;
LeaveCriticalSection(&cache_cs);
if (!*lpChars->sCurrency)
wcscpy(lpChars->sCurrency, L"$");
lpChars->sCurrencyLen = wcslen(lpChars->sCurrency);
TRACE("lcid %#lx, sCurrency %lu %s\n", lcid, lpChars->sCurrencyLen, wine_dbgstr_w(lpChars->sCurrency));
}
/* Number Parsing States */
@@ -1571,6 +1540,11 @@ static void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS *lpChars, LCID
#define B_PROCESSING_HEX 0x20
#define B_PROCESSING_OCT 0x40
static inline BOOL is_digit(WCHAR c)
{
return '0' <= c && c <= '9';
}
/**********************************************************************
* VarParseNumFromStr [OLEAUT32.46]
*
@@ -1601,7 +1575,7 @@ static void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS *lpChars, LCID
* - I am unsure if this function should parse non-Arabic (e.g. Thai)
* numerals, so this has not been implemented.
*/
HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
HRESULT WINAPI VarParseNumFromStr(const OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
NUMPARSE *pNumprs, BYTE *rgbDig)
{
VARIANT_NUMBER_CHARS chars;
@@ -1609,8 +1583,9 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
DWORD dwState = B_EXPONENT_START|B_INEXACT_ZEROS;
int iMaxDigits = ARRAY_SIZE(rgbTmp);
int cchUsed = 0;
OLECHAR cDigitSeparator2;
TRACE("(%s,%d,0x%08x,%p,%p)\n", debugstr_w(lpszStr), lcid, dwFlags, pNumprs, rgbDig);
TRACE("%s, %#lx, %#lx, %p, %p.\n", debugstr_w(lpszStr), lcid, dwFlags, pNumprs, rgbDig);
if (!pNumprs || !rgbDig)
return E_INVALIDARG;
@@ -1628,11 +1603,42 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
return DISP_E_TYPEMISMATCH;
VARIANT_GetLocalisedNumberChars(&chars, lcid, dwFlags);
if (chars.cDigitSeparator == chars.cDecimalPoint)
/* The decimal point completely masks the digit separator */
chars.cDigitSeparator = 0;
/* Setting the thousands separator to a non-breaking space implies regular
* spaces are allowed too. But the converse is not true.
*/
cDigitSeparator2 = chars.cDigitSeparator == 0xa0 ? ' ' : 0;
/* First consume all the leading symbols and space from the string */
while (1)
{
if (pNumprs->dwInFlags & NUMPRS_LEADING_WHITE && iswspace(*lpszStr))
if (pNumprs->dwInFlags & NUMPRS_DECIMAL &&
(*lpszStr == chars.cDecimalPoint ||
*lpszStr == chars.cCurrencyDecimalPoint))
{
pNumprs->dwOutFlags |= NUMPRS_DECIMAL;
if (*lpszStr == chars.cCurrencyDecimalPoint &&
chars.cDecimalPoint != chars.cCurrencyDecimalPoint)
pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
cchUsed++;
lpszStr++;
/* If we have no digits so far, skip leading zeros */
if (!pNumprs->cDig)
{
while (*lpszStr == '0')
{
dwState |= B_LEADING_ZERO;
cchUsed++;
lpszStr++;
pNumprs->nPwr10--;
}
}
break;
}
else if (pNumprs->dwInFlags & NUMPRS_LEADING_WHITE && iswspace(*lpszStr))
{
pNumprs->dwOutFlags |= NUMPRS_LEADING_WHITE;
do
@@ -1641,6 +1647,17 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
lpszStr++;
} while (iswspace(*lpszStr));
}
else if (pNumprs->dwInFlags & NUMPRS_THOUSANDS &&
((chars.cDigitSeparator && *lpszStr == chars.cDigitSeparator) ||
(cDigitSeparator2 && *lpszStr == cDigitSeparator2)))
{
return DISP_E_TYPEMISMATCH; /* Not allowed before the first digit */
}
else if ((pNumprs->dwInFlags & (NUMPRS_THOUSANDS|NUMPRS_CURRENCY)) == (NUMPRS_THOUSANDS|NUMPRS_CURRENCY) &&
chars.cCurrencyDigitSeparator && *lpszStr == chars.cCurrencyDigitSeparator)
{
return DISP_E_TYPEMISMATCH; /* Not allowed before the first digit */
}
else if (pNumprs->dwInFlags & NUMPRS_LEADING_PLUS &&
*lpszStr == chars.cPositiveSymbol &&
!(pNumprs->dwOutFlags & NUMPRS_LEADING_PLUS))
@@ -1659,15 +1676,11 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
}
else if (pNumprs->dwInFlags & NUMPRS_CURRENCY &&
!(pNumprs->dwOutFlags & NUMPRS_CURRENCY) &&
*lpszStr == chars.cCurrencyLocal &&
(!chars.cCurrencyLocal2 || lpszStr[1] == chars.cCurrencyLocal2))
wcsncmp(lpszStr, chars.sCurrency, chars.sCurrencyLen) == 0)
{
pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
cchUsed++;
lpszStr++;
/* Only accept currency characters */
chars.cDecimalPoint = chars.cCurrencyDecimalPoint;
chars.cDigitSeparator = chars.cCurrencyDigitSeparator;
cchUsed += chars.sCurrencyLen;
lpszStr += chars.sCurrencyLen;
}
else if (pNumprs->dwInFlags & NUMPRS_PARENS && *lpszStr == '(' &&
!(pNumprs->dwOutFlags & NUMPRS_PARENS))
@@ -1680,28 +1693,24 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
break;
}
if (!(pNumprs->dwOutFlags & NUMPRS_CURRENCY))
{
/* Only accept non-currency characters */
chars.cCurrencyDecimalPoint = chars.cDecimalPoint;
chars.cCurrencyDigitSeparator = chars.cDigitSeparator;
}
if ((*lpszStr == '&' && (*(lpszStr+1) == 'H' || *(lpszStr+1) == 'h')) &&
pNumprs->dwInFlags & NUMPRS_HEX_OCT)
if (!(pNumprs->dwOutFlags & (NUMPRS_CURRENCY|NUMPRS_DECIMAL)))
{
if ((*lpszStr == '&' && (*(lpszStr+1) == 'H' || *(lpszStr+1) == 'h')) &&
pNumprs->dwInFlags & NUMPRS_HEX_OCT)
{
dwState |= B_PROCESSING_HEX;
pNumprs->dwOutFlags |= NUMPRS_HEX_OCT;
cchUsed=cchUsed+2;
lpszStr=lpszStr+2;
}
else if ((*lpszStr == '&' && (*(lpszStr+1) == 'O' || *(lpszStr+1) == 'o')) &&
pNumprs->dwInFlags & NUMPRS_HEX_OCT)
{
}
else if ((*lpszStr == '&' && (*(lpszStr+1) == 'O' || *(lpszStr+1) == 'o')) &&
pNumprs->dwInFlags & NUMPRS_HEX_OCT)
{
dwState |= B_PROCESSING_OCT;
pNumprs->dwOutFlags |= NUMPRS_HEX_OCT;
cchUsed=cchUsed+2;
lpszStr=lpszStr+2;
}
}
/* Strip Leading zeros */
@@ -1714,14 +1723,14 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
while (*lpszStr)
{
if (iswdigit(*lpszStr))
if (is_digit(*lpszStr))
{
if (dwState & B_PROCESSING_EXPONENT)
{
int exponentSize = 0;
if (dwState & B_EXPONENT_START)
{
if (!iswdigit(*lpszStr))
if (!is_digit(*lpszStr))
break; /* No exponent digits - invalid */
while (*lpszStr == '0')
{
@@ -1731,7 +1740,7 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
}
}
while (iswdigit(*lpszStr))
while (is_digit(*lpszStr))
{
exponentSize *= 10;
exponentSize += *lpszStr - '0';
@@ -1775,16 +1784,30 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
cchUsed++;
}
}
else if (*lpszStr == chars.cDigitSeparator && pNumprs->dwInFlags & NUMPRS_THOUSANDS)
else if (pNumprs->dwInFlags & NUMPRS_THOUSANDS &&
!(pNumprs->dwOutFlags & NUMPRS_HEX_OCT) &&
((chars.cDigitSeparator && *lpszStr == chars.cDigitSeparator) ||
(cDigitSeparator2 && *lpszStr == cDigitSeparator2)))
{
pNumprs->dwOutFlags |= NUMPRS_THOUSANDS;
cchUsed++;
}
else if (*lpszStr == chars.cDecimalPoint &&
pNumprs->dwInFlags & NUMPRS_DECIMAL &&
!(pNumprs->dwOutFlags & (NUMPRS_DECIMAL|NUMPRS_EXPONENT)))
else if ((pNumprs->dwInFlags & (NUMPRS_THOUSANDS|NUMPRS_CURRENCY)) == (NUMPRS_THOUSANDS|NUMPRS_CURRENCY) &&
!(pNumprs->dwOutFlags & NUMPRS_HEX_OCT) &&
chars.cCurrencyDigitSeparator && *lpszStr == chars.cCurrencyDigitSeparator)
{
pNumprs->dwOutFlags |= NUMPRS_THOUSANDS|NUMPRS_CURRENCY;
cchUsed++;
}
else if (pNumprs->dwInFlags & NUMPRS_DECIMAL &&
(*lpszStr == chars.cDecimalPoint ||
*lpszStr == chars.cCurrencyDecimalPoint) &&
!(pNumprs->dwOutFlags & (NUMPRS_HEX_OCT|NUMPRS_DECIMAL|NUMPRS_EXPONENT)))
{
pNumprs->dwOutFlags |= NUMPRS_DECIMAL;
if (*lpszStr == chars.cCurrencyDecimalPoint &&
chars.cDecimalPoint != chars.cCurrencyDecimalPoint)
pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
cchUsed++;
/* If we have no digits so far, skip leading zeros */
@@ -1819,7 +1842,7 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
}
else if ((*lpszStr == 'e' || *lpszStr == 'E') &&
pNumprs->dwInFlags & NUMPRS_EXPONENT &&
!(pNumprs->dwOutFlags & NUMPRS_EXPONENT))
!(pNumprs->dwOutFlags & (NUMPRS_HEX_OCT|NUMPRS_CURRENCY|NUMPRS_EXPONENT)))
{
dwState |= B_PROCESSING_EXPONENT;
pNumprs->dwOutFlags |= NUMPRS_EXPONENT;
@@ -1903,7 +1926,38 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
/* Consume any trailing symbols and space */
while (1)
{
if ((pNumprs->dwInFlags & NUMPRS_TRAILING_WHITE) && iswspace(*lpszStr))
if ((chars.cDigitSeparator && *lpszStr == chars.cDigitSeparator) ||
(cDigitSeparator2 && *lpszStr == cDigitSeparator2))
{
if (pNumprs->dwInFlags & NUMPRS_THOUSANDS &&
!(pNumprs->dwOutFlags & NUMPRS_HEX_OCT))
{
pNumprs->dwOutFlags |= NUMPRS_THOUSANDS;
cchUsed++;
lpszStr++;
}
else
{
/* Not allowed, even with NUMPRS_TRAILING_WHITE */
break;
}
}
else if (*lpszStr == chars.cCurrencyDigitSeparator)
{
if ((pNumprs->dwInFlags & (NUMPRS_THOUSANDS|NUMPRS_CURRENCY)) == (NUMPRS_THOUSANDS|NUMPRS_CURRENCY) &&
!(pNumprs->dwOutFlags & NUMPRS_HEX_OCT))
{
pNumprs->dwOutFlags |= NUMPRS_THOUSANDS|NUMPRS_CURRENCY;
cchUsed++;
lpszStr++;
}
else
{
/* Not allowed, even with NUMPRS_TRAILING_WHITE */
break;
}
}
else if ((pNumprs->dwInFlags & NUMPRS_TRAILING_WHITE) && iswspace(*lpszStr))
{
pNumprs->dwOutFlags |= NUMPRS_TRAILING_WHITE;
do
@@ -1935,6 +1989,14 @@ HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
lpszStr++;
pNumprs->dwOutFlags |= NUMPRS_NEG;
}
else if (pNumprs->dwInFlags & NUMPRS_CURRENCY &&
!(pNumprs->dwOutFlags & NUMPRS_HEX_OCT) &&
wcsncmp(lpszStr, chars.sCurrency, chars.sCurrencyLen) == 0)
{
pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
cchUsed += chars.sCurrencyLen;
lpszStr += chars.sCurrencyLen;
}
else
break;
}
@@ -2016,7 +2078,7 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
int wholeNumberDigits, fractionalDigits, divisor10 = 0, multiplier10 = 0;
TRACE("(%p,%p,0x%x,%p)\n", pNumprs, rgbDig, dwVtBits, pVarDst);
TRACE("%p, %p, %lx, %p.\n", pNumprs, rgbDig, dwVtBits, pVarDst);
if (pNumprs->nBaseShift)
{
@@ -2091,9 +2153,10 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
else if ((dwVtBits & VTBIT_DECIMAL) == VTBIT_DECIMAL)
{
V_VT(pVarDst) = VT_DECIMAL;
DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_POS,0);
DEC_HI32(&V_DECIMAL(pVarDst)) = 0;
DEC_LO64(&V_DECIMAL(pVarDst)) = ul64;
V_DECIMAL(pVarDst).sign = DECIMAL_POS;
V_DECIMAL(pVarDst).scale = 0;
V_DECIMAL(pVarDst).Hi32 = 0;
V_DECIMAL(pVarDst).Lo64 = ul64;
return S_OK;
}
else if (dwVtBits & VTBIT_R4 && ((ul64 <= I4_MAX)||(l64 >= I4_MIN)))
@@ -2115,7 +2178,7 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
return S_OK;
}
TRACE("Overflow: possible return types: 0x%x, value: %s\n", dwVtBits, wine_dbgstr_longlong(ul64));
TRACE("Overflow: possible return types: %#lx, value: %s\n", dwVtBits, wine_dbgstr_longlong(ul64));
return DISP_E_OVERFLOW;
}
@@ -2276,9 +2339,10 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
{
/* Decimal is only output choice left - fast path */
V_VT(pVarDst) = VT_DECIMAL;
DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_NEG,0);
DEC_HI32(&V_DECIMAL(pVarDst)) = 0;
DEC_LO64(&V_DECIMAL(pVarDst)) = -ul64;
V_DECIMAL(pVarDst).sign = DECIMAL_NEG;
V_DECIMAL(pVarDst).scale = 0;
V_DECIMAL(pVarDst).Hi32 = 0;
V_DECIMAL(pVarDst).Lo64 = -ul64;
return S_OK;
}
}
@@ -2338,9 +2402,10 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
{
/* Decimal is only output choice left - fast path */
V_VT(pVarDst) = VT_DECIMAL;
DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_POS,0);
DEC_HI32(&V_DECIMAL(pVarDst)) = 0;
DEC_LO64(&V_DECIMAL(pVarDst)) = ul64;
V_DECIMAL(pVarDst).sign = DECIMAL_POS;
V_DECIMAL(pVarDst).scale = 0;
V_DECIMAL(pVarDst).Hi32 = 0;
V_DECIMAL(pVarDst).Lo64 = ul64;
return S_OK;
}
}
@@ -2446,30 +2511,30 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
DECIMAL* pDec = &V_DECIMAL(pVarDst);
DECIMAL_SETZERO(*pDec);
DEC_LO32(pDec) = 0;
pDec->Lo32 = 0;
if (pNumprs->dwOutFlags & NUMPRS_NEG)
DEC_SIGN(pDec) = DECIMAL_NEG;
pDec->sign = DECIMAL_NEG;
else
DEC_SIGN(pDec) = DECIMAL_POS;
pDec->sign = DECIMAL_POS;
/* Factor the significant digits */
for (i = 0; i < pNumprs->cDig; i++)
{
tmp = (ULONG64)DEC_LO32(pDec) * 10 + rgbDig[i];
tmp = (ULONG64)pDec->Lo32 * 10 + rgbDig[i];
carry = (ULONG)(tmp >> 32);
DEC_LO32(pDec) = (ULONG)(tmp & UI4_MAX);
tmp = (ULONG64)DEC_MID32(pDec) * 10 + carry;
pDec->Lo32 = (ULONG)tmp;
tmp = (ULONG64)pDec->Mid32 * 10 + carry;
carry = (ULONG)(tmp >> 32);
DEC_MID32(pDec) = (ULONG)(tmp & UI4_MAX);
tmp = (ULONG64)DEC_HI32(pDec) * 10 + carry;
DEC_HI32(pDec) = (ULONG)(tmp & UI4_MAX);
pDec->Mid32 = (ULONG)tmp;
tmp = (ULONG64)pDec->Hi32 * 10 + carry;
pDec->Hi32 = (ULONG)tmp;
if (tmp >> 32 & UI4_MAX)
if (tmp >> 32)
{
VarNumFromParseNum_DecOverflow:
TRACE("Overflow\n");
DEC_LO32(pDec) = DEC_MID32(pDec) = DEC_HI32(pDec) = UI4_MAX;
pDec->Lo32 = pDec->Mid32 = pDec->Hi32 = UI4_MAX;
return DISP_E_OVERFLOW;
}
}
@@ -2477,20 +2542,20 @@ VarNumFromParseNum_DecOverflow:
/* Account for the scale of the number */
while (multiplier10 > 0)
{
tmp = (ULONG64)DEC_LO32(pDec) * 10;
tmp = (ULONG64)pDec->Lo32 * 10;
carry = (ULONG)(tmp >> 32);
DEC_LO32(pDec) = (ULONG)(tmp & UI4_MAX);
tmp = (ULONG64)DEC_MID32(pDec) * 10 + carry;
pDec->Lo32 = (ULONG)tmp;
tmp = (ULONG64)pDec->Mid32 * 10 + carry;
carry = (ULONG)(tmp >> 32);
DEC_MID32(pDec) = (ULONG)(tmp & UI4_MAX);
tmp = (ULONG64)DEC_HI32(pDec) * 10 + carry;
DEC_HI32(pDec) = (ULONG)(tmp & UI4_MAX);
pDec->Mid32 = (ULONG)tmp;
tmp = (ULONG64)pDec->Hi32 * 10 + carry;
pDec->Hi32 = (ULONG)tmp;
if (tmp >> 32 & UI4_MAX)
if (tmp >> 32)
goto VarNumFromParseNum_DecOverflow;
multiplier10--;
}
DEC_SCALE(pDec) = divisor10;
pDec->scale = divisor10;
V_VT(pVarDst) = VT_DECIMAL;
return S_OK;
@@ -2716,7 +2781,7 @@ HRESULT WINAPI VarCmp(LPVARIANT left, LPVARIANT right, LCID lcid, DWORD flags)
DWORD xmask;
HRESULT rc;
TRACE("(%s,%s,0x%08x,0x%08x)\n", debugstr_variant(left), debugstr_variant(right), lcid, flags);
TRACE("%s, %s, %#lx, %#lx.\n", debugstr_variant(left), debugstr_variant(right), lcid, flags);
lvt = V_VT(left) & VT_TYPEMASK;
rvt = V_VT(right) & VT_TYPEMASK;
@@ -3009,8 +3074,7 @@ HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
resvt = VT_NULL;
break;
case VT_DECIMAL:
if (DEC_HI32(&V_DECIMAL(right)) ||
DEC_LO64(&V_DECIMAL(right)))
if (V_DECIMAL(right).Hi32 || V_DECIMAL(right).Lo64)
resvt = VT_NULL;
break;
case VT_BSTR:
@@ -3311,7 +3375,7 @@ end:
VariantClear(&tv);
VariantClear(&tempLeft);
VariantClear(&tempRight);
TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
TRACE("returning %#lx, %s\n", hres, debugstr_variant(result));
return hres;
}
@@ -3500,7 +3564,7 @@ end:
VariantClear(&tv);
VariantClear(&tempLeft);
VariantClear(&tempRight);
TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
TRACE("returning %#lx, %s\n", hres, debugstr_variant(result));
return hres;
}
@@ -3662,7 +3726,7 @@ end:
VariantClear(&rv);
VariantClear(&tempLeft);
VariantClear(&tempRight);
TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
TRACE("returning %#lx, %s\n", hres, debugstr_variant(result));
return hres;
}
@@ -3925,7 +3989,7 @@ end:
VariantClear(&rv);
VariantClear(&tempLeft);
VariantClear(&tempRight);
TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
TRACE("returning %#lx, %s\n", hres, debugstr_variant(result));
return hres;
}
@@ -4045,7 +4109,7 @@ HRESULT WINAPI VarOr(LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut)
hRet = S_OK;
goto VarOr_Exit;
case VT_DECIMAL:
if (DEC_HI32(&V_DECIMAL(pVarLeft)) || DEC_LO64(&V_DECIMAL(pVarLeft)))
if (V_DECIMAL(pVarLeft).Hi32 || V_DECIMAL(pVarLeft).Lo64)
goto VarOr_AsEmpty;
hRet = S_OK;
goto VarOr_Exit;
@@ -4262,7 +4326,6 @@ VarOr_Exit:
*/
HRESULT WINAPI VarAbs(LPVARIANT pVarIn, LPVARIANT pVarOut)
{
VARIANT varIn;
HRESULT hRet = S_OK;
VARIANT temp;
@@ -4302,21 +4365,24 @@ HRESULT WINAPI VarAbs(LPVARIANT pVarIn, LPVARIANT pVarOut)
case VT_INT:
ABS_CASE(I4,I4_MIN);
ABS_CASE(I8,I8_MIN);
ABS_CASE(R4,R4_MIN);
case VT_R4:
if (V_R4(pVarOut) < 0.0) V_R4(pVarOut) = -V_R4(pVarOut);
break;
case VT_BSTR:
hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(&varIn));
hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(pVarOut));
if (FAILED(hRet))
break;
V_VT(pVarOut) = VT_R8;
pVarIn = &varIn;
/* Fall through ... */
case VT_DATE:
ABS_CASE(R8,R8_MIN);
case VT_R8:
if (V_R8(pVarOut) < 0.0) V_R8(pVarOut) = -V_R8(pVarOut);
break;
case VT_CY:
hRet = VarCyAbs(V_CY(pVarIn), & V_CY(pVarOut));
break;
case VT_DECIMAL:
DEC_SIGN(&V_DECIMAL(pVarOut)) &= ~DECIMAL_NEG;
V_DECIMAL(pVarOut).sign &= ~DECIMAL_NEG;
break;
case VT_UI1:
case VT_UI2:
@@ -4568,6 +4634,7 @@ HRESULT WINAPI VarXor(LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut
return S_OK;
}
V_VT(&varLeft) = V_VT(&varRight) = VT_EMPTY;
VariantInit(&tempLeft);
VariantInit(&tempRight);
@@ -4586,8 +4653,6 @@ HRESULT WINAPI VarXor(LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut
}
/* Copy our inputs so we don't disturb anything */
V_VT(&varLeft) = V_VT(&varRight) = VT_EMPTY;
hRet = VariantCopy(&varLeft, pVarLeft);
if (FAILED(hRet))
goto VarXor_Exit;
@@ -5159,7 +5224,7 @@ VarRound_Exit:
V_VT(pVarOut) = VT_EMPTY;
VariantClear(&temp);
TRACE("returning 0x%08x %s\n", hRet, debugstr_variant(pVarOut));
TRACE("returning %#lx, %s\n", hRet, debugstr_variant(pVarOut));
return hRet;
}
@@ -5336,7 +5401,6 @@ end:
*/
HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
{
BOOL lOk = TRUE;
HRESULT rc = E_FAIL;
int resT = 0;
VARIANT lv,rv;
@@ -5346,6 +5410,7 @@ HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
VariantInit(&tempRight);
VariantInit(&lv);
VariantInit(&rv);
V_VT(result) = VT_EMPTY;
TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
@@ -5364,7 +5429,6 @@ HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
}
/* check for invalid inputs */
lOk = TRUE;
switch (V_VT(left) & VT_TYPEMASK) {
case VT_BOOL :
case VT_I1 :
@@ -5436,6 +5500,7 @@ HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
if(V_VT(left) == VT_EMPTY)
{
V_VT(result) = VT_I4;
V_I4(result) = 0;
rc = S_OK;
goto end;
}
@@ -5466,15 +5531,10 @@ HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
{
V_VT(result) = VT_EMPTY;
rc = DISP_E_BADVARTYPE;
} else if((V_VT(left) == VT_NULL) || (V_VT(left) == VT_EMPTY) || (V_VT(left) == VT_ERROR) ||
lOk)
} else
{
V_VT(result) = VT_NULL;
rc = S_OK;
} else
{
V_VT(result) = VT_NULL;
rc = DISP_E_BADVARTYPE;
}
goto end;
case VT_VARIANT:
@@ -5486,7 +5546,7 @@ HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
rc = DISP_E_TYPEMISMATCH;
goto end;
case VT_RECORD:
if((V_VT(left) == 15) || ((V_VT(left) >= 24) && (V_VT(left) <= 35)) || !lOk)
if((V_VT(left) == 15) || ((V_VT(left) >= 24) && (V_VT(left) <= 35)))
{
V_VT(result) = VT_EMPTY;
rc = DISP_E_BADVARTYPE;
@@ -5519,14 +5579,14 @@ HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
rc = VariantChangeType(&lv, left, 0, VT_I8);
if(FAILED(rc))
{
FIXME("Could not convert left type %d to %d? rc == 0x%X\n", V_VT(left), VT_I8, rc);
FIXME("Could not convert left type %d to %d? rc == %#lx.\n", V_VT(left), VT_I8, rc);
goto end;
}
rc = VariantChangeType(&rv, right, 0, VT_I8);
if(FAILED(rc))
{
FIXME("Could not convert right type %d to %d? rc == 0x%X\n", V_VT(right), VT_I8, rc);
FIXME("Could not convert right type %d to %d? rc == %#lx.\n", V_VT(right), VT_I8, rc);
goto end;
}
@@ -5803,7 +5863,7 @@ HRESULT WINAPI VarImp(LPVARIANT left, LPVARIANT right, LPVARIANT result)
case VT_DATE: if (!V_DATE(right)) resvt = VT_NULL; break;
case VT_CY: if (!V_CY(right).int64) resvt = VT_NULL; break;
case VT_DECIMAL:
if (!(DEC_HI32(&V_DECIMAL(right)) || DEC_LO64(&V_DECIMAL(right))))
if (!(V_DECIMAL(right).Hi32 || V_DECIMAL(right).Lo64))
resvt = VT_NULL;
break;
case VT_BSTR:
@@ -5853,7 +5913,7 @@ HRESULT WINAPI VarImp(LPVARIANT left, LPVARIANT right, LPVARIANT result)
case VT_R8: if (V_R8(left) == -1.0) resvt = VT_NULL; break;
case VT_CY: if (V_CY(left).int64 == -1) resvt = VT_NULL; break;
case VT_DECIMAL:
if (DEC_HI32(&V_DECIMAL(left)) == 0xffffffff)
if (V_DECIMAL(left).Hi32 == 0xffffffff)
resvt = VT_NULL;
break;
case VT_BSTR:
dll/win32/oleaut32/variant.h
+3 -38
View File
@@ -18,8 +18,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#pragma once
#include "windef.h"
#include "winerror.h"
#include "objbase.h"
@@ -76,26 +74,6 @@
/* Value of sign for a positive decimal number */
#define DECIMAL_POS 0
/* Native headers don't change the union ordering for DECIMAL sign/scale (duh).
* This means that the signscale member is only useful for setting both members to 0.
* SIGNSCALE creates endian-correct values so that we can properly set both at once
* to values other than 0.
*/
#ifdef WORDS_BIGENDIAN
#define SIGNSCALE(sign,scale) (((scale) << 8) | sign)
#else
#define SIGNSCALE(sign,scale) (((sign) << 8) | scale)
#endif
/* Macros for getting at a DECIMAL's parts */
#define DEC_SIGN(d) ((d)->u.s.sign)
#define DEC_SCALE(d) ((d)->u.s.scale)
#define DEC_SIGNSCALE(d) ((d)->u.signscale)
#define DEC_HI32(d) ((d)->Hi32)
#define DEC_MID32(d) ((d)->u1.s1.Mid32)
#define DEC_LO32(d) ((d)->u1.s1.Lo32)
#define DEC_LO64(d) ((d)->u1.Lo64)
#define DEC_MAX_SCALE 28 /* Maximum scale for a decimal */
/* Internal flags for low level conversion functions */
@@ -103,20 +81,7 @@
#define VAR_BOOLYESNO 0x0800 /* Convert bool to "Yes"/"No" */
#define VAR_NEGATIVE 0x1000 /* Number is negative */
/* The localised characters that make up a valid number */
typedef struct tagVARIANT_NUMBER_CHARS
{
WCHAR cNegativeSymbol;
WCHAR cPositiveSymbol;
WCHAR cDecimalPoint;
WCHAR cDigitSeparator;
WCHAR cCurrencyLocal;
WCHAR cCurrencyLocal2;
WCHAR cCurrencyDecimalPoint;
WCHAR cCurrencyDigitSeparator;
} VARIANT_NUMBER_CHARS;
unsigned int get_type_size(ULONG*, VARTYPE) DECLSPEC_HIDDEN;
HRESULT VARIANT_ClearInd(VARIANTARG *) DECLSPEC_HIDDEN;
unsigned int get_type_size(ULONG*, VARTYPE);
HRESULT VARIANT_ClearInd(VARIANTARG *);
BOOL get_date_format(LCID, DWORD, const SYSTEMTIME *,
const WCHAR *, WCHAR *, int) DECLSPEC_HIDDEN;
const WCHAR *, WCHAR *, int);
dll/win32/oleaut32/vartype.c
+293 -224
View File
File diff suppressed because it is too large Load Diff
media/doc/WINESYNC.txt
+1 -1
View File
@@ -155,7 +155,7 @@ dll/win32/odbc32 # Synced to WineStaging-4.18. Depends on port of L
dll/win32/odbccp32 # Synced to WineStaging-4.18
dll/win32/ole32 # Synced to Wine-10.0
dll/win32/oleacc # Synced to Wine-10.0
dll/win32/oleaut32 # Synced to WineStaging-4.18
dll/win32/oleaut32 # Synced to Wine-10.0
dll/win32/olecli32 # Synced to WineStaging-4.18
dll/win32/oledlg # Synced to WineStaging-4.18
dll/win32/olepro32 # Synced to WineStaging-3.3