git.oblomov.eu Git - wine/blob - dlls/ole32/compositemoniker.c

   1 /*
   2  * CompositeMonikers 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 #define NONAMELESSSTRUCT
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winuser.h"
  32 #include "winerror.h"
  33 #include "wine/debug.h"
  34 #include "wine/unicode.h"
  35 #include "ole2.h"
  36 #include "moniker.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  39
  40 #define  BLOCK_TAB_SIZE 5 /* represent the first size table and it's increment block size */
  41
  42 /* CompositeMoniker data structure */
  43 typedef struct CompositeMonikerImpl{
  44
  45     const IMonikerVtbl*  lpvtbl1;  /* VTable relative to the IMoniker interface.*/
  46
  47     /* The ROT (RunningObjectTable implementation) uses the IROTData
  48      * interface to test whether two monikers are equal. That's why IROTData
  49      * interface is implemented by monikers.
  50      */
  51     const IROTDataVtbl*  lpvtbl2;  /* VTable relative to the IROTData interface.*/
  52
  53     const IMarshalVtbl*  lpvtblMarshal;  /* VTable relative to the IMarshal interface.*/
  54
  55     LONG ref; /* reference counter for this object */
  56
  57     IMoniker** tabMoniker; /* dynamaic table containing all components (monikers) of this composite moniker */
  58
  59     ULONG    tabSize;      /* size of tabMoniker */
  60
  61     ULONG    tabLastIndex;  /* first free index in tabMoniker */
  62
  63 } CompositeMonikerImpl;
  64
  65
  66 /* EnumMoniker data structure */
  67 typedef struct EnumMonikerImpl{
  68
  69     const IEnumMonikerVtbl *lpVtbl;  /* VTable relative to the IEnumMoniker interface.*/
  70
  71     LONG ref; /* reference counter for this object */
  72
  73     IMoniker** tabMoniker; /* dynamic table containing the enumerated monikers */
  74
  75     ULONG      tabSize; /* size of tabMoniker */
  76
  77     ULONG      currentPos;  /* index pointer on the current moniker */
  78
  79 } EnumMonikerImpl;
  80
  81 static inline IMoniker *impl_from_IROTData( IROTData *iface )
  82 {
  83     return (IMoniker *)((char*)iface - FIELD_OFFSET(CompositeMonikerImpl, lpvtbl2));
  84 }
  85
  86 static inline IMoniker *impl_from_IMarshal( IMarshal *iface )
  87 {
  88     return (IMoniker *)((char*)iface - FIELD_OFFSET(CompositeMonikerImpl, lpvtblMarshal));
  89 }
  90
  91 static HRESULT EnumMonikerImpl_CreateEnumMoniker(IMoniker** tabMoniker,ULONG tabSize,ULONG currentPos,BOOL leftToRigth,IEnumMoniker ** ppmk);
  92
  93 /*******************************************************************************
  94  *        CompositeMoniker_QueryInterface
  95  *******************************************************************************/
  96 static HRESULT WINAPI
  97 CompositeMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
  98 {
  99     CompositeMonikerImpl *This = (CompositeMonikerImpl *)iface;
 100
 101     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
 102
 103     /* Perform a sanity check on the parameters.*/
 104     if ( (This==0) || (ppvObject==0) )
 105         return E_INVALIDARG;
 106
 107     /* Initialize the return parameter */
 108     *ppvObject = 0;
 109
 110     /* Compare the riid with the interface IDs implemented by this object.*/
 111     if (IsEqualIID(&IID_IUnknown, riid) ||
 112         IsEqualIID(&IID_IPersist, riid) ||
 113         IsEqualIID(&IID_IPersistStream, riid) ||
 114         IsEqualIID(&IID_IMoniker, riid)
 115        )
 116         *ppvObject = iface;
 117     else if (IsEqualIID(&IID_IROTData, riid))
 118         *ppvObject = (IROTData*)&(This->lpvtbl2);
 119     else if (IsEqualIID(&IID_IMarshal, riid))
 120         *ppvObject = (IROTData*)&(This->lpvtblMarshal);
 121
 122     /* Check that we obtained an interface.*/
 123     if ((*ppvObject)==0)
 124         return E_NOINTERFACE;
 125
 126     /* Query Interface always increases the reference count by one when it is successful */
 127     IMoniker_AddRef(iface);
 128
 129     return S_OK;
 130 }
 131
 132 /******************************************************************************
 133  *        CompositeMoniker_AddRef
 134  ******************************************************************************/
 135 static ULONG WINAPI
 136 CompositeMonikerImpl_AddRef(IMoniker* iface)
 137 {
 138     CompositeMonikerImpl *This = (CompositeMonikerImpl *)iface;
 139
 140     TRACE("(%p)\n",This);
 141
 142     return InterlockedIncrement(&This->ref);
 143 }
 144
 145 static void CompositeMonikerImpl_ReleaseMonikersInTable(CompositeMonikerImpl *This)
 146 {
 147     ULONG i;
 148
 149     for (i = 0; i < This->tabLastIndex; i++)
 150         IMoniker_Release(This->tabMoniker[i]);
 151
 152     This->tabLastIndex = 0;
 153 }
 154
 155 /******************************************************************************
 156  *        CompositeMoniker_Release
 157  ******************************************************************************/
 158 static ULONG WINAPI
 159 CompositeMonikerImpl_Release(IMoniker* iface)
 160 {
 161     CompositeMonikerImpl *This = (CompositeMonikerImpl *)iface;
 162     ULONG ref;
 163
 164     TRACE("(%p)\n",This);
 165
 166     ref = InterlockedDecrement(&This->ref);
 167
 168     /* destroy the object if there's no more reference on it */
 169     if (ref == 0){
 170
 171         /* release all the components before destroying this object */
 172         CompositeMonikerImpl_ReleaseMonikersInTable(This);
 173
 174         HeapFree(GetProcessHeap(),0,This->tabMoniker);
 175         HeapFree(GetProcessHeap(),0,This);
 176     }
 177     return ref;
 178 }
 179
 180 /******************************************************************************
 181  *        CompositeMoniker_GetClassID
 182  ******************************************************************************/
 183 static HRESULT WINAPI
 184 CompositeMonikerImpl_GetClassID(IMoniker* iface,CLSID *pClassID)
 185 {
 186     TRACE("(%p,%p)\n",iface,pClassID);
 187
 188     if (pClassID==NULL)
 189         return E_POINTER;
 190
 191     *pClassID = CLSID_CompositeMoniker;
 192
 193     return S_OK;
 194 }
 195
 196 /******************************************************************************
 197  *        CompositeMoniker_IsDirty
 198  ******************************************************************************/
 199 static HRESULT WINAPI
 200 CompositeMonikerImpl_IsDirty(IMoniker* iface)
 201 {
 202     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
 203        method in the OLE-provided moniker interfaces always return S_FALSE because
 204        their internal state never changes. */
 205
 206     TRACE("(%p)\n",iface);
 207
 208     return S_FALSE;
 209 }
 210
 211 /******************************************************************************
 212  *        CompositeMoniker_Load
 213  ******************************************************************************/
 214 static HRESULT WINAPI
 215 CompositeMonikerImpl_Load(IMoniker* iface,IStream* pStm)
 216 {
 217     HRESULT res;
 218     DWORD moniker_count;
 219     DWORD i;
 220
 221     CompositeMonikerImpl *This = (CompositeMonikerImpl *)iface;
 222
 223     TRACE("(%p,%p)\n",iface,pStm);
 224
 225     /* this function call OleLoadFromStream function for each moniker within this object */
 226
 227     res=IStream_Read(pStm,&moniker_count,sizeof(DWORD),NULL);
 228     if (res != S_OK)
 229     {
 230         ERR("couldn't reading moniker count from stream\n");
 231         return E_FAIL;
 232     }
 233
 234     CompositeMonikerImpl_ReleaseMonikersInTable(This);
 235
 236     for (i = 0; i < moniker_count; i++)
 237     {
 238         res=OleLoadFromStream(pStm,&IID_IMoniker,(void**)&This->tabMoniker[This->tabLastIndex]);
 239         if (FAILED(res))
 240         {
 241             ERR("couldn't load moniker from stream, res = 0x%08x\n", res);
 242             break;
 243         }
 244
 245         /* resize the table if needed */
 246         if (++This->tabLastIndex==This->tabSize){
 247
 248             This->tabSize+=BLOCK_TAB_SIZE;
 249             This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(IMoniker));
 250
 251             if (This->tabMoniker==NULL)
 252             return E_OUTOFMEMORY;
 253         }
 254     }
 255
 256     return res;
 257 }
 258
 259 /******************************************************************************
 260  *        CompositeMoniker_Save
 261  ******************************************************************************/
 262 static HRESULT WINAPI
 263 CompositeMonikerImpl_Save(IMoniker* iface,IStream* pStm,BOOL fClearDirty)
 264 {
 265     CompositeMonikerImpl *This = (CompositeMonikerImpl *)iface;
 266     HRESULT res;
 267     IEnumMoniker *enumMk;
 268     IMoniker *pmk;
 269     DWORD moniker_count = This->tabLastIndex;
 270
 271     TRACE("(%p,%p,%d)\n",iface,pStm,fClearDirty);
 272
 273     /* This function calls OleSaveToStream function for each moniker within
 274      * this object.
 275      * When I tested this function in windows, I usually found this constant
 276      * at the beginning of the stream. I don't known why (there's no
 277      * indication in the specification) !
 278      */
 279     res=IStream_Write(pStm,&moniker_count,sizeof(moniker_count),NULL);
 280     if (FAILED(res)) return res;
 281
 282     IMoniker_Enum(iface,TRUE,&enumMk);
 283
 284     while(IEnumMoniker_Next(enumMk,1,&pmk,NULL)==S_OK){
 285
 286         res=OleSaveToStream((IPersistStream*)pmk,pStm);
 287
 288         IMoniker_Release(pmk);
 289
 290         if (FAILED(res)){
 291
 292             IEnumMoniker_Release(enumMk);
 293             return res;
 294         }
 295     }
 296
 297     IEnumMoniker_Release(enumMk);
 298
 299     return S_OK;
 300 }
 301
 302 /******************************************************************************
 303  *        CompositeMoniker_GetSizeMax
 304  ******************************************************************************/
 305 static HRESULT WINAPI
 306 CompositeMonikerImpl_GetSizeMax(IMoniker* iface,ULARGE_INTEGER* pcbSize)
 307 {
 308     IEnumMoniker *enumMk;
 309     IMoniker *pmk;
 310     ULARGE_INTEGER ptmpSize;
 311
 312     /* The sizeMax of this object is calculated by calling  GetSizeMax on
 313      * each moniker within this object then summing all returned values
 314      */
 315
 316     TRACE("(%p,%p)\n",iface,pcbSize);
 317
 318     if (!pcbSize)
 319         return E_POINTER;
 320
 321     pcbSize->QuadPart = sizeof(DWORD);
 322
 323     IMoniker_Enum(iface,TRUE,&enumMk);
 324
 325     while(IEnumMoniker_Next(enumMk,1,&pmk,NULL)==S_OK){
 326
 327         IMoniker_GetSizeMax(pmk,&ptmpSize);
 328
 329         IMoniker_Release(pmk);
 330
 331         pcbSize->QuadPart = ptmpSize.QuadPart + sizeof(CLSID);
 332     }
 333
 334     IEnumMoniker_Release(enumMk);
 335
 336     return S_OK;
 337 }
 338
 339 /******************************************************************************
 340  *                  CompositeMoniker_BindToObject
 341  ******************************************************************************/
 342 static HRESULT WINAPI
 343 CompositeMonikerImpl_BindToObject(IMoniker* iface, IBindCtx* pbc,
 344                IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult)
 345 {
 346     HRESULT   res;
 347     IRunningObjectTable *prot;
 348     IMoniker *tempMk,*antiMk,*mostRigthMk;
 349     IEnumMoniker *enumMoniker;
 350
 351     TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
 352
 353     if (ppvResult==NULL)
 354         return E_POINTER;
 355
 356     *ppvResult=0;
 357     /* If pmkToLeft is NULL, this method looks for the moniker in the ROT, and if found, queries the retrieved */
 358     /* object for the requested interface pointer. */
 359     if(pmkToLeft==NULL){
 360
 361         res=IBindCtx_GetRunningObjectTable(pbc,&prot);
 362
 363         if (SUCCEEDED(res)){
 364
 365             /* if the requested class was loaded before ! we don't need to reload it */
 366             res = IRunningObjectTable_GetObject(prot,iface,(IUnknown**)ppvResult);
 367
 368             if (res==S_OK)
 369                 return res;
 370         }
 371     }
 372     else{
 373         /* If pmkToLeft is not NULL, the method recursively calls IMoniker::BindToObject on the rightmost */
 374         /* component of the composite, passing the rest of the composite as the pmkToLeft parameter for that call */
 375
 376         IMoniker_Enum(iface,FALSE,&enumMoniker);
 377         IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
 378         IEnumMoniker_Release(enumMoniker);
 379
 380         res=CreateAntiMoniker(&antiMk);
 381         res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
 382         IMoniker_Release(antiMk);
 383
 384         res=IMoniker_BindToObject(mostRigthMk,pbc,tempMk,riid,ppvResult);
 385
 386         IMoniker_Release(tempMk);
 387         IMoniker_Release(mostRigthMk);
 388     }
 389
 390     return res;
 391 }
 392
 393 /******************************************************************************
 394  *        CompositeMoniker_BindToStorage
 395  ******************************************************************************/
 396 static HRESULT WINAPI
 397 CompositeMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc,
 398                IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult)
 399 {
 400     HRESULT   res;
 401     IMoniker *tempMk,*antiMk,*mostRigthMk,*leftMk;
 402     IEnumMoniker *enumMoniker;
 403
 404     TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
 405
 406     *ppvResult=0;
 407
 408     /* This method recursively calls BindToStorage on the rightmost component of the composite, */
 409     /* passing the rest of the composite as the pmkToLeft parameter for that call. */
 410
 411     if (pmkToLeft)
 412     {
 413         res = IMoniker_ComposeWith(pmkToLeft, iface, FALSE, &leftMk);
 414         if (FAILED(res)) return res;
 415     }
 416     else
 417         leftMk = iface;
 418
 419     IMoniker_Enum(iface, FALSE, &enumMoniker);
 420     IEnumMoniker_Next(enumMoniker, 1, &mostRigthMk, NULL);
 421     IEnumMoniker_Release(enumMoniker);
 422
 423     res = CreateAntiMoniker(&antiMk);
 424     if (FAILED(res)) return res;
 425     res = IMoniker_ComposeWith(leftMk, antiMk, 0, &tempMk);
 426     if (FAILED(res)) return res;
 427     IMoniker_Release(antiMk);
 428
 429     res = IMoniker_BindToStorage(mostRigthMk, pbc, tempMk, riid, ppvResult);
 430
 431     IMoniker_Release(tempMk);
 432
 433     IMoniker_Release(mostRigthMk);
 434
 435     if (pmkToLeft)
 436         IMoniker_Release(leftMk);
 437
 438     return res;
 439 }
 440
 441 /******************************************************************************
 442  *        CompositeMoniker_Reduce
 443  ******************************************************************************/
 444 static HRESULT WINAPI
 445 CompositeMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
 446                IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
 447 {
 448     HRESULT   res;
 449     IMoniker *tempMk,*antiMk,*mostRigthMk,*leftReducedComposedMk,*mostRigthReducedMk;
 450     IEnumMoniker *enumMoniker;
 451
 452     TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
 453
 454     if (ppmkReduced==NULL)
 455         return E_POINTER;
 456
 457     /* This method recursively calls Reduce for each of its component monikers. */
 458
 459     if (ppmkToLeft==NULL){
 460
 461         IMoniker_Enum(iface,FALSE,&enumMoniker);
 462         IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
 463         IEnumMoniker_Release(enumMoniker);
 464
 465         res=CreateAntiMoniker(&antiMk);
 466         res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
 467         IMoniker_Release(antiMk);
 468
 469         return IMoniker_Reduce(mostRigthMk,pbc,dwReduceHowFar,&tempMk, ppmkReduced);
 470     }
 471     else if (*ppmkToLeft==NULL)
 472
 473         return IMoniker_Reduce(iface,pbc,dwReduceHowFar,NULL,ppmkReduced);
 474
 475     else{
 476
 477         /* separate the composite moniker in to left and right moniker */
 478         IMoniker_Enum(iface,FALSE,&enumMoniker);
 479         IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
 480         IEnumMoniker_Release(enumMoniker);
 481
 482         res=CreateAntiMoniker(&antiMk);
 483         res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
 484         IMoniker_Release(antiMk);
 485
 486         /* If any of the components  reduces itself, the method returns S_OK and passes back a composite */
 487         /* of the reduced components */
 488         if (IMoniker_Reduce(mostRigthMk,pbc,dwReduceHowFar,NULL,&mostRigthReducedMk) &&
 489             IMoniker_Reduce(mostRigthMk,pbc,dwReduceHowFar,&tempMk,&leftReducedComposedMk)
 490            )
 491
 492             return CreateGenericComposite(leftReducedComposedMk,mostRigthReducedMk,ppmkReduced);
 493
 494         else{
 495             /* If no reduction occurred, the method passes back the same moniker and returns MK_S_REDUCED_TO_SELF.*/
 496
 497             IMoniker_AddRef(iface);
 498
 499             *ppmkReduced=iface;
 500
 501             return MK_S_REDUCED_TO_SELF;
 502         }
 503     }
 504 }
 505
 506 /******************************************************************************
 507  *        CompositeMoniker_ComposeWith
 508  ******************************************************************************/
 509 static HRESULT WINAPI
 510 CompositeMonikerImpl_ComposeWith(IMoniker* iface, IMoniker* pmkRight,
 511                BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
 512 {
 513     TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
 514
 515     if ((ppmkComposite==NULL)||(pmkRight==NULL))
 516         return E_POINTER;
 517
 518     *ppmkComposite=0;
 519
 520     /* If fOnlyIfNotGeneric is TRUE, this method sets *pmkComposite to NULL and returns MK_E_NEEDGENERIC; */
 521     /* otherwise, the method returns the result of combining the two monikers by calling the */
 522     /* CreateGenericComposite function */
 523
 524     if (fOnlyIfNotGeneric)
 525         return MK_E_NEEDGENERIC;
 526
 527     return CreateGenericComposite(iface,pmkRight,ppmkComposite);
 528 }
 529
 530 /******************************************************************************
 531  *        CompositeMoniker_Enum
 532  ******************************************************************************/
 533 static HRESULT WINAPI
 534 CompositeMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
 535 {
 536     CompositeMonikerImpl *This = (CompositeMonikerImpl *)iface;
 537
 538     TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
 539
 540     if (ppenumMoniker == NULL)
 541         return E_POINTER;
 542
 543     return EnumMonikerImpl_CreateEnumMoniker(This->tabMoniker,This->tabLastIndex,0,fForward,ppenumMoniker);
 544 }
 545
 546 /******************************************************************************
 547  *        CompositeMoniker_IsEqual
 548  ******************************************************************************/
 549 static HRESULT WINAPI
 550 CompositeMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
 551 {
 552     IEnumMoniker *enumMoniker1,*enumMoniker2;
 553     IMoniker *tempMk1,*tempMk2;
 554     HRESULT res1,res2,res;
 555
 556     TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
 557
 558     if (pmkOtherMoniker==NULL)
 559         return S_FALSE;
 560
 561     /* This method returns S_OK if the components of both monikers are equal when compared in the */
 562     /* left-to-right order.*/
 563     IMoniker_Enum(pmkOtherMoniker,TRUE,&enumMoniker1);
 564
 565     if (enumMoniker1==NULL)
 566         return S_FALSE;
 567
 568     IMoniker_Enum(iface,TRUE,&enumMoniker2);
 569
 570     while(1){
 571
 572         res1=IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
 573         res2=IEnumMoniker_Next(enumMoniker2,1,&tempMk2,NULL);
 574
 575         if((res1==S_OK)&&(res2==S_OK)){
 576
 577             if(IMoniker_IsEqual(tempMk1,tempMk2)==S_FALSE){
 578                 res= S_FALSE;
 579                 break;
 580             }
 581             else
 582                 continue;
 583         }
 584         else if ( (res1==S_FALSE) && (res2==S_FALSE) ){
 585                 res = S_OK;
 586                 break;
 587         }
 588         else{
 589             res = S_FALSE;
 590             break;
 591         }
 592
 593         if (res1==S_OK)
 594             IMoniker_Release(tempMk1);
 595
 596         if (res2==S_OK)
 597             IMoniker_Release(tempMk2);
 598     }
 599
 600     IEnumMoniker_Release(enumMoniker1);
 601     IEnumMoniker_Release(enumMoniker2);
 602
 603     return res;
 604 }
 605 /******************************************************************************
 606  *        CompositeMoniker_Hash
 607  ******************************************************************************/
 608 static HRESULT WINAPI
 609 CompositeMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
 610 {
 611     IEnumMoniker *enumMoniker;
 612     IMoniker *tempMk;
 613     HRESULT res;
 614     DWORD tempHash;
 615
 616     TRACE("(%p,%p)\n",iface,pdwHash);
 617
 618     if (pdwHash==NULL)
 619         return E_POINTER;
 620
 621     res = IMoniker_Enum(iface,TRUE,&enumMoniker);
 622     if(FAILED(res))
 623         return res;
 624
 625     *pdwHash = 0;
 626
 627     while(IEnumMoniker_Next(enumMoniker,1,&tempMk,NULL)==S_OK){
 628         res = IMoniker_Hash(tempMk, &tempHash);
 629         if(FAILED(res))
 630             break;
 631         *pdwHash = *pdwHash ^ tempHash;
 632
 633         IMoniker_Release(tempMk);
 634     }
 635
 636     IEnumMoniker_Release(enumMoniker);
 637
 638     return res;
 639 }
 640
 641 /******************************************************************************
 642  *        CompositeMoniker_IsRunning
 643  ******************************************************************************/
 644 static HRESULT WINAPI
 645 CompositeMonikerImpl_IsRunning(IMoniker* iface, IBindCtx* pbc,
 646                IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning)
 647 {
 648     IRunningObjectTable* rot;
 649     HRESULT res;
 650     IMoniker *tempMk,*antiMk,*mostRigthMk;
 651     IEnumMoniker *enumMoniker;
 652
 653     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
 654
 655     /* If pmkToLeft is non-NULL, this method composes pmkToLeft with this moniker and calls IsRunning on the result.*/
 656     if (pmkToLeft!=NULL){
 657
 658         CreateGenericComposite(pmkToLeft,iface,&tempMk);
 659
 660         res = IMoniker_IsRunning(tempMk,pbc,NULL,pmkNewlyRunning);
 661
 662         IMoniker_Release(tempMk);
 663
 664         return res;
 665     }
 666     else
 667         /* If pmkToLeft is NULL, this method returns S_OK if pmkNewlyRunning is non-NULL and is equal */
 668         /* to this moniker */
 669
 670         if (pmkNewlyRunning!=NULL)
 671
 672             if (IMoniker_IsEqual(iface,pmkNewlyRunning)==S_OK)
 673                 return S_OK;
 674
 675             else
 676                 return S_FALSE;
 677
 678         else{
 679
 680             if (pbc==NULL)
 681                 return E_POINTER;
 682
 683             /* If pmkToLeft and pmkNewlyRunning are both NULL, this method checks the ROT to see whether */
 684             /* the moniker is running. If so, the method returns S_OK; otherwise, it recursively calls   */
 685             /* IMoniker::IsRunning on the rightmost component of the composite, passing the remainder of */
 686             /* the composite as the pmkToLeft parameter for that call.                                   */
 687
 688              res=IBindCtx_GetRunningObjectTable(pbc,&rot);
 689
 690             if (FAILED(res))
 691                 return res;
 692
 693             res = IRunningObjectTable_IsRunning(rot,iface);
 694             IRunningObjectTable_Release(rot);
 695
 696             if(res==S_OK)
 697                 return S_OK;
 698
 699             else{
 700
 701                 IMoniker_Enum(iface,FALSE,&enumMoniker);
 702                 IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
 703                 IEnumMoniker_Release(enumMoniker);
 704
 705                 res=CreateAntiMoniker(&antiMk);
 706                 res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
 707                 IMoniker_Release(antiMk);
 708
 709                 res=IMoniker_IsRunning(mostRigthMk,pbc,tempMk,pmkNewlyRunning);
 710
 711                 IMoniker_Release(tempMk);
 712                 IMoniker_Release(mostRigthMk);
 713
 714                 return res;
 715             }
 716         }
 717 }
 718
 719 /******************************************************************************
 720  *        CompositeMoniker_GetTimeOfLastChange
 721  ******************************************************************************/
 722 static HRESULT WINAPI
 723 CompositeMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc,
 724                IMoniker* pmkToLeft, FILETIME* pCompositeTime)
 725 {
 726     HRESULT res;
 727     IMoniker *tempMk,*antiMk,*mostRigthMk,*leftMk;
 728     IEnumMoniker *enumMoniker;
 729
 730     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pCompositeTime);
 731
 732     if (pCompositeTime==NULL)
 733         return E_INVALIDARG;
 734
 735     /* This method creates a composite of pmkToLeft (if non-NULL) and this moniker and uses the ROT to  */
 736     /* retrieve the time of last change. If the object is not in the ROT, the method recursively calls  */
 737     /* IMoniker::GetTimeOfLastChange on the rightmost component of the composite, passing the remainder */
 738     /* of the composite as the pmkToLeft parameter for that call.                                       */
 739     if (pmkToLeft)
 740     {
 741         IRunningObjectTable* rot;
 742
 743         res = IMoniker_ComposeWith(pmkToLeft, iface, FALSE, &leftMk);
 744
 745         res = IBindCtx_GetRunningObjectTable(pbc,&rot);
 746         if (FAILED(res))
 747         {
 748             IMoniker_Release(leftMk);
 749             return res;
 750         }
 751
 752         if (IRunningObjectTable_GetTimeOfLastChange(rot,leftMk,pCompositeTime)==S_OK)
 753         {
 754             IMoniker_Release(leftMk);
 755             return res;
 756         }
 757     }
 758     else
 759         leftMk = iface;
 760
 761     IMoniker_Enum(iface, FALSE, &enumMoniker);
 762     IEnumMoniker_Next(enumMoniker, 1, &mostRigthMk, NULL);
 763     IEnumMoniker_Release(enumMoniker);
 764
 765     res = CreateAntiMoniker(&antiMk);
 766     res = IMoniker_ComposeWith(leftMk, antiMk, 0, &tempMk);
 767     IMoniker_Release(antiMk);
 768
 769     res = IMoniker_GetTimeOfLastChange(mostRigthMk, pbc, tempMk, pCompositeTime);
 770
 771     IMoniker_Release(tempMk);
 772     IMoniker_Release(mostRigthMk);
 773
 774     if (pmkToLeft)
 775         IMoniker_Release(leftMk);
 776
 777     return res;
 778 }
 779
 780 /******************************************************************************
 781  *        CompositeMoniker_Inverse
 782  ******************************************************************************/
 783 static HRESULT WINAPI
 784 CompositeMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
 785 {
 786     HRESULT res;
 787     IMoniker *tempMk,*antiMk,*mostRigthMk,*tempInvMk,*mostRigthInvMk;
 788     IEnumMoniker *enumMoniker;
 789
 790     TRACE("(%p,%p)\n",iface,ppmk);
 791
 792     if (ppmk==NULL)
 793         return E_POINTER;
 794
 795     /* This method returns a composite moniker that consists of the inverses of each of the components */
 796     /* of the original composite, stored in reverse order */
 797
 798     res=CreateAntiMoniker(&antiMk);
 799     res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
 800     IMoniker_Release(antiMk);
 801
 802     if (tempMk==NULL)
 803
 804         return IMoniker_Inverse(iface,ppmk);
 805
 806     else{
 807
 808         IMoniker_Enum(iface,FALSE,&enumMoniker);
 809         IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
 810         IEnumMoniker_Release(enumMoniker);
 811
 812         IMoniker_Inverse(mostRigthMk,&mostRigthInvMk);
 813         CompositeMonikerImpl_Inverse(tempMk,&tempInvMk);
 814
 815         res=CreateGenericComposite(mostRigthInvMk,tempInvMk,ppmk);
 816
 817         IMoniker_Release(tempMk);
 818         IMoniker_Release(mostRigthMk);
 819         IMoniker_Release(tempInvMk);
 820         IMoniker_Release(mostRigthInvMk);
 821
 822         return res;
 823     }
 824 }
 825
 826 /******************************************************************************
 827  *        CompositeMoniker_CommonPrefixWith
 828  ******************************************************************************/
 829 static HRESULT WINAPI
 830 CompositeMonikerImpl_CommonPrefixWith(IMoniker* iface, IMoniker* pmkOther,
 831                IMoniker** ppmkPrefix)
 832 {
 833     DWORD mkSys;
 834     HRESULT res1,res2;
 835     IMoniker *tempMk1,*tempMk2,*mostLeftMk1,*mostLeftMk2;
 836     IEnumMoniker *enumMoniker1,*enumMoniker2;
 837     ULONG i,nbCommonMk=0;
 838
 839     /* If the other moniker is a composite, this method compares the components of each composite from left  */
 840     /* to right. The returned common prefix moniker might also be a composite moniker, depending on how many */
 841     /* of the leftmost components were common to both monikers.                                              */
 842
 843     if (ppmkPrefix==NULL)
 844         return E_POINTER;
 845
 846     *ppmkPrefix=0;
 847
 848     if (pmkOther==NULL)
 849         return MK_E_NOPREFIX;
 850
 851     IMoniker_IsSystemMoniker(pmkOther,&mkSys);
 852
 853     if((mkSys==MKSYS_GENERICCOMPOSITE)){
 854
 855         IMoniker_Enum(iface,TRUE,&enumMoniker1);
 856         IMoniker_Enum(pmkOther,TRUE,&enumMoniker2);
 857
 858         while(1){
 859
 860             res1=IEnumMoniker_Next(enumMoniker1,1,&mostLeftMk1,NULL);
 861             res2=IEnumMoniker_Next(enumMoniker2,1,&mostLeftMk2,NULL);
 862
 863             if ((res1==S_FALSE) && (res2==S_FALSE)){
 864
 865                 /* If the monikers are equal, the method returns MK_S_US and sets ppmkPrefix to this moniker.*/
 866                 *ppmkPrefix=iface;
 867                 IMoniker_AddRef(iface);
 868                 return  MK_S_US;
 869             }
 870             else if ((res1==S_OK) && (res2==S_OK)){
 871
 872                 if (IMoniker_IsEqual(mostLeftMk1,mostLeftMk2)==S_OK)
 873
 874                     nbCommonMk++;
 875
 876                 else
 877                     break;
 878
 879             }
 880             else if (res1==S_OK){
 881
 882                 /* If the other moniker is a prefix of this moniker, the method returns MK_S_HIM and sets */
 883                 /* ppmkPrefix to the other moniker.                                                       */
 884                 *ppmkPrefix=pmkOther;
 885                 return MK_S_HIM;
 886             }
 887             else{
 888                 /* If this moniker is a prefix of the other, this method returns MK_S_ME and sets ppmkPrefix */
 889                 /* to this moniker.                                                                          */
 890                 *ppmkPrefix=iface;
 891                 return MK_S_ME;
 892             }
 893         }
 894
 895         IEnumMoniker_Release(enumMoniker1);
 896         IEnumMoniker_Release(enumMoniker2);
 897
 898         /* If there is no common prefix, this method returns MK_E_NOPREFIX and sets ppmkPrefix to NULL. */
 899         if (nbCommonMk==0)
 900             return MK_E_NOPREFIX;
 901
 902         IEnumMoniker_Reset(enumMoniker1);
 903
 904         IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
 905
 906         /* if we have more than one commun moniker the result will be a composite moniker */
 907         if (nbCommonMk>1){
 908
 909             /* initialize the common prefix moniker with the composite of two first moniker (from the left)*/
 910             IEnumMoniker_Next(enumMoniker1,1,&tempMk2,NULL);
 911             CreateGenericComposite(tempMk1,tempMk2,ppmkPrefix);
 912             IMoniker_Release(tempMk1);
 913             IMoniker_Release(tempMk2);
 914
 915             /* compose all common monikers in a composite moniker */
 916             for(i=0;i<nbCommonMk;i++){
 917
 918                 IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
 919
 920                 CreateGenericComposite(*ppmkPrefix,tempMk1,&tempMk2);
 921
 922                 IMoniker_Release(*ppmkPrefix);
 923
 924                 IMoniker_Release(tempMk1);
 925
 926                 *ppmkPrefix=tempMk2;
 927             }
 928             return S_OK;
 929         }
 930         else{
 931             /* if we have only one commun moniker the result will be a simple moniker which is the most-left one*/
 932             *ppmkPrefix=tempMk1;
 933
 934             return S_OK;
 935         }
 936     }
 937     else{
 938         /* If the other moniker is not a composite, the method simply compares it to the leftmost component
 939          of this moniker.*/
 940
 941         IMoniker_Enum(iface,TRUE,&enumMoniker1);
 942
 943         IEnumMoniker_Next(enumMoniker1,1,&mostLeftMk1,NULL);
 944
 945         if (IMoniker_IsEqual(pmkOther,mostLeftMk1)==S_OK){
 946
 947             *ppmkPrefix=pmkOther;
 948
 949             return MK_S_HIM;
 950         }
 951         else
 952             return MK_E_NOPREFIX;
 953     }
 954 }
 955
 956 /***************************************************************************************************
 957  *        GetAfterCommonPrefix (local function)
 958  *  This function returns a moniker that consist of the remainder when the common prefix is removed
 959  ***************************************************************************************************/
 960 static VOID GetAfterCommonPrefix(IMoniker* pGenMk,IMoniker* commonMk,IMoniker** restMk)
 961 {
 962     IMoniker *tempMk,*tempMk1,*tempMk2;
 963     IEnumMoniker *enumMoniker1,*enumMoniker2,*enumMoniker3;
 964     ULONG nbRestMk=0;
 965     DWORD mkSys;
 966     HRESULT res1,res2;
 967
 968     *restMk=0;
 969
 970     /* to create an enumerator for pGenMk with current position pointed on the first element after common  */
 971     /* prefix: enum the two monikers (left-right) then compare these enumerations (left-right) and stop  */
 972     /* on the first difference. */
 973     IMoniker_Enum(pGenMk,TRUE,&enumMoniker1);
 974
 975     IMoniker_IsSystemMoniker(commonMk,&mkSys);
 976
 977     if (mkSys==MKSYS_GENERICCOMPOSITE){
 978
 979         IMoniker_Enum(commonMk,TRUE,&enumMoniker2);
 980         while(1){
 981
 982             res1=IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
 983             res2=IEnumMoniker_Next(enumMoniker2,1,&tempMk2,NULL);
 984
 985             if ((res1==S_FALSE)||(res2==S_FALSE)){
 986
 987                 if (res1==S_OK)
 988
 989                     nbRestMk++;
 990
 991                 IMoniker_Release(tempMk1);
 992                 IMoniker_Release(tempMk1);
 993
 994                 break;
 995             }
 996             IMoniker_Release(tempMk1);
 997             IMoniker_Release(tempMk1);
 998         }
 999     }
1000     else{
1001         IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
1002         IMoniker_Release(tempMk1);
1003     }
1004
1005     /* count the number of elements in the enumerator after the common prefix */
1006     IEnumMoniker_Clone(enumMoniker1,&enumMoniker3);
1007
1008     for(;IEnumMoniker_Next(enumMoniker3,1,&tempMk,NULL)==S_OK;nbRestMk++)
1009
1010         IMoniker_Release(tempMk);
1011
1012     if (nbRestMk==0)
1013         return;
1014
1015     /* create a generic composite moniker with monikers located after the common prefix */
1016     IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
1017
1018     if (nbRestMk==1){
1019
1020         *restMk= tempMk1;
1021         return;
1022     }
1023     else {
1024
1025         IEnumMoniker_Next(enumMoniker1,1,&tempMk2,NULL);
1026
1027         CreateGenericComposite(tempMk1,tempMk2,restMk);
1028
1029         IMoniker_Release(tempMk1);
1030
1031         IMoniker_Release(tempMk2);
1032
1033         while(IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL)==S_OK){
1034
1035             CreateGenericComposite(*restMk,tempMk1,&tempMk2);
1036
1037             IMoniker_Release(tempMk1);
1038
1039             IMoniker_Release(*restMk);
1040
1041             *restMk=tempMk2;
1042         }
1043     }
1044 }
1045
1046 /******************************************************************************
1047  *        CompositeMoniker_RelativePathTo
1048  ******************************************************************************/
1049 static HRESULT WINAPI
1050 CompositeMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmkOther,
1051                IMoniker** ppmkRelPath)
1052 {
1053     HRESULT res;
1054     IMoniker *restOtherMk=0,*restThisMk=0,*invRestThisMk=0,*commonMk=0;
1055
1056     TRACE("(%p,%p,%p)\n",iface,pmkOther,ppmkRelPath);
1057
1058     if (ppmkRelPath==NULL)
1059         return E_POINTER;
1060
1061     *ppmkRelPath=0;
1062
1063     /* This method finds the common prefix of the two monikers and creates two monikers that consist     */
1064     /* of the remainder when the common prefix is removed. Then it creates the inverse for the remainder */
1065     /* of this moniker and composes the remainder of the other moniker on the right of it.               */
1066
1067     /* finds the common prefix of the two monikers */
1068     res=IMoniker_CommonPrefixWith(iface,pmkOther,&commonMk);
1069
1070     /* if there's no common prefix or the two moniker are equal the relative is the other moniker */
1071     if ((res== MK_E_NOPREFIX)||(res==MK_S_US)){
1072
1073         *ppmkRelPath=pmkOther;
1074         IMoniker_AddRef(pmkOther);
1075         return MK_S_HIM;
1076     }
1077
1078     GetAfterCommonPrefix(iface,commonMk,&restThisMk);
1079     GetAfterCommonPrefix(pmkOther,commonMk,&restOtherMk);
1080
1081     /* if other is a prefix of this moniker the relative path is the inverse of the remainder path of this */
1082     /* moniker when the common prefix is removed                                                           */
1083     if (res==MK_S_HIM){
1084
1085         IMoniker_Inverse(restThisMk,ppmkRelPath);
1086         IMoniker_Release(restThisMk);
1087     }
1088     /* if this moniker is a prefix of other moniker the relative path is the remainder path of other moniker */
1089     /* when the common prefix is removed                                                                     */
1090     else if (res==MK_S_ME){
1091
1092         *ppmkRelPath=restOtherMk;
1093         IMoniker_AddRef(restOtherMk);
1094     }
1095     /* the relative path is the inverse for the remainder of this moniker and the remainder of the other  */
1096     /* moniker on the right of it.                                                                        */
1097     else if (res==S_OK){
1098
1099         IMoniker_Inverse(restThisMk,&invRestThisMk);
1100         IMoniker_Release(restThisMk);
1101         CreateGenericComposite(invRestThisMk,restOtherMk,ppmkRelPath);
1102         IMoniker_Release(invRestThisMk);
1103         IMoniker_Release(restOtherMk);
1104     }
1105     return S_OK;
1106 }
1107
1108 /******************************************************************************
1109  *        CompositeMoniker_GetDisplayName
1110  ******************************************************************************/
1111 static HRESULT WINAPI
1112 CompositeMonikerImpl_GetDisplayName(IMoniker* iface, IBindCtx* pbc,
1113                IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
1114 {
1115     ULONG lengthStr=1;
1116     IEnumMoniker *enumMoniker;
1117     IMoniker* tempMk;
1118     LPOLESTR tempStr;
1119
1120     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
1121
1122     if (ppszDisplayName==NULL)
1123         return E_POINTER;
1124
1125     *ppszDisplayName=CoTaskMemAlloc(sizeof(WCHAR));
1126
1127     if (*ppszDisplayName==NULL)
1128         return E_OUTOFMEMORY;
1129
1130     /* This method returns the concatenation of the display names returned by each component moniker of */
1131     /* the composite */
1132
1133     **ppszDisplayName=0;
1134
1135     IMoniker_Enum(iface,TRUE,&enumMoniker);
1136
1137     while(IEnumMoniker_Next(enumMoniker,1,&tempMk,NULL)==S_OK){
1138
1139         IMoniker_GetDisplayName(tempMk,pbc,NULL,&tempStr);
1140
1141         lengthStr+=lstrlenW(tempStr);
1142
1143         *ppszDisplayName=CoTaskMemRealloc(*ppszDisplayName,lengthStr * sizeof(WCHAR));
1144
1145         if (*ppszDisplayName==NULL)
1146             return E_OUTOFMEMORY;
1147
1148         strcatW(*ppszDisplayName,tempStr);
1149
1150         CoTaskMemFree(tempStr);
1151         IMoniker_Release(tempMk);
1152     }
1153
1154     IEnumMoniker_Release(enumMoniker);
1155
1156     return S_OK;
1157 }
1158
1159 /******************************************************************************
1160  *        CompositeMoniker_ParseDisplayName
1161  ******************************************************************************/
1162 static HRESULT WINAPI
1163 CompositeMonikerImpl_ParseDisplayName(IMoniker* iface, IBindCtx* pbc,
1164                IMoniker* pmkToLeft, LPOLESTR pszDisplayName, ULONG* pchEaten,
1165                IMoniker** ppmkOut)
1166 {
1167     IEnumMoniker *enumMoniker;
1168     IMoniker *tempMk,*mostRigthMk,*antiMk;
1169     /* This method recursively calls IMoniker::ParseDisplayName on the rightmost component of the composite,*/
1170     /* passing everything else as the pmkToLeft parameter for that call. */
1171
1172     /* get the most right moniker */
1173     IMoniker_Enum(iface,FALSE,&enumMoniker);
1174     IEnumMoniker_Next(enumMoniker,1,&mostRigthMk,NULL);
1175     IEnumMoniker_Release(enumMoniker);
1176
1177     /* get the left moniker */
1178     CreateAntiMoniker(&antiMk);
1179     IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
1180     IMoniker_Release(antiMk);
1181
1182     return IMoniker_ParseDisplayName(mostRigthMk,pbc,tempMk,pszDisplayName,pchEaten,ppmkOut);
1183 }
1184
1185 /******************************************************************************
1186  *        CompositeMoniker_IsSystemMoniker
1187  ******************************************************************************/
1188 static HRESULT WINAPI
1189 CompositeMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
1190 {
1191     TRACE("(%p,%p)\n",iface,pwdMksys);
1192
1193     if (!pwdMksys)
1194         return E_POINTER;
1195
1196     (*pwdMksys)=MKSYS_GENERICCOMPOSITE;
1197
1198     return S_OK;
1199 }
1200
1201 /*******************************************************************************
1202  *        CompositeMonikerIROTData_QueryInterface
1203  *******************************************************************************/
1204 static HRESULT WINAPI
1205 CompositeMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,
1206                VOID** ppvObject)
1207 {
1208
1209     IMoniker *This = impl_from_IROTData(iface);
1210
1211     TRACE("(%p,%p,%p)\n",iface,riid,ppvObject);
1212
1213     return CompositeMonikerImpl_QueryInterface(This, riid, ppvObject);
1214 }
1215
1216 /***********************************************************************
1217  *        CompositeMonikerIROTData_AddRef
1218  */
1219 static ULONG WINAPI
1220 CompositeMonikerROTDataImpl_AddRef(IROTData *iface)
1221 {
1222     IMoniker *This = impl_from_IROTData(iface);
1223
1224     TRACE("(%p)\n",iface);
1225
1226     return IMoniker_AddRef(This);
1227 }
1228
1229 /***********************************************************************
1230  *        CompositeMonikerIROTData_Release
1231  */
1232 static ULONG WINAPI CompositeMonikerROTDataImpl_Release(IROTData* iface)
1233 {
1234     IMoniker *This = impl_from_IROTData(iface);
1235
1236     TRACE("(%p)\n",iface);
1237
1238     return IMoniker_Release(This);
1239 }
1240
1241 /******************************************************************************
1242  *        CompositeMonikerIROTData_GetComparisonData
1243  ******************************************************************************/
1244 static HRESULT WINAPI
1245 CompositeMonikerROTDataImpl_GetComparisonData(IROTData* iface,
1246                BYTE* pbData, ULONG cbMax, ULONG* pcbData)
1247 {
1248     IMoniker *This = impl_from_IROTData(iface);
1249     IEnumMoniker *pEnumMk;
1250     IMoniker *pmk;
1251     HRESULT hr;
1252
1253     TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
1254
1255     *pcbData = sizeof(CLSID);
1256
1257     hr = IMoniker_Enum(This, TRUE, &pEnumMk);
1258     if (FAILED(hr)) return hr;
1259
1260     while(IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK)
1261     {
1262         IROTData *pROTData;
1263         hr = IMoniker_QueryInterface(pmk, &IID_IROTData, (void **)&pROTData);
1264         if (FAILED(hr))
1265             ERR("moniker doesn't support IROTData interface\n");
1266
1267         if (SUCCEEDED(hr))
1268         {
1269             ULONG cbData;
1270             hr = IROTData_GetComparisonData(pROTData, NULL, 0, &cbData);
1271             IROTData_Release(pROTData);
1272             if (SUCCEEDED(hr) || (hr == E_OUTOFMEMORY))
1273             {
1274                 *pcbData += cbData;
1275                 hr = S_OK;
1276             }
1277             else
1278                 ERR("IROTData_GetComparisonData failed with error 0x%08x\n", hr);
1279         }
1280
1281         IMoniker_Release(pmk);
1282
1283         if (FAILED(hr))
1284         {
1285             IEnumMoniker_Release(pEnumMk);
1286             return hr;
1287         }
1288     }
1289     if (cbMax < *pcbData)
1290         return E_OUTOFMEMORY;
1291
1292     IEnumMoniker_Reset(pEnumMk);
1293
1294     memcpy(pbData, &CLSID_CompositeMoniker, sizeof(CLSID));
1295     pbData += sizeof(CLSID);
1296     cbMax -= sizeof(CLSID);
1297
1298     while (IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK)
1299     {
1300         IROTData *pROTData;
1301         hr = IMoniker_QueryInterface(pmk, &IID_IROTData, (void **)&pROTData);
1302         if (FAILED(hr))
1303             ERR("moniker doesn't support IROTData interface\n");
1304
1305         if (SUCCEEDED(hr))
1306         {
1307             ULONG cbData;
1308             hr = IROTData_GetComparisonData(pROTData, pbData, cbMax, &cbData);
1309             IROTData_Release(pROTData);
1310             if (SUCCEEDED(hr))
1311             {
1312                 pbData += cbData;
1313                 cbMax -= cbData;
1314             }
1315             else
1316                 ERR("IROTData_GetComparisonData failed with error 0x%08x\n", hr);
1317         }
1318
1319         IMoniker_Release(pmk);
1320
1321         if (FAILED(hr))
1322         {
1323             IEnumMoniker_Release(pEnumMk);
1324             return hr;
1325         }
1326     }
1327
1328     IEnumMoniker_Release(pEnumMk);
1329
1330     return S_OK;
1331 }
1332
1333 static HRESULT WINAPI CompositeMonikerMarshalImpl_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv)
1334 {
1335     IMoniker *This = impl_from_IMarshal(iface);
1336
1337     TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppv);
1338
1339     return CompositeMonikerImpl_QueryInterface(This, riid, ppv);
1340 }
1341
1342 static ULONG WINAPI CompositeMonikerMarshalImpl_AddRef(IMarshal *iface)
1343 {
1344     IMoniker *This = impl_from_IMarshal(iface);
1345
1346     TRACE("(%p)\n",iface);
1347
1348     return CompositeMonikerImpl_AddRef(This);
1349 }
1350
1351 static ULONG WINAPI CompositeMonikerMarshalImpl_Release(IMarshal *iface)
1352 {
1353     IMoniker *This = impl_from_IMarshal(iface);
1354
1355     TRACE("(%p)\n",iface);
1356
1357     return CompositeMonikerImpl_Release(This);
1358 }
1359
1360 static HRESULT WINAPI CompositeMonikerMarshalImpl_GetUnmarshalClass(
1361   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1362   void* pvDestContext, DWORD mshlflags, CLSID* pCid)
1363 {
1364     IMoniker *This = impl_from_IMarshal(iface);
1365
1366     TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1367         dwDestContext, pvDestContext, mshlflags, pCid);
1368
1369     return IMoniker_GetClassID(This, pCid);
1370 }
1371
1372 static HRESULT WINAPI CompositeMonikerMarshalImpl_GetMarshalSizeMax(
1373   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1374   void* pvDestContext, DWORD mshlflags, DWORD* pSize)
1375 {
1376     IMoniker *This = impl_from_IMarshal(iface);
1377     IEnumMoniker *pEnumMk;
1378     IMoniker *pmk;
1379     HRESULT hr;
1380     ULARGE_INTEGER size;
1381
1382     TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1383         dwDestContext, pvDestContext, mshlflags, pSize);
1384
1385     *pSize = 0x10; /* to match native */
1386
1387     hr = IMoniker_Enum(This, TRUE, &pEnumMk);
1388     if (FAILED(hr)) return hr;
1389
1390     hr = IMoniker_GetSizeMax(This, &size);
1391
1392     while (IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK)
1393     {
1394         ULONG size;
1395
1396         hr = CoGetMarshalSizeMax(&size, &IID_IMoniker, (IUnknown *)pmk, dwDestContext, pvDestContext, mshlflags);
1397         if (SUCCEEDED(hr))
1398             *pSize += size;
1399
1400         IMoniker_Release(pmk);
1401
1402         if (FAILED(hr))
1403         {
1404             IEnumMoniker_Release(pEnumMk);
1405             return hr;
1406         }
1407     }
1408
1409     IEnumMoniker_Release(pEnumMk);
1410
1411     return S_OK;
1412 }
1413
1414 static HRESULT WINAPI CompositeMonikerMarshalImpl_MarshalInterface(LPMARSHAL iface, IStream *pStm,
1415     REFIID riid, void* pv, DWORD dwDestContext,
1416     void* pvDestContext, DWORD mshlflags)
1417 {
1418     IMoniker *This = impl_from_IMarshal(iface);
1419     IEnumMoniker *pEnumMk;
1420     IMoniker *pmk;
1421     HRESULT hr;
1422     ULONG i = 0;
1423
1424     TRACE("(%p, %s, %p, %x, %p, %x)\n", pStm, debugstr_guid(riid), pv,
1425         dwDestContext, pvDestContext, mshlflags);
1426
1427     hr = IMoniker_Enum(This, TRUE, &pEnumMk);
1428     if (FAILED(hr)) return hr;
1429
1430     while (IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK)
1431     {
1432         hr = CoMarshalInterface(pStm, &IID_IMoniker, (IUnknown *)pmk, dwDestContext, pvDestContext, mshlflags);
1433
1434         IMoniker_Release(pmk);
1435
1436         if (FAILED(hr))
1437         {
1438             IEnumMoniker_Release(pEnumMk);
1439             return hr;
1440         }
1441         i++;
1442     }
1443
1444     if (i != 2)
1445         FIXME("moniker count of %d not supported\n", i);
1446
1447     IEnumMoniker_Release(pEnumMk);
1448
1449     return S_OK;
1450 }
1451
1452 static HRESULT WINAPI CompositeMonikerMarshalImpl_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv)
1453 {
1454     CompositeMonikerImpl *This = (CompositeMonikerImpl *)impl_from_IMarshal(iface);
1455     HRESULT hr;
1456
1457     TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);
1458
1459     CompositeMonikerImpl_ReleaseMonikersInTable(This);
1460
1461     /* resize the table if needed */
1462     if (This->tabLastIndex + 2 > This->tabSize)
1463     {
1464         This->tabSize += max(BLOCK_TAB_SIZE, 2);
1465         This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(IMoniker));
1466
1467         if (This->tabMoniker==NULL)
1468             return E_OUTOFMEMORY;
1469     }
1470
1471     hr = CoUnmarshalInterface(pStm, &IID_IMoniker, (void**)&This->tabMoniker[This->tabLastIndex]);
1472     if (FAILED(hr))
1473     {
1474         ERR("couldn't unmarshal moniker, hr = 0x%08x\n", hr);
1475         return hr;
1476     }
1477     This->tabLastIndex++;
1478     hr = CoUnmarshalInterface(pStm, &IID_IMoniker, (void**)&This->tabMoniker[This->tabLastIndex]);
1479     if (FAILED(hr))
1480     {
1481         ERR("couldn't unmarshal moniker, hr = 0x%08x\n", hr);
1482         return hr;
1483     }
1484     This->tabLastIndex++;
1485
1486     return IMoniker_QueryInterface((IMoniker *)&This->lpvtbl1, riid, ppv);
1487 }
1488
1489 static HRESULT WINAPI CompositeMonikerMarshalImpl_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm)
1490 {
1491     TRACE("(%p)\n", pStm);
1492     /* can't release a state-based marshal as nothing on server side to
1493      * release */
1494     return S_OK;
1495 }
1496
1497 static HRESULT WINAPI CompositeMonikerMarshalImpl_DisconnectObject(LPMARSHAL iface, DWORD dwReserved)
1498 {
1499     TRACE("(0x%x)\n", dwReserved);
1500     /* can't disconnect a state-based marshal as nothing on server side to
1501      * disconnect from */
1502     return S_OK;
1503 }
1504
1505 /******************************************************************************
1506  *        EnumMonikerImpl_QueryInterface
1507  ******************************************************************************/
1508 static HRESULT WINAPI
1509 EnumMonikerImpl_QueryInterface(IEnumMoniker* iface,REFIID riid,void** ppvObject)
1510 {
1511     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
1512
1513     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
1514
1515     /* Perform a sanity check on the parameters.*/
1516     if ( (This==0) || (ppvObject==0) )
1517         return E_INVALIDARG;
1518
1519     /* Initialize the return parameter */
1520     *ppvObject = 0;
1521
1522     /* Compare the riid with the interface IDs implemented by this object.*/
1523     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IEnumMoniker, riid))
1524         *ppvObject = iface;
1525
1526     /* Check that we obtained an interface.*/
1527     if ((*ppvObject)==0)
1528         return E_NOINTERFACE;
1529
1530     /* Query Interface always increases the reference count by one when it is successful */
1531     IEnumMoniker_AddRef(iface);
1532
1533     return S_OK;
1534 }
1535
1536 /******************************************************************************
1537  *        EnumMonikerImpl_AddRef
1538  ******************************************************************************/
1539 static ULONG WINAPI
1540 EnumMonikerImpl_AddRef(IEnumMoniker* iface)
1541 {
1542     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
1543
1544     TRACE("(%p)\n",This);
1545
1546     return InterlockedIncrement(&This->ref);
1547
1548 }
1549
1550 /******************************************************************************
1551  *        EnumMonikerImpl_Release
1552  ******************************************************************************/
1553 static ULONG WINAPI
1554 EnumMonikerImpl_Release(IEnumMoniker* iface)
1555 {
1556     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
1557     ULONG i;
1558     ULONG ref;
1559     TRACE("(%p)\n",This);
1560
1561     ref = InterlockedDecrement(&This->ref);
1562
1563     /* destroy the object if there's no more reference on it */
1564     if (ref == 0) {
1565
1566         for(i=0;i<This->tabSize;i++)
1567             IMoniker_Release(This->tabMoniker[i]);
1568
1569         HeapFree(GetProcessHeap(),0,This->tabMoniker);
1570         HeapFree(GetProcessHeap(),0,This);
1571     }
1572     return ref;
1573 }
1574
1575 /******************************************************************************
1576  *        EnumMonikerImpl_Next
1577  ******************************************************************************/
1578 static HRESULT WINAPI
1579 EnumMonikerImpl_Next(IEnumMoniker* iface,ULONG celt, IMoniker** rgelt,
1580                ULONG* pceltFethed)
1581 {
1582     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
1583     ULONG i;
1584
1585     /* retrieve the requested number of moniker from the current position */
1586     for(i=0;((This->currentPos < This->tabSize) && (i < celt));i++)
1587     {
1588         rgelt[i]=This->tabMoniker[This->currentPos++];
1589         IMoniker_AddRef(rgelt[i]);
1590     }
1591
1592     if (pceltFethed!=NULL)
1593         *pceltFethed= i;
1594
1595     if (i==celt)
1596         return S_OK;
1597     else
1598         return S_FALSE;
1599 }
1600
1601 /******************************************************************************
1602  *        EnumMonikerImpl_Skip
1603  ******************************************************************************/
1604 static HRESULT WINAPI
1605 EnumMonikerImpl_Skip(IEnumMoniker* iface,ULONG celt)
1606 {
1607     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
1608
1609     if ((This->currentPos+celt) >= This->tabSize)
1610         return S_FALSE;
1611
1612     This->currentPos+=celt;
1613
1614     return S_OK;
1615 }
1616
1617 /******************************************************************************
1618  *        EnumMonikerImpl_Reset
1619  ******************************************************************************/
1620 static HRESULT WINAPI
1621 EnumMonikerImpl_Reset(IEnumMoniker* iface)
1622 {
1623
1624     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
1625
1626     This->currentPos=0;
1627
1628     return S_OK;
1629 }
1630
1631 /******************************************************************************
1632  *        EnumMonikerImpl_Clone
1633  ******************************************************************************/
1634 static HRESULT WINAPI
1635 EnumMonikerImpl_Clone(IEnumMoniker* iface,IEnumMoniker** ppenum)
1636 {
1637     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
1638
1639     return EnumMonikerImpl_CreateEnumMoniker(This->tabMoniker,This->tabSize,This->currentPos,TRUE,ppenum);
1640 }
1641
1642 /********************************************************************************/
1643 /* Virtual function table for the IROTData class                                */
1644 static const IEnumMonikerVtbl VT_EnumMonikerImpl =
1645 {
1646     EnumMonikerImpl_QueryInterface,
1647     EnumMonikerImpl_AddRef,
1648     EnumMonikerImpl_Release,
1649     EnumMonikerImpl_Next,
1650     EnumMonikerImpl_Skip,
1651     EnumMonikerImpl_Reset,
1652     EnumMonikerImpl_Clone
1653 };
1654
1655 /******************************************************************************
1656  *        EnumMonikerImpl_CreateEnumMoniker
1657  ******************************************************************************/
1658 static HRESULT
1659 EnumMonikerImpl_CreateEnumMoniker(IMoniker** tabMoniker, ULONG tabSize,
1660                ULONG currentPos, BOOL leftToRigth, IEnumMoniker ** ppmk)
1661 {
1662     EnumMonikerImpl* newEnumMoniker;
1663     int i;
1664
1665     if (currentPos > tabSize)
1666         return E_INVALIDARG;
1667
1668     newEnumMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumMonikerImpl));
1669
1670     if (newEnumMoniker == 0)
1671         return STG_E_INSUFFICIENTMEMORY;
1672
1673     /* Initialize the virtual function table. */
1674     newEnumMoniker->lpVtbl       = &VT_EnumMonikerImpl;
1675     newEnumMoniker->ref          = 1;
1676
1677     newEnumMoniker->tabSize=tabSize;
1678     newEnumMoniker->currentPos=currentPos;
1679
1680     newEnumMoniker->tabMoniker=HeapAlloc(GetProcessHeap(),0,tabSize*sizeof(IMoniker));
1681
1682     if (newEnumMoniker->tabMoniker==NULL) {
1683         HeapFree(GetProcessHeap(), 0, newEnumMoniker);
1684         return E_OUTOFMEMORY;
1685     }
1686
1687     if (leftToRigth)
1688         for (i=0;i<tabSize;i++){
1689
1690             newEnumMoniker->tabMoniker[i]=tabMoniker[i];
1691             IMoniker_AddRef(tabMoniker[i]);
1692         }
1693     else
1694         for (i=tabSize-1;i>=0;i--){
1695
1696             newEnumMoniker->tabMoniker[tabSize-i-1]=tabMoniker[i];
1697             IMoniker_AddRef(tabMoniker[i]);
1698         }
1699
1700     *ppmk=(IEnumMoniker*)newEnumMoniker;
1701
1702     return S_OK;
1703 }
1704
1705 /********************************************************************************/
1706 /* Virtual function table for the CompositeMonikerImpl class which includes     */
1707 /* IPersist, IPersistStream and IMoniker functions.                             */
1708
1709 static const IMonikerVtbl VT_CompositeMonikerImpl =
1710 {
1711     CompositeMonikerImpl_QueryInterface,
1712     CompositeMonikerImpl_AddRef,
1713     CompositeMonikerImpl_Release,
1714     CompositeMonikerImpl_GetClassID,
1715     CompositeMonikerImpl_IsDirty,
1716     CompositeMonikerImpl_Load,
1717     CompositeMonikerImpl_Save,
1718     CompositeMonikerImpl_GetSizeMax,
1719     CompositeMonikerImpl_BindToObject,
1720     CompositeMonikerImpl_BindToStorage,
1721     CompositeMonikerImpl_Reduce,
1722     CompositeMonikerImpl_ComposeWith,
1723     CompositeMonikerImpl_Enum,
1724     CompositeMonikerImpl_IsEqual,
1725     CompositeMonikerImpl_Hash,
1726     CompositeMonikerImpl_IsRunning,
1727     CompositeMonikerImpl_GetTimeOfLastChange,
1728     CompositeMonikerImpl_Inverse,
1729     CompositeMonikerImpl_CommonPrefixWith,
1730     CompositeMonikerImpl_RelativePathTo,
1731     CompositeMonikerImpl_GetDisplayName,
1732     CompositeMonikerImpl_ParseDisplayName,
1733     CompositeMonikerImpl_IsSystemMoniker
1734 };
1735
1736 /********************************************************************************/
1737 /* Virtual function table for the IROTData class.                               */
1738 static const IROTDataVtbl VT_ROTDataImpl =
1739 {
1740     CompositeMonikerROTDataImpl_QueryInterface,
1741     CompositeMonikerROTDataImpl_AddRef,
1742     CompositeMonikerROTDataImpl_Release,
1743     CompositeMonikerROTDataImpl_GetComparisonData
1744 };
1745
1746 static const IMarshalVtbl VT_MarshalImpl =
1747 {
1748     CompositeMonikerMarshalImpl_QueryInterface,
1749     CompositeMonikerMarshalImpl_AddRef,
1750     CompositeMonikerMarshalImpl_Release,
1751     CompositeMonikerMarshalImpl_GetUnmarshalClass,
1752     CompositeMonikerMarshalImpl_GetMarshalSizeMax,
1753     CompositeMonikerMarshalImpl_MarshalInterface,
1754     CompositeMonikerMarshalImpl_UnmarshalInterface,
1755     CompositeMonikerMarshalImpl_ReleaseMarshalData,
1756     CompositeMonikerMarshalImpl_DisconnectObject
1757 };
1758
1759 /******************************************************************************
1760  *         Composite-Moniker_Construct (local function)
1761  *******************************************************************************/
1762 static HRESULT
1763 CompositeMonikerImpl_Construct(IMoniker** ppMoniker,
1764                LPMONIKER pmkFirst, LPMONIKER pmkRest)
1765 {
1766     DWORD mkSys;
1767     IEnumMoniker *enumMoniker;
1768     IMoniker *tempMk;
1769     HRESULT res;
1770     CompositeMonikerImpl *This;
1771
1772     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1773
1774     if (!This)
1775         return E_OUTOFMEMORY;
1776
1777     TRACE("(%p,%p,%p)\n",This,pmkFirst,pmkRest);
1778
1779     /* Initialize the virtual function table. */
1780     This->lpvtbl1      = &VT_CompositeMonikerImpl;
1781     This->lpvtbl2      = &VT_ROTDataImpl;
1782     This->lpvtblMarshal= &VT_MarshalImpl;
1783     This->ref          = 1;
1784
1785     This->tabSize=BLOCK_TAB_SIZE;
1786     This->tabLastIndex=0;
1787
1788     This->tabMoniker=HeapAlloc(GetProcessHeap(),0,This->tabSize*sizeof(IMoniker));
1789     if (This->tabMoniker==NULL) {
1790         HeapFree(GetProcessHeap(), 0, This);
1791         return E_OUTOFMEMORY;
1792     }
1793
1794     if (!pmkFirst && !pmkRest)
1795     {
1796         *ppMoniker = (IMoniker *)This;
1797         return S_OK;
1798     }
1799
1800     IMoniker_IsSystemMoniker(pmkFirst,&mkSys);
1801
1802     /* put the first moniker contents in the beginning of the table */
1803     if (mkSys!=MKSYS_GENERICCOMPOSITE){
1804
1805         This->tabMoniker[(This->tabLastIndex)++]=pmkFirst;
1806         IMoniker_AddRef(pmkFirst);
1807     }
1808     else{
1809
1810         IMoniker_Enum(pmkFirst,TRUE,&enumMoniker);
1811
1812         while(IEnumMoniker_Next(enumMoniker,1,&This->tabMoniker[This->tabLastIndex],NULL)==S_OK){
1813
1814
1815             if (++This->tabLastIndex==This->tabSize){
1816                 LPVOID tab_moniker = This->tabMoniker;
1817
1818                 This->tabSize+=BLOCK_TAB_SIZE;
1819                 This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(IMoniker));
1820
1821                 if (This->tabMoniker==NULL){
1822                     HeapFree(GetProcessHeap(), 0, tab_moniker);
1823                     HeapFree(GetProcessHeap(), 0, This);
1824                     return E_OUTOFMEMORY;
1825                 }
1826             }
1827         }
1828
1829         IEnumMoniker_Release(enumMoniker);
1830     }
1831
1832     /* put the rest moniker contents after the first one and make simplification if needed */
1833
1834     IMoniker_IsSystemMoniker(pmkRest,&mkSys);
1835
1836     if (mkSys!=MKSYS_GENERICCOMPOSITE){
1837
1838         /* add a simple moniker to the moniker table */
1839
1840         res=IMoniker_ComposeWith(This->tabMoniker[This->tabLastIndex-1],pmkRest,TRUE,&tempMk);
1841
1842         if (res==MK_E_NEEDGENERIC){
1843
1844             /* there's no simplification in this case */
1845             This->tabMoniker[This->tabLastIndex]=pmkRest;
1846
1847             This->tabLastIndex++;
1848
1849             IMoniker_AddRef(pmkRest);
1850         }
1851         else if (tempMk==NULL){
1852
1853             /* we have an antimoniker after a simple moniker so we can make a simplification in this case */
1854             IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]);
1855
1856             This->tabLastIndex--;
1857         }
1858         else if (SUCCEEDED(res)){
1859
1860             /* the non-generic composition was successful so we can make a simplification in this case */
1861             IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]);
1862
1863             This->tabMoniker[This->tabLastIndex-1]=tempMk;
1864         } else
1865             return res;
1866
1867         /* resize tabMoniker if needed */
1868         if (This->tabLastIndex==This->tabSize){
1869             LPVOID tab_moniker = This->tabMoniker;
1870
1871             This->tabSize+=BLOCK_TAB_SIZE;
1872
1873             This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(IMoniker));
1874
1875             if (This->tabMoniker==NULL){
1876                 HeapFree(GetProcessHeap(), 0, tab_moniker);
1877                 HeapFree(GetProcessHeap(), 0, This);
1878                 return E_OUTOFMEMORY;
1879             }
1880         }
1881     }
1882     else{
1883
1884         /* add a composite moniker to the moniker table (do the same thing
1885          * for each moniker within the composite moniker as a simple moniker
1886          * (see above for how to add a simple moniker case) )
1887          */
1888         IMoniker_Enum(pmkRest,TRUE,&enumMoniker);
1889
1890         while(IEnumMoniker_Next(enumMoniker,1,&This->tabMoniker[This->tabLastIndex],NULL)==S_OK){
1891
1892             res=IMoniker_ComposeWith(This->tabMoniker[This->tabLastIndex-1],This->tabMoniker[This->tabLastIndex],TRUE,&tempMk);
1893
1894             if (res==MK_E_NEEDGENERIC){
1895
1896                 This->tabLastIndex++;
1897             }
1898             else if (tempMk==NULL){
1899
1900                 IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]);
1901                 IMoniker_Release(This->tabMoniker[This->tabLastIndex]);
1902                 This->tabLastIndex--;
1903             }
1904             else{
1905
1906                 IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]);
1907
1908                 This->tabMoniker[This->tabLastIndex-1]=tempMk;
1909             }
1910
1911             if (This->tabLastIndex==This->tabSize){
1912                 LPVOID tab_moniker = This->tabMoniker;
1913
1914                 This->tabSize+=BLOCK_TAB_SIZE;
1915
1916                 This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(IMoniker));
1917
1918                 if (This->tabMoniker==NULL){
1919                     HeapFree(GetProcessHeap(), 0, tab_moniker);
1920                     HeapFree(GetProcessHeap(), 0, This);
1921                     return E_OUTOFMEMORY;
1922                 }
1923             }
1924         }
1925
1926         IEnumMoniker_Release(enumMoniker);
1927     }
1928
1929     /* only one moniker, then just return it */
1930     if (This->tabLastIndex == 1)
1931     {
1932         *ppMoniker = This->tabMoniker[0];
1933         IMoniker_AddRef(*ppMoniker);
1934         IMoniker_Release((IMoniker *)This);
1935     }
1936     else
1937         *ppMoniker = (IMoniker *)This;
1938
1939     return S_OK;
1940 }
1941
1942 /******************************************************************************
1943  *        CreateGenericComposite        [OLE32.@]
1944  ******************************************************************************/
1945 HRESULT WINAPI
1946 CreateGenericComposite(LPMONIKER pmkFirst, LPMONIKER pmkRest,
1947                LPMONIKER* ppmkComposite)
1948 {
1949     IMoniker* moniker = 0;
1950     HRESULT        hr = S_OK;
1951
1952     TRACE("(%p,%p,%p)\n",pmkFirst,pmkRest,ppmkComposite);
1953
1954     if (ppmkComposite==NULL)
1955         return E_POINTER;
1956
1957     *ppmkComposite=0;
1958
1959     if (pmkFirst==NULL && pmkRest!=NULL){
1960
1961         *ppmkComposite=pmkRest;
1962         return S_OK;
1963     }
1964     else if (pmkFirst!=NULL && pmkRest==NULL){
1965         *ppmkComposite=pmkFirst;
1966         return S_OK;
1967     }
1968     else  if (pmkFirst==NULL && pmkRest==NULL)
1969         return S_OK;
1970
1971     hr = CompositeMonikerImpl_Construct(&moniker,pmkFirst,pmkRest);
1972
1973     if (FAILED(hr))
1974         return hr;
1975
1976     hr = IMoniker_QueryInterface(moniker,&IID_IMoniker,(void**)ppmkComposite);
1977     IMoniker_Release(moniker);
1978
1979     return hr;
1980 }
1981
1982 /******************************************************************************
1983  *        MonikerCommonPrefixWith       [OLE32.@]
1984  ******************************************************************************/
1985 HRESULT WINAPI
1986 MonikerCommonPrefixWith(IMoniker* pmkThis,IMoniker* pmkOther,IMoniker** ppmkCommon)
1987 {
1988     FIXME("(),stub!\n");
1989     return E_NOTIMPL;
1990 }
1991
1992 static HRESULT WINAPI CompositeMonikerCF_QueryInterface(LPCLASSFACTORY iface,
1993                                                   REFIID riid, LPVOID *ppv)
1994 {
1995     *ppv = NULL;
1996     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
1997     {
1998         *ppv = iface;
1999         IUnknown_AddRef(iface);
2000         return S_OK;
2001     }
2002     return E_NOINTERFACE;
2003 }
2004
2005 static ULONG WINAPI CompositeMonikerCF_AddRef(LPCLASSFACTORY iface)
2006 {
2007     return 2; /* non-heap based object */
2008 }
2009
2010 static ULONG WINAPI CompositeMonikerCF_Release(LPCLASSFACTORY iface)
2011 {
2012     return 1; /* non-heap based object */
2013 }
2014
2015 static HRESULT WINAPI CompositeMonikerCF_CreateInstance(LPCLASSFACTORY iface,
2016     LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
2017 {
2018     IMoniker* pMoniker;
2019     HRESULT  hr;
2020
2021     TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
2022
2023     *ppv = NULL;
2024
2025     if (pUnk)
2026         return CLASS_E_NOAGGREGATION;
2027
2028     hr = CompositeMonikerImpl_Construct(&pMoniker, NULL, NULL);
2029
2030     if (SUCCEEDED(hr))
2031     {
2032         hr = IMoniker_QueryInterface(pMoniker, riid, ppv);
2033         IMoniker_Release(pMoniker);
2034     }
2035
2036     return hr;
2037 }
2038
2039 static HRESULT WINAPI CompositeMonikerCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
2040 {
2041     FIXME("(%d), stub!\n",fLock);
2042     return S_OK;
2043 }
2044
2045 static const IClassFactoryVtbl CompositeMonikerCFVtbl =
2046 {
2047     CompositeMonikerCF_QueryInterface,
2048     CompositeMonikerCF_AddRef,
2049     CompositeMonikerCF_Release,
2050     CompositeMonikerCF_CreateInstance,
2051     CompositeMonikerCF_LockServer
2052 };
2053 static const IClassFactoryVtbl *CompositeMonikerCF = &CompositeMonikerCFVtbl;
2054
2055 HRESULT CompositeMonikerCF_Create(REFIID riid, LPVOID *ppv)
2056 {
2057     return IClassFactory_QueryInterface((IClassFactory *)&CompositeMonikerCF, riid, ppv);
2058 }