Google Git
Sign in
goma / wine / ed494ec5398d908ce52e4854f76e4ada7e035335 / . / ole / antimoniker.c
blob: 9fd18338d6c836ef8666eb214159dd7c5d8aaddd [file] [log] [blame]
Noomen Hamzaed494ec1999-03-23 13:48:56 +0000[diff] [blame^]1/***************************************************************************************
2 * AntiMonikers implementation
3 *
4 * Copyright 1999 Noomen Hamza
5 ***************************************************************************************/
6
7#include <assert.h>
8#include "winerror.h"
9#include "debug.h"
10#include "heap.h"
11#include "winuser.h"
12#include "file.h"
13#include "winreg.h"
14#include "objbase.h"
15#include "wine/obj_inplace.h"
16
17/* AntiMoniker data structure */
18typedef struct AntiMonikerImpl{
19
20 ICOM_VTABLE(IMoniker)* lpvtbl1; /* VTable relative to the IMoniker interface.*/
21
22 /* The ROT (RunningObjectTable implementation) uses the IROTData interface to test whether
23 * two monikers are equal. That's whay IROTData interface is implemented by monikers.
24 */
25 ICOM_VTABLE(IROTData)* lpvtbl2; /* VTable relative to the IROTData interface.*/
26
27 ULONG ref; /* reference counter for this object */
28
29} AntiMonikerImpl;
30
31/********************************************************************************/
32/* AntiMoniker prototype functions : */
33
34/* IUnknown prototype functions */
35static HRESULT WINAPI AntiMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject);
36static ULONG WINAPI AntiMonikerImpl_AddRef(IMoniker* iface);
37static ULONG WINAPI AntiMonikerImpl_Release(IMoniker* iface);
38
39/* IPersist prototype functions */
40static HRESULT WINAPI AntiMonikerImpl_GetClassID(const IMoniker* iface, CLSID *pClassID);
41
42/* IPersistStream prototype functions */
43static HRESULT WINAPI AntiMonikerImpl_IsDirty(IMoniker* iface);
44static HRESULT WINAPI AntiMonikerImpl_Load(IMoniker* iface, IStream* pStm);
45static HRESULT WINAPI AntiMonikerImpl_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty);
46static HRESULT WINAPI AntiMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize);
47
48/* IMoniker prototype functions */
49static HRESULT WINAPI AntiMonikerImpl_BindToObject(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
50static HRESULT WINAPI AntiMonikerImpl_BindToStorage(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
51static HRESULT WINAPI AntiMonikerImpl_Reduce(IMoniker* iface,IBindCtx* pbc, DWORD dwReduceHowFar,IMoniker** ppmkToLeft, IMoniker** ppmkReduced);
52static HRESULT WINAPI AntiMonikerImpl_ComposeWith(IMoniker* iface,IMoniker* pmkRight,BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite);
53static HRESULT WINAPI AntiMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker);
54static HRESULT WINAPI AntiMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker);
55static HRESULT WINAPI AntiMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash);
56static HRESULT WINAPI AntiMonikerImpl_IsRunning(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning);
57static HRESULT WINAPI AntiMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, FILETIME* pAntiTime);
58static HRESULT WINAPI AntiMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk);
59static HRESULT WINAPI AntiMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther, IMoniker** ppmkPrefix);
60static HRESULT WINAPI AntiMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath);
61static HRESULT WINAPI AntiMonikerImpl_GetDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName);
62static HRESULT WINAPI AntiMonikerImpl_ParseDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut);
63static HRESULT WINAPI AntiMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys);
64
65/********************************************************************************/
66/* IROTData prototype functions */
67
68/* IUnknown prototype functions */
69static HRESULT WINAPI AntiMonikerROTDataImpl_QueryInterface(IROTData* iface,REFIID riid,VOID** ppvObject);
70static ULONG WINAPI AntiMonikerROTDataImpl_AddRef(IROTData* iface);
71static ULONG WINAPI AntiMonikerROTDataImpl_Release(IROTData* iface);
72
73/* IROTData prototype function */
74static HRESULT WINAPI AntiMonikerROTDataImpl_GetComparaisonData(IROTData* iface,BYTE* pbData,ULONG cbMax,ULONG* pcbData);
75
76/* Local function used by AntiMoniker implementation */
77HRESULT WINAPI AntiMonikerImpl_Construct(AntiMonikerImpl* iface);
78HRESULT WINAPI AntiMonikerImpl_Destroy(AntiMonikerImpl* iface);
79
80/********************************************************************************/
81/* Virtual function table for the AntiMonikerImpl class witch include Ipersist,*/
82/* IPersistStream and IMoniker functions. */
83static ICOM_VTABLE(IMoniker) VT_AntiMonikerImpl =
84{
85 AntiMonikerImpl_QueryInterface,
86 AntiMonikerImpl_AddRef,
87 AntiMonikerImpl_Release,
88 AntiMonikerImpl_GetClassID,
89 AntiMonikerImpl_IsDirty,
90 AntiMonikerImpl_Load,
91 AntiMonikerImpl_Save,
92 AntiMonikerImpl_GetSizeMax,
93 AntiMonikerImpl_BindToObject,
94 AntiMonikerImpl_BindToStorage,
95 AntiMonikerImpl_Reduce,
96 AntiMonikerImpl_ComposeWith,
97 AntiMonikerImpl_Enum,
98 AntiMonikerImpl_IsEqual,
99 AntiMonikerImpl_Hash,
100 AntiMonikerImpl_IsRunning,
101 AntiMonikerImpl_GetTimeOfLastChange,
102 AntiMonikerImpl_Inverse,
103 AntiMonikerImpl_CommonPrefixWith,
104 AntiMonikerImpl_RelativePathTo,
105 AntiMonikerImpl_GetDisplayName,
106 AntiMonikerImpl_ParseDisplayName,
107 AntiMonikerImpl_IsSystemMoniker
108};
109
110/********************************************************************************/
111/* Virtual function table for the IROTData class. */
112static ICOM_VTABLE(IROTData) VT_ROTDataImpl =
113{
114 AntiMonikerROTDataImpl_QueryInterface,
115 AntiMonikerROTDataImpl_AddRef,
116 AntiMonikerROTDataImpl_Release,
117 AntiMonikerROTDataImpl_GetComparaisonData
118};
119
120/*******************************************************************************
121 * AntiMoniker_QueryInterface
122 *******************************************************************************/
123HRESULT WINAPI AntiMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
124{
125 ICOM_THIS(AntiMonikerImpl,iface);
126
127 TRACE(ole,"(%p,%p,%p)\n",This,riid,ppvObject);
128
129 /* Perform a sanity check on the parameters.*/
130 if ( (This==0) || (ppvObject==0) )
131 return E_INVALIDARG;
132
133 /* Initialize the return parameter */
134 *ppvObject = 0;
135
136 /* Compare the riid with the interface IDs implemented by this object.*/
137 if (IsEqualIID(&IID_IUnknown, riid) ||
138 IsEqualIID(&IID_IPersist, riid) ||
139 IsEqualIID(&IID_IPersistStream, riid) ||
140 IsEqualIID(&IID_IMoniker, riid)
141 )
142 *ppvObject = iface;
143 else if (IsEqualIID(&IID_IROTData, riid))
144 *ppvObject = (IROTData*)&(This->lpvtbl2);
145
146 /* Check that we obtained an interface.*/
147 if ((*ppvObject)==0)
148 return E_NOINTERFACE;
149
150 /* Query Interface always increases the reference count by one when it is successful */
151 AntiMonikerImpl_AddRef(iface);
152
153 return S_OK;
154}
155
156/******************************************************************************
157 * AntiMoniker_AddRef
158 ******************************************************************************/
159ULONG WINAPI AntiMonikerImpl_AddRef(IMoniker* iface)
160{
161 ICOM_THIS(AntiMonikerImpl,iface);
162
163 TRACE(ole,"(%p)\n",This);
164
165 return ++(This->ref);
166}
167
168/******************************************************************************
169 * AntiMoniker_Release
170 ******************************************************************************/
171ULONG WINAPI AntiMonikerImpl_Release(IMoniker* iface)
172{
173 ICOM_THIS(AntiMonikerImpl,iface);
174
175 TRACE(ole,"(%p)\n",This);
176
177 This->ref--;
178
179 /* destroy the object if there's no more reference on it */
180 if (This->ref==0){
181
182 AntiMonikerImpl_Destroy(This);
183
184 return 0;
185 }
186 return This->ref;;
187}
188
189/******************************************************************************
190 * AntiMoniker_GetClassID
191 ******************************************************************************/
192HRESULT WINAPI AntiMonikerImpl_GetClassID(const IMoniker* iface,CLSID *pClassID)
193{
194 TRACE(ole,"(%p,%p),stub!\n",iface,pClassID);
195
196 if (pClassID==NULL)
197 return E_POINTER;
198
199 *pClassID = CLSID_AntiMoniker;
200
201 return S_OK;
202}
203
204/******************************************************************************
205 * AntiMoniker_IsDirty
206 ******************************************************************************/
207HRESULT WINAPI AntiMonikerImpl_IsDirty(IMoniker* iface)
208{
209 /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
210 method in the OLE-provided moniker interfaces always return S_FALSE because
211 their internal state never changes. */
212
213 TRACE(ole,"(%p)\n",iface);
214
215 return S_FALSE;
216}
217
218/******************************************************************************
219 * AntiMoniker_Load
220 ******************************************************************************/
221HRESULT WINAPI AntiMonikerImpl_Load(IMoniker* iface,IStream* pStm)
222{
223 DWORD constant=1,dwbuffer;
224 HRESULT res;
225
226 /* data read by this function is only a DWORD constant (must be 1) ! */
227 res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),NULL);
228
229 if (SUCCEEDED(res)&& dwbuffer!=constant)
230 return E_FAIL;
231
232 return res;
233}
234
235/******************************************************************************
236 * AntiMoniker_Save
237 ******************************************************************************/
238HRESULT WINAPI AntiMonikerImpl_Save(IMoniker* iface,IStream* pStm,BOOL fClearDirty)
239{
240 DWORD constant=1;
241 HRESULT res;
242
243 /* data writen by this function is only a DWORD constant seted to 1 ! */
244 res=IStream_Write(pStm,&constant,sizeof(constant),NULL);
245
246 return res;
247}
248
249/******************************************************************************
250 * AntiMoniker_GetSizeMax
251 ******************************************************************************/
252HRESULT WINAPI AntiMonikerImpl_GetSizeMax(IMoniker* iface,
253 ULARGE_INTEGER* pcbSize)/* Pointer to size of stream needed to save object */
254{
255 TRACE(ole,"(%p,%p)\n",iface,pcbSize);
256
257 if (pcbSize!=NULL)
258 return E_POINTER;
259
260 /* for more details see AntiMonikerImpl_Save coments */
261
262 /* Normaly the sizemax must be the size of DWORD ! but I tested this function it ususlly return 16 bytes */
263 /* more than the number of bytes used by AntiMoniker::Save function */
264 pcbSize->LowPart = sizeof(DWORD)+16;
265
266 pcbSize->HighPart=0;
267
268 return S_OK;
269}
270
271/******************************************************************************
272 * AntiMoniker_Construct (local function)
273 *******************************************************************************/
274HRESULT WINAPI AntiMonikerImpl_Construct(AntiMonikerImpl* This)
275{
276
277 TRACE(ole,"(%p)\n",This);
278
279 /* Initialize the virtual fgunction table. */
280 This->lpvtbl1 = &VT_AntiMonikerImpl;
281 This->lpvtbl2 = &VT_ROTDataImpl;
282 This->ref = 0;
283
284 return S_OK;
285}
286
287/******************************************************************************
288 * AntiMoniker_Destroy (local function)
289 *******************************************************************************/
290HRESULT WINAPI AntiMonikerImpl_Destroy(AntiMonikerImpl* This)
291{
292 TRACE(ole,"(%p)\n",This);
293
294 return HeapFree(GetProcessHeap(),0,This);
295}
296
297/******************************************************************************
298 * AntiMoniker_BindToObject
299 ******************************************************************************/
300HRESULT WINAPI AntiMonikerImpl_BindToObject(IMoniker* iface,
301 IBindCtx* pbc,
302 IMoniker* pmkToLeft,
303 REFIID riid,
304 VOID** ppvResult)
305{
306 TRACE(ole,"(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
307 return E_NOTIMPL;
308}
309
310/******************************************************************************
311 * AntiMoniker_BindToStorage
312 ******************************************************************************/
313HRESULT WINAPI AntiMonikerImpl_BindToStorage(IMoniker* iface,
314 IBindCtx* pbc,
315 IMoniker* pmkToLeft,
316 REFIID riid,
317 VOID** ppvResult)
318{
319 TRACE(ole,"(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
320 return E_NOTIMPL;
321}
322
323/******************************************************************************
324 * AntiMoniker_Reduce
325 ******************************************************************************/
326HRESULT WINAPI AntiMonikerImpl_Reduce(IMoniker* iface,
327 IBindCtx* pbc,
328 DWORD dwReduceHowFar,
329 IMoniker** ppmkToLeft,
330 IMoniker** ppmkReduced)
331{
332 TRACE(ole,"(%p,%p,%ld,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
333
334 if (ppmkReduced==NULL)
335 return E_POINTER;
336
337 AntiMonikerImpl_AddRef(iface);
338
339 *ppmkReduced=iface;
340
341 return MK_S_REDUCED_TO_SELF;
342}
343/******************************************************************************
344 * AntiMoniker_ComposeWith
345 ******************************************************************************/
346HRESULT WINAPI AntiMonikerImpl_ComposeWith(IMoniker* iface,
347 IMoniker* pmkRight,
348 BOOL fOnlyIfNotGeneric,
349 IMoniker** ppmkComposite)
350{
351
352 TRACE(ole,"(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
353
354 if ((ppmkComposite==NULL)||(pmkRight==NULL))
355 return E_POINTER;
356
357 *ppmkComposite=0;
358
359 if (fOnlyIfNotGeneric)
360 return MK_E_NEEDGENERIC;
361 else
362 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
363}
364
365/******************************************************************************
366 * AntiMoniker_Enum
367 ******************************************************************************/
368HRESULT WINAPI AntiMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
369{
370 TRACE(ole,"(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
371
372 if (ppenumMoniker == NULL)
373 return E_POINTER;
374
375 *ppenumMoniker = NULL;
376
377 return S_OK;
378}
379
380/******************************************************************************
381 * AntiMoniker_IsEqual
382 ******************************************************************************/
383HRESULT WINAPI AntiMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
384{
385 DWORD mkSys;
386
387 TRACE(ole,"(%p,%p)\n",iface,pmkOtherMoniker);
388
389 if (pmkOtherMoniker==NULL)
390 return S_FALSE;
391
392 IMoniker_IsSystemMoniker(pmkOtherMoniker,&mkSys);
393
394 if (mkSys==MKSYS_ANTIMONIKER)
395 return S_OK;
396 else
397 return S_FALSE;
398}
399
400/******************************************************************************
401 * AntiMoniker_Hash
402 ******************************************************************************/
403HRESULT WINAPI AntiMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
404{
405 if (pdwHash==NULL)
406 return E_POINTER;
407
408 *pdwHash=0;
409
410 return S_OK;
411}
412
413/******************************************************************************
414 * AntiMoniker_IsRunning
415 ******************************************************************************/
416HRESULT WINAPI AntiMonikerImpl_IsRunning(IMoniker* iface,
417 IBindCtx* pbc,
418 IMoniker* pmkToLeft,
419 IMoniker* pmkNewlyRunning)
420{
421 IRunningObjectTable* rot;
422 HRESULT res;
423
424 TRACE(ole,"(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
425
426 if (pbc==NULL)
427 return E_INVALIDARG;
428
429 res=IBindCtx_GetRunningObjectTable(pbc,&rot);
430
431 if (FAILED(res))
432 return res;
433
434 res = IRunningObjectTable_IsRunning(rot,iface);
435
436 IRunningObjectTable_Release(rot);
437
438 return res;
439}
440
441/******************************************************************************
442 * AntiMoniker_GetTimeOfLastChange
443 ******************************************************************************/
444HRESULT WINAPI AntiMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
445 IBindCtx* pbc,
446 IMoniker* pmkToLeft,
447 FILETIME* pAntiTime)
448{
449 TRACE(ole,"(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pAntiTime);
450 return E_NOTIMPL;
451}
452
453/******************************************************************************
454 * AntiMoniker_Inverse
455 ******************************************************************************/
456HRESULT WINAPI AntiMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
457{
458 TRACE(ole,"(%p,%p)\n",iface,ppmk);
459
460 if (ppmk==NULL)
461 return E_POINTER;
462
463 *ppmk=0;
464
465 return MK_E_NOINVERSE;
466}
467
468/******************************************************************************
469 * AntiMoniker_CommonPrefixWith
470 ******************************************************************************/
471HRESULT WINAPI AntiMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
472{
473 DWORD mkSys;
474
475 IMoniker_IsSystemMoniker(pmkOther,&mkSys);
476
477 if(mkSys==MKSYS_ITEMMONIKER){
478
479 IMoniker_AddRef(iface);
480
481 *ppmkPrefix=iface;
482
483 IMoniker_AddRef(iface);
484
485 return MK_S_US;
486 }
487 else
488 return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
489}
490
491/******************************************************************************
492 * AntiMoniker_RelativePathTo
493 ******************************************************************************/
494HRESULT WINAPI AntiMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
495{
496 TRACE(ole,"(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
497
498 if (ppmkRelPath==NULL)
499 return E_POINTER;
500
501 IMoniker_AddRef(pmOther);
502
503 *ppmkRelPath=pmOther;
504
505 return MK_S_HIM;
506}
507
508/******************************************************************************
509 * AntiMoniker_GetDisplayName
510 ******************************************************************************/
511HRESULT WINAPI AntiMonikerImpl_GetDisplayName(IMoniker* iface,
512 IBindCtx* pbc,
513 IMoniker* pmkToLeft,
514 LPOLESTR *ppszDisplayName)
515{
516 WCHAR back[]={'\\','.','.',0};
517
518 TRACE(ole,"(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
519
520 if (ppszDisplayName==NULL)
521 return E_POINTER;
522
523 if (pmkToLeft!=NULL){
524 FIXME(ole,"() pmkToLeft!=NULL not implemented \n");
525 return E_NOTIMPL;
526 }
527
528 *ppszDisplayName=CoTaskMemAlloc(sizeof(back));
529
530 if (*ppszDisplayName==NULL)
531 return E_OUTOFMEMORY;
532
533 lstrcpyW(*ppszDisplayName,back);
534
535 return S_OK;
536}
537
538/******************************************************************************
539 * AntiMoniker_ParseDisplayName
540 ******************************************************************************/
541HRESULT WINAPI AntiMonikerImpl_ParseDisplayName(IMoniker* iface,
542 IBindCtx* pbc,
543 IMoniker* pmkToLeft,
544 LPOLESTR pszDisplayName,
545 ULONG* pchEaten,
546 IMoniker** ppmkOut)
547{
548 TRACE(ole,"(%p,%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
549 return E_NOTIMPL;
550}
551
552/******************************************************************************
553 * AntiMoniker_IsSystemMonker
554 ******************************************************************************/
555HRESULT WINAPI AntiMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
556{
557 TRACE(ole,"(%p,%p)\n",iface,pwdMksys);
558
559 if (!pwdMksys)
560 return E_POINTER;
561
562 (*pwdMksys)=MKSYS_ANTIMONIKER;
563
564 return S_OK;
565}
566
567/*******************************************************************************
568 * AntiMonikerIROTData_QueryInterface
569 *******************************************************************************/
570HRESULT WINAPI AntiMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
571{
572
573 ICOM_THIS_From_IROTData(IMoniker, iface);
574
575 TRACE(ole,"(%p,%p,%p)\n",iface,riid,ppvObject);
576
577 return AntiMonikerImpl_QueryInterface(This, riid, ppvObject);
578}
579
580/***********************************************************************
581 * AntiMonikerIROTData_AddRef
582 */
583ULONG WINAPI AntiMonikerROTDataImpl_AddRef(IROTData *iface)
584{
585 ICOM_THIS_From_IROTData(IMoniker, iface);
586
587 TRACE(ole,"(%p)\n",iface);
588
589 return AntiMonikerImpl_AddRef(This);
590}
591
592/***********************************************************************
593 * AntiMonikerIROTData_Release
594 */
595ULONG WINAPI AntiMonikerROTDataImpl_Release(IROTData* iface)
596{
597 ICOM_THIS_From_IROTData(IMoniker, iface);
598
599 TRACE(ole,"(%p)\n",iface);
600
601 return AntiMonikerImpl_Release(This);
602}
603
604/******************************************************************************
605 * AntiMonikerIROTData_GetComparaisonData
606 ******************************************************************************/
607HRESULT WINAPI AntiMonikerROTDataImpl_GetComparaisonData(IROTData* iface,
608 BYTE* pbData,
609 ULONG cbMax,
610 ULONG* pcbData)
611{
612 FIXME(ole,"(),stub!\n");
613 return E_NOTIMPL;
614}
615
616/******************************************************************************
617 * CreateAntiMoniker [OLE.55]
618 ******************************************************************************/
619HRESULT WINAPI CreateAntiMoniker(LPMONIKER * ppmk)
620{
621 AntiMonikerImpl* newAntiMoniker = 0;
622 HRESULT hr = S_OK;
623 IID riid=IID_IMoniker;
624
625 TRACE(ole,"(%p)\n",ppmk);
626
627 newAntiMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(AntiMonikerImpl));
628
629 if (newAntiMoniker == 0)
630 return STG_E_INSUFFICIENTMEMORY;
631
632 hr = AntiMonikerImpl_Construct(newAntiMoniker);
633
634 if (FAILED(hr)){
635
636 HeapFree(GetProcessHeap(),0,newAntiMoniker);
637 return hr;
638 }
639
640 hr = AntiMonikerImpl_QueryInterface((IMoniker*)newAntiMoniker,&riid,(void**)ppmk);
641
642 return hr;
643}