ReactOS 0.4.15-dev-5666-gc548b97
antimoniker.c
Go to the documentation of this file.
1/*
2 * AntiMonikers implementation
3 *
4 * Copyright 1999 Noomen Hamza
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21#include <assert.h>
22#include <stdarg.h>
23#include <string.h>
24
25#define COBJMACROS
26#define NONAMELESSUNION
27
28#include "windef.h"
29#include "winbase.h"
30#include "winerror.h"
31#include "objbase.h"
32#include "wine/debug.h"
33#include "moniker.h"
34
36
37/* AntiMoniker data structure */
38typedef struct AntiMonikerImpl{
42 IUnknown *pMarshal; /* custom marshaler */
44
46{
47 return CONTAINING_RECORD(iface, AntiMonikerImpl, IMoniker_iface);
48}
49
51{
52 return CONTAINING_RECORD(iface, AntiMonikerImpl, IROTData_iface);
53}
54
55
56/*******************************************************************************
57 * AntiMoniker_QueryInterface
58 *******************************************************************************/
59static HRESULT WINAPI
61{
63
64 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
65
66 /* Perform a sanity check on the parameters.*/
67 if ( ppvObject==0 )
68 return E_INVALIDARG;
69
70 /* Initialize the return parameter */
71 *ppvObject = 0;
72
73 /* Compare the riid with the interface IDs implemented by this object.*/
77 IsEqualIID(&IID_IMoniker, riid))
78 *ppvObject = iface;
79 else if (IsEqualIID(&IID_IROTData, riid))
80 *ppvObject = &This->IROTData_iface;
81 else if (IsEqualIID(&IID_IMarshal, riid))
82 {
83 HRESULT hr = S_OK;
84 if (!This->pMarshal)
85 hr = MonikerMarshal_Create(iface, &This->pMarshal);
86 if (hr != S_OK)
87 return hr;
88 return IUnknown_QueryInterface(This->pMarshal, riid, ppvObject);
89 }
90
91 /* Check that we obtained an interface.*/
92 if ((*ppvObject)==0)
93 return E_NOINTERFACE;
94
95 /* always increase the reference count by one when it is successful */
96 IMoniker_AddRef(iface);
97
98 return S_OK;
99}
100
101/******************************************************************************
102 * AntiMoniker_AddRef
103 ******************************************************************************/
104static ULONG WINAPI
106{
108
109 TRACE("(%p)\n",This);
110
111 return InterlockedIncrement(&This->ref);
112}
113
114/******************************************************************************
115 * AntiMoniker_Release
116 ******************************************************************************/
117static ULONG WINAPI
119{
121 ULONG ref;
122
123 TRACE("(%p)\n",This);
124
126
127 /* destroy the object if there are no more references to it */
128 if (ref == 0)
129 {
130 if (This->pMarshal) IUnknown_Release(This->pMarshal);
132 }
133
134 return ref;
135}
136
137/******************************************************************************
138 * AntiMoniker_GetClassID
139 ******************************************************************************/
140static HRESULT WINAPI
142{
143 TRACE("(%p,%p)\n",iface,pClassID);
144
145 if (pClassID==NULL)
146 return E_POINTER;
147
148 *pClassID = CLSID_AntiMoniker;
149
150 return S_OK;
151}
152
153/******************************************************************************
154 * AntiMoniker_IsDirty
155 ******************************************************************************/
156static HRESULT WINAPI
158{
159 /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
160 method in the OLE-provided moniker interfaces always return S_FALSE because
161 their internal state never changes. */
162
163 TRACE("(%p)\n",iface);
164
165 return S_FALSE;
166}
167
168/******************************************************************************
169 * AntiMoniker_Load
170 ******************************************************************************/
171static HRESULT WINAPI
173{
174 DWORD constant=1,dwbuffer;
175 HRESULT res;
176
177 /* data read by this function is only a DWORD constant (must be 1) ! */
178 res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),NULL);
179
180 if (SUCCEEDED(res)&& dwbuffer!=constant)
181 return E_FAIL;
182
183 return res;
184}
185
186/******************************************************************************
187 * AntiMoniker_Save
188 ******************************************************************************/
189static HRESULT WINAPI
190AntiMonikerImpl_Save(IMoniker* iface,IStream* pStm,BOOL fClearDirty)
191{
192 static const DWORD constant = 1;
193 /* data written by this function is only a DWORD constant set to 1 ! */
194 return IStream_Write(pStm,&constant,sizeof(constant),NULL);
195}
196
197/******************************************************************************
198 * AntiMoniker_GetSizeMax
199 *
200 * PARAMS
201 * pcbSize [out] Pointer to size of stream needed to save object
202 ******************************************************************************/
203static HRESULT WINAPI
205{
206 TRACE("(%p,%p)\n",iface,pcbSize);
207
208 if (!pcbSize)
209 return E_POINTER;
210
211 /* for more details see AntiMonikerImpl_Save comments */
212
213 /*
214 * Normally the sizemax must be sizeof DWORD, but
215 * I tested this function it usually return 16 bytes
216 * more than the number of bytes used by AntiMoniker::Save function
217 */
218 pcbSize->u.LowPart = sizeof(DWORD)+16;
219
220 pcbSize->u.HighPart=0;
221
222 return S_OK;
223}
224
225/******************************************************************************
226 * AntiMoniker_BindToObject
227 ******************************************************************************/
228static HRESULT WINAPI
230 REFIID riid, VOID** ppvResult)
231{
232 TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
233 return E_NOTIMPL;
234}
235
236/******************************************************************************
237 * AntiMoniker_BindToStorage
238 ******************************************************************************/
239static HRESULT WINAPI
241 REFIID riid, VOID** ppvResult)
242{
243 TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
244 return E_NOTIMPL;
245}
246
247/******************************************************************************
248 * AntiMoniker_Reduce
249 ******************************************************************************/
250static HRESULT WINAPI
251AntiMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
252 IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
253{
254 TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
255
256 if (ppmkReduced==NULL)
257 return E_POINTER;
258
260
261 *ppmkReduced=iface;
262
264}
265/******************************************************************************
266 * AntiMoniker_ComposeWith
267 ******************************************************************************/
268static HRESULT WINAPI
270 BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
271{
272
273 TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
274
275 if ((ppmkComposite==NULL)||(pmkRight==NULL))
276 return E_POINTER;
277
278 *ppmkComposite=0;
279
280 if (fOnlyIfNotGeneric)
281 return MK_E_NEEDGENERIC;
282 else
283 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
284}
285
286/******************************************************************************
287 * AntiMoniker_Enum
288 ******************************************************************************/
289static HRESULT WINAPI
290AntiMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
291{
292 TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
293
294 if (ppenumMoniker == NULL)
295 return E_POINTER;
296
297 *ppenumMoniker = NULL;
298
299 return S_OK;
300}
301
302/******************************************************************************
303 * AntiMoniker_IsEqual
304 ******************************************************************************/
305static HRESULT WINAPI
307{
308 DWORD mkSys;
309
310 TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
311
312 if (pmkOtherMoniker==NULL)
313 return S_FALSE;
314
315 IMoniker_IsSystemMoniker(pmkOtherMoniker,&mkSys);
316
317 if (mkSys==MKSYS_ANTIMONIKER)
318 return S_OK;
319 else
320 return S_FALSE;
321}
322
323/******************************************************************************
324 * AntiMoniker_Hash
325 ******************************************************************************/
327{
328 if (pdwHash==NULL)
329 return E_POINTER;
330
331 *pdwHash = 0x80000001;
332
333 return S_OK;
334}
335
336/******************************************************************************
337 * AntiMoniker_IsRunning
338 ******************************************************************************/
339static HRESULT WINAPI
341 IMoniker* pmkNewlyRunning)
342{
344 HRESULT res;
345
346 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
347
348 if (pbc==NULL)
349 return E_INVALIDARG;
350
351 res=IBindCtx_GetRunningObjectTable(pbc,&rot);
352
353 if (FAILED(res))
354 return res;
355
356 res = IRunningObjectTable_IsRunning(rot,iface);
357
358 IRunningObjectTable_Release(rot);
359
360 return res;
361}
362
363/******************************************************************************
364 * AntiMoniker_GetTimeOfLastChange
365 ******************************************************************************/
367 IBindCtx* pbc,
368 IMoniker* pmkToLeft,
369 FILETIME* pAntiTime)
370{
371 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pAntiTime);
372 return E_NOTIMPL;
373}
374
375/******************************************************************************
376 * AntiMoniker_Inverse
377 ******************************************************************************/
378static HRESULT WINAPI
380{
381 TRACE("(%p,%p)\n",iface,ppmk);
382
383 if (ppmk==NULL)
384 return E_POINTER;
385
386 *ppmk=0;
387
388 return MK_E_NOINVERSE;
389}
390
391/******************************************************************************
392 * AntiMoniker_CommonPrefixWith
393 ******************************************************************************/
394static HRESULT WINAPI
396{
397 DWORD mkSys;
398
399 IMoniker_IsSystemMoniker(pmkOther,&mkSys);
400
401 if(mkSys==MKSYS_ANTIMONIKER){
402
403 IMoniker_AddRef(iface);
404
405 *ppmkPrefix=iface;
406
407 IMoniker_AddRef(iface);
408
409 return MK_S_US;
410 }
411 else
412 return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
413}
414
415/******************************************************************************
416 * AntiMoniker_RelativePathTo
417 ******************************************************************************/
418static HRESULT WINAPI
420{
421 TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
422
423 if (ppmkRelPath==NULL)
424 return E_POINTER;
425
426 IMoniker_AddRef(pmOther);
427
428 *ppmkRelPath=pmOther;
429
430 return MK_S_HIM;
431}
432
433/******************************************************************************
434 * AntiMoniker_GetDisplayName
435 ******************************************************************************/
436static HRESULT WINAPI
438 IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
439{
440 static const WCHAR back[]={'\\','.','.',0};
441
442 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
443
444 if (ppszDisplayName==NULL)
445 return E_POINTER;
446
447 if (pmkToLeft!=NULL){
448 FIXME("() pmkToLeft!=NULL not implemented\n");
449 return E_NOTIMPL;
450 }
451
452 *ppszDisplayName=CoTaskMemAlloc(sizeof(back));
453
454 if (*ppszDisplayName==NULL)
455 return E_OUTOFMEMORY;
456
457 lstrcpyW(*ppszDisplayName,back);
458
459 return S_OK;
460}
461
462/******************************************************************************
463 * AntiMoniker_ParseDisplayName
464 ******************************************************************************/
465static HRESULT WINAPI
467 IMoniker* pmkToLeft, LPOLESTR pszDisplayName,
468 ULONG* pchEaten, IMoniker** ppmkOut)
469{
470 TRACE("(%p,%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
471 return E_NOTIMPL;
472}
473
474/******************************************************************************
475 * AntiMoniker_IsSystemMoniker
476 ******************************************************************************/
477static HRESULT WINAPI
479{
480 TRACE("(%p,%p)\n",iface,pwdMksys);
481
482 if (!pwdMksys)
483 return E_POINTER;
484
485 (*pwdMksys)=MKSYS_ANTIMONIKER;
486
487 return S_OK;
488}
489
490/*******************************************************************************
491 * AntiMonikerIROTData_QueryInterface
492 *******************************************************************************/
493static HRESULT WINAPI
495{
497
498 TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppvObject);
499
500 return AntiMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppvObject);
501}
502
503/***********************************************************************
504 * AntiMonikerIROTData_AddRef
505 */
507{
509
510 TRACE("(%p)\n",iface);
511
512 return AntiMonikerImpl_AddRef(&This->IMoniker_iface);
513}
514
515/***********************************************************************
516 * AntiMonikerIROTData_Release
517 */
519{
521
522 TRACE("(%p)\n",iface);
523
524 return AntiMonikerImpl_Release(&This->IMoniker_iface);
525}
526
527/******************************************************************************
528 * AntiMonikerIROTData_GetComparisonData
529 ******************************************************************************/
530static HRESULT WINAPI
532 ULONG cbMax, ULONG* pcbData)
533{
534 DWORD constant = 1;
535
536 TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
537
538 *pcbData = sizeof(CLSID) + sizeof(DWORD);
539 if (cbMax < *pcbData)
540 return E_OUTOFMEMORY;
541
542 memcpy(pbData, &CLSID_AntiMoniker, sizeof(CLSID));
543 memcpy(pbData+sizeof(CLSID), &constant, sizeof(DWORD));
544
545 return S_OK;
546}
547
548/********************************************************************************/
549/* Virtual function table for the AntiMonikerImpl class which include IPersist,*/
550/* IPersistStream and IMoniker functions. */
551static const IMonikerVtbl VT_AntiMonikerImpl =
552{
576};
577
578/********************************************************************************/
579/* Virtual function table for the IROTData class. */
580static const IROTDataVtbl VT_ROTDataImpl =
581{
586};
587
588/******************************************************************************
589 * AntiMoniker_Construct (local function)
590 *******************************************************************************/
592{
593
594 TRACE("(%p)\n",This);
595
596 /* Initialize the virtual function table. */
597 This->IMoniker_iface.lpVtbl = &VT_AntiMonikerImpl;
598 This->IROTData_iface.lpVtbl = &VT_ROTDataImpl;
599 This->ref = 0;
600 This->pMarshal = NULL;
601
602 return S_OK;
603}
604
605/******************************************************************************
606 * CreateAntiMoniker [OLE32.@]
607 ******************************************************************************/
609{
610 AntiMonikerImpl* newAntiMoniker;
611 HRESULT hr;
612
613 TRACE("(%p)\n",ppmk);
614
615 newAntiMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(AntiMonikerImpl));
616
617 if (newAntiMoniker == 0)
619
620 hr = AntiMonikerImpl_Construct(newAntiMoniker);
621 if (FAILED(hr))
622 {
623 HeapFree(GetProcessHeap(),0,newAntiMoniker);
624 return hr;
625 }
626
627 return AntiMonikerImpl_QueryInterface(&newAntiMoniker->IMoniker_iface, &IID_IMoniker,
628 (void**)ppmk);
629}
630
632 IUnknown *pUnk, REFIID riid, void **ppv)
633{
634 IMoniker *pMoniker;
635 HRESULT hr;
636
637 TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
638
639 *ppv = NULL;
640
641 if (pUnk)
643
644 hr = CreateAntiMoniker(&pMoniker);
645 if (FAILED(hr))
646 return hr;
647
648 hr = IMoniker_QueryInterface(pMoniker, riid, ppv);
649
650 if (FAILED(hr))
651 IMoniker_Release(pMoniker);
652
653 return hr;
654}
GLfloat rot
Definition: 3dtext.c:36
static HRESULT WINAPI AntiMonikerImpl_Enum(IMoniker *iface, BOOL fForward, IEnumMoniker **ppenumMoniker)
Definition: antimoniker.c:290
static HRESULT WINAPI AntiMonikerImpl_IsEqual(IMoniker *iface, IMoniker *pmkOtherMoniker)
Definition: antimoniker.c:306
static AntiMonikerImpl * impl_from_IMoniker(IMoniker *iface)
Definition: antimoniker.c:45
static HRESULT WINAPI AntiMonikerImpl_IsSystemMoniker(IMoniker *iface, DWORD *pwdMksys)
Definition: antimoniker.c:478
static HRESULT WINAPI AntiMonikerImpl_GetSizeMax(IMoniker *iface, ULARGE_INTEGER *pcbSize)
Definition: antimoniker.c:204
HRESULT WINAPI AntiMoniker_CreateInstance(IClassFactory *iface, IUnknown *pUnk, REFIID riid, void **ppv)
Definition: antimoniker.c:631
static HRESULT WINAPI AntiMonikerImpl_BindToObject(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvResult)
Definition: antimoniker.c:229
static HRESULT WINAPI AntiMonikerImpl_RelativePathTo(IMoniker *iface, IMoniker *pmOther, IMoniker **ppmkRelPath)
Definition: antimoniker.c:419
static const IMonikerVtbl VT_AntiMonikerImpl
Definition: antimoniker.c:551
HRESULT WINAPI CreateAntiMoniker(IMoniker **ppmk)
Definition: antimoniker.c:608
static HRESULT WINAPI AntiMonikerImpl_QueryInterface(IMoniker *iface, REFIID riid, void **ppvObject)
Definition: antimoniker.c:60
static HRESULT WINAPI AntiMonikerImpl_GetDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
Definition: antimoniker.c:437
static HRESULT WINAPI AntiMonikerImpl_Inverse(IMoniker *iface, IMoniker **ppmk)
Definition: antimoniker.c:379
static HRESULT WINAPI AntiMonikerImpl_IsRunning(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
Definition: antimoniker.c:340
static HRESULT WINAPI AntiMonikerImpl_Hash(IMoniker *iface, DWORD *pdwHash)
Definition: antimoniker.c:326
static HRESULT WINAPI AntiMonikerImpl_GetTimeOfLastChange(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pAntiTime)
Definition: antimoniker.c:366
static HRESULT WINAPI AntiMonikerImpl_CommonPrefixWith(IMoniker *iface, IMoniker *pmkOther, IMoniker **ppmkPrefix)
Definition: antimoniker.c:395
static HRESULT WINAPI AntiMonikerImpl_Load(IMoniker *iface, IStream *pStm)
Definition: antimoniker.c:172
static const IROTDataVtbl VT_ROTDataImpl
Definition: antimoniker.c:580
static HRESULT WINAPI AntiMonikerImpl_Reduce(IMoniker *iface, IBindCtx *pbc, DWORD dwReduceHowFar, IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
Definition: antimoniker.c:251
static HRESULT WINAPI AntiMonikerImpl_BindToStorage(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvResult)
Definition: antimoniker.c:240
static HRESULT WINAPI AntiMonikerROTDataImpl_QueryInterface(IROTData *iface, REFIID riid, VOID **ppvObject)
Definition: antimoniker.c:494
static HRESULT WINAPI AntiMonikerImpl_GetClassID(IMoniker *iface, CLSID *pClassID)
Definition: antimoniker.c:141
static HRESULT WINAPI AntiMonikerImpl_ParseDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
Definition: antimoniker.c:466
static HRESULT WINAPI AntiMonikerImpl_ComposeWith(IMoniker *iface, IMoniker *pmkRight, BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
Definition: antimoniker.c:269
static HRESULT AntiMonikerImpl_Construct(AntiMonikerImpl *This)
Definition: antimoniker.c:591
static HRESULT WINAPI AntiMonikerImpl_Save(IMoniker *iface, IStream *pStm, BOOL fClearDirty)
Definition: antimoniker.c:190
static ULONG WINAPI AntiMonikerImpl_Release(IMoniker *iface)
Definition: antimoniker.c:118
static AntiMonikerImpl * impl_from_IROTData(IROTData *iface)
Definition: antimoniker.c:50
static ULONG WINAPI AntiMonikerROTDataImpl_Release(IROTData *iface)
Definition: antimoniker.c:518
static ULONG WINAPI AntiMonikerROTDataImpl_AddRef(IROTData *iface)
Definition: antimoniker.c:506
static ULONG WINAPI AntiMonikerImpl_AddRef(IMoniker *iface)
Definition: antimoniker.c:105
static HRESULT WINAPI AntiMonikerImpl_IsDirty(IMoniker *iface)
Definition: antimoniker.c:157
static HRESULT WINAPI AntiMonikerROTDataImpl_GetComparisonData(IROTData *iface, BYTE *pbData, ULONG cbMax, ULONG *pcbData)
Definition: antimoniker.c:531
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
const GUID IID_IUnknown
#define FIXME(fmt,...)
Definition: debug.h:111
HRESULT WINAPI MonikerCommonPrefixWith(IMoniker *pmkThis, IMoniker *pmkOther, IMoniker **ppmkCommon)
HRESULT WINAPI CreateGenericComposite(IMoniker *pmkFirst, IMoniker *pmkRest, IMoniker **ppmkComposite)
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_NOTIMPL
Definition: ddrawi.h:99
#define E_FAIL
Definition: ddrawi.h:102
#define NULL
Definition: types.h:112
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
#define lstrcpyW
Definition: compat.h:749
HRESULT MonikerMarshal_Create(IMoniker *inner, IUnknown **outer)
Definition: moniker.c:1677
static void *static void *static LPDIRECTPLAY IUnknown * pUnk
Definition: dplayx.c:30
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint res
Definition: glext.h:9613
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
#define debugstr_guid
Definition: kernel32.h:35
unsigned int ULONG
Definition: retypes.h:1
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static LPOLESTR
Definition: stg_prop.c:27
IID CLSID
Definition: mstsclib_i.c:62
#define DWORD
Definition: nt_native.h:44
long LONG
Definition: pedump.c:60
const GUID IID_IPersist
Definition: proxy.cpp:14
const GUID IID_IPersistStream
Definition: proxy.cpp:13
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define REFIID
Definition: guiddef.h:118
HRESULT hr
Definition: shlfolder.c:183
#define TRACE(s)
Definition: solgame.cpp:4
IUnknown * pMarshal
Definition: antimoniker.c:42
IROTData IROTData_iface
Definition: antimoniker.c:40
IMoniker IMoniker_iface
Definition: antimoniker.c:39
struct _ULARGE_INTEGER::@3937 u
Definition: send.c:48
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
_In_ HCRYPTHASH _In_ BOOL _In_ DWORD _Inout_updates_bytes_to_ pdwDataLen BYTE * pbData
Definition: wincrypt.h:4201
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD _Outptr_opt_ void ** ppvObject
Definition: wincrypt.h:6082
_In_ DWORD _Out_writes_bytes_to_opt_ pcbData void _Inout_ DWORD * pcbData
Definition: wincrypt.h:4950
#define WINAPI
Definition: msvc.h:6
#define S_FALSE
Definition: winerror.h:2357
#define MK_S_REDUCED_TO_SELF
Definition: winerror.h:2773
#define E_NOINTERFACE
Definition: winerror.h:2364
#define MK_E_NOINVERSE
Definition: winerror.h:2793
#define CLASS_E_NOAGGREGATION
Definition: winerror.h:2662
#define MK_E_NEEDGENERIC
Definition: winerror.h:2783
#define MK_S_HIM
Definition: winerror.h:2775
#define E_POINTER
Definition: winerror.h:2365
#define STG_E_INSUFFICIENTMEMORY
Definition: winerror.h:2570
#define MK_S_US
Definition: winerror.h:2776
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned char BYTE
Definition: xxhash.c:193