ole32: Add documentation for CreateBindCtx, BindMoniker, GetRunningObjectTable and...
[wine] / dlls / ole32 / filemoniker.c
1 /*
2  * FileMonikers 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 "winerror.h"
32 #include "winnls.h"
33 #include "wine/unicode.h"
34 #include "wine/debug.h"
35 #include "objbase.h"
36 #include "moniker.h"
37
38 #include "compobj_private.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(ole);
41
42 /* filemoniker data structure */
43 typedef struct FileMonikerImpl{
44
45     const IMonikerVtbl*  lpvtbl1;  /* VTable relative to the IMoniker interface.*/
46
47     /* The ROT (RunningObjectTable implementation) uses the IROTData interface to test whether
48      * two monikers are equal. That's whay IROTData interface is implemented by monikers.
49      */
50     const IROTDataVtbl*  lpvtbl2;  /* VTable relative to the IROTData interface.*/
51
52     LONG ref; /* reference counter for this object */
53
54     LPOLESTR filePathName; /* path string identified by this filemoniker */
55
56     IUnknown *pMarshal; /* custom marshaler */
57 } FileMonikerImpl;
58
59 static inline IMoniker *impl_from_IROTData( IROTData *iface )
60 {
61     return (IMoniker *)((char*)iface - FIELD_OFFSET(FileMonikerImpl, lpvtbl2));
62 }
63
64 /* Local function used by filemoniker implementation */
65 static HRESULT WINAPI FileMonikerImpl_Construct(FileMonikerImpl* iface, LPCOLESTR lpszPathName);
66 static HRESULT WINAPI FileMonikerImpl_Destroy(FileMonikerImpl* iface);
67
68 /*******************************************************************************
69  *        FileMoniker_QueryInterface
70  */
71 static HRESULT WINAPI
72 FileMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
73 {
74     FileMonikerImpl *This = (FileMonikerImpl *)iface;
75
76     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
77
78     /* Perform a sanity check on the parameters.*/
79     if ( (This==0) || (ppvObject==0) )
80         return E_INVALIDARG;
81
82     /* Initialize the return parameter */
83     *ppvObject = 0;
84
85     /* Compare the riid with the interface IDs implemented by this object.*/
86     if (IsEqualIID(&IID_IUnknown, riid)      ||
87         IsEqualIID(&IID_IPersist, riid)      ||
88         IsEqualIID(&IID_IPersistStream,riid) ||
89         IsEqualIID(&IID_IMoniker, riid)
90        )
91         *ppvObject = iface;
92
93     else if (IsEqualIID(&IID_IROTData, riid))
94         *ppvObject = (IROTData*)&(This->lpvtbl2);
95     else if (IsEqualIID(&IID_IMarshal, riid))
96     {
97         HRESULT hr = S_OK;
98         if (!This->pMarshal)
99             hr = MonikerMarshal_Create(iface, &This->pMarshal);
100         if (hr != S_OK)
101             return hr;
102         return IUnknown_QueryInterface(This->pMarshal, riid, ppvObject);
103     }
104
105     /* Check that we obtained an interface.*/
106     if ((*ppvObject)==0)
107         return E_NOINTERFACE;
108
109     /* Query Interface always increases the reference count by one when it is successful */
110     IMoniker_AddRef(iface);
111
112     return S_OK;
113 }
114
115 /******************************************************************************
116  *        FileMoniker_AddRef
117  */
118 static ULONG WINAPI
119 FileMonikerImpl_AddRef(IMoniker* iface)
120 {
121     FileMonikerImpl *This = (FileMonikerImpl *)iface;
122
123     TRACE("(%p)\n",iface);
124
125     return InterlockedIncrement(&This->ref);
126 }
127
128 /******************************************************************************
129  *        FileMoniker_Release
130  */
131 static ULONG WINAPI
132 FileMonikerImpl_Release(IMoniker* iface)
133 {
134     FileMonikerImpl *This = (FileMonikerImpl *)iface;
135     ULONG ref;
136
137     TRACE("(%p)\n",iface);
138
139     ref = InterlockedDecrement(&This->ref);
140
141     /* destroy the object if there's no more reference on it */
142     if (ref == 0) FileMonikerImpl_Destroy(This);
143
144     return ref;
145 }
146
147 /******************************************************************************
148  *        FileMoniker_GetClassID
149  */
150 static HRESULT WINAPI
151 FileMonikerImpl_GetClassID(IMoniker* iface, CLSID *pClassID)
152 {
153     TRACE("(%p,%p)\n",iface,pClassID);
154
155     if (pClassID==NULL)
156         return E_POINTER;
157
158     *pClassID = CLSID_FileMoniker;
159
160     return S_OK;
161 }
162
163 /******************************************************************************
164  *        FileMoniker_IsDirty
165  *
166  * Note that the OLE-provided implementations of the IPersistStream::IsDirty
167  * method in the OLE-provided moniker interfaces always return S_FALSE because
168  * their internal state never changes.
169  */
170 static HRESULT WINAPI
171 FileMonikerImpl_IsDirty(IMoniker* iface)
172 {
173
174     TRACE("(%p)\n",iface);
175
176     return S_FALSE;
177 }
178
179 /******************************************************************************
180  *        FileMoniker_Load
181  *
182  * this function locates and reads from the stream the filePath string
183  * written by FileMonikerImpl_Save
184  */
185 static HRESULT WINAPI
186 FileMonikerImpl_Load(IMoniker* iface, IStream* pStm)
187 {
188     HRESULT res;
189     CHAR* filePathA = NULL;
190     WCHAR* filePathW = NULL;
191     ULONG bread;
192     WORD  wbuffer;
193     DWORD dwbuffer, bytesA, bytesW, len;
194     int i;
195
196     FileMonikerImpl *This = (FileMonikerImpl *)iface;
197
198     TRACE("(%p,%p)\n",iface,pStm);
199
200     /* first WORD must be 0 */
201     res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
202     if (bread!=sizeof(WORD) || wbuffer!=0)
203     {
204         WARN("Couldn't read 0 word\n");
205         goto fail;
206     }
207
208     /* read filePath string length (plus one) */
209     res=IStream_Read(pStm,&bytesA,sizeof(DWORD),&bread);
210     if (bread != sizeof(DWORD))
211     {
212         WARN("Couldn't read file string length\n");
213         goto fail;
214     }
215
216     /* read filePath string */
217     filePathA=HeapAlloc(GetProcessHeap(),0,bytesA);
218     if (!filePathA)
219     {
220         res = E_OUTOFMEMORY;
221         goto fail;
222     }
223
224     res=IStream_Read(pStm,filePathA,bytesA,&bread);
225     if (bread != bytesA)
226     {
227         WARN("Couldn't read file path string\n");
228         goto fail;
229     }
230
231     /* read the first constant */
232     IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
233     if (bread != sizeof(DWORD) || dwbuffer != 0xDEADFFFF)
234     {
235         WARN("Couldn't read 0xDEADFFFF constant\n");
236         goto fail;
237     }
238
239     for(i=0;i<5;i++)
240     {
241         res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
242         if (bread!=sizeof(DWORD) || dwbuffer!=0)
243         {
244             WARN("Couldn't read 0 padding\n");
245             goto fail;
246         }
247     }
248
249     res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
250     if (bread!=sizeof(DWORD))
251         goto fail;
252
253     if (!dwbuffer) /* No W-string */
254     {        
255         bytesA--;
256         len=MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, filePathA, bytesA, NULL, 0);
257         if (!len)
258             goto fail;
259
260         filePathW=HeapAlloc(GetProcessHeap(),0,(len+1)*sizeof(WCHAR));
261         if (!filePathW)
262         {
263             res = E_OUTOFMEMORY;
264             goto fail;
265         }
266         MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, filePathA, -1, filePathW, len+1);
267         goto succeed;
268     }
269
270     if (dwbuffer < 6)
271         goto fail;
272
273     bytesW=dwbuffer - 6;
274
275     res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
276     if (bread!=sizeof(DWORD) || dwbuffer!=bytesW)
277         goto fail;
278
279     res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
280     if (bread!=sizeof(WORD) || wbuffer!=0x3)
281         goto fail;
282
283     len=bytesW/sizeof(WCHAR);
284     filePathW=HeapAlloc(GetProcessHeap(),0,(len+1)*sizeof(WCHAR));
285     if(!filePathW)
286     {
287          res = E_OUTOFMEMORY;
288          goto fail;
289     }
290     res=IStream_Read(pStm,filePathW,bytesW,&bread);
291     if (bread!=bytesW)
292          goto fail;
293
294     filePathW[len]=0;
295
296  succeed:
297     HeapFree(GetProcessHeap(),0,filePathA);
298     HeapFree(GetProcessHeap(),0,This->filePathName);
299     This->filePathName=filePathW;
300
301     return S_OK;
302
303  fail:
304     HeapFree(GetProcessHeap(), 0, filePathA);
305     HeapFree(GetProcessHeap(), 0, filePathW);
306
307     if (SUCCEEDED(res))
308          res = E_FAIL;
309     return res;
310 }
311
312 /******************************************************************************
313  *        FileMoniker_Save
314  *
315  * This function saves data of this object. In the beginning I thought
316  * that I have just to write the filePath string on Stream. But, when I
317  * tested this function with windows programs samples, I noticed that it
318  * was not the case. This implementation is based on XP SP2. Other versions
319  * of Windows have minor variations.
320  *
321  * Data which must be written on stream is:
322  * 1) WORD constant:zero
323  * 2) length of the path string ("\0" included)
324  * 3) path string type A
325  * 4) DWORD constant : 0xDEADFFFF
326  * 5) five DWORD constant: zero
327  * 6) If we're only writing the multibyte version, 
328  *     write a zero DWORD and finish.
329  *
330  * 7) DWORD: double-length of the the path string type W ("\0" not
331  *    included)
332  * 8) WORD constant: 0x3
333  * 9) filePath unicode string.
334  *
335  */
336 static HRESULT WINAPI
337 FileMonikerImpl_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty)
338 {
339     FileMonikerImpl *This = (FileMonikerImpl *)iface;
340
341     HRESULT res;
342     LPOLESTR filePathW=This->filePathName;
343     CHAR*    filePathA;
344     DWORD bytesA, bytesW, len;
345
346     static const DWORD DEADFFFF = 0xDEADFFFF;  /* Constants */
347     static const DWORD ZERO     = 0;
348     static const WORD  THREE    = 0x3;
349
350     int i;
351     BOOL bUsedDefault, bWriteWide;
352
353     TRACE("(%p,%p,%d)\n",iface,pStm,fClearDirty);
354
355     if (pStm==NULL)
356         return E_POINTER;
357
358     /* write a 0 WORD */
359     res=IStream_Write(pStm,&ZERO,sizeof(WORD),NULL);
360     if (!SUCCEEDED(res)) return res;
361
362     /* write length of filePath string ( 0 included )*/
363     bytesA = WideCharToMultiByte( CP_ACP, 0, filePathW, -1, NULL, 0, NULL, NULL );
364     res=IStream_Write(pStm,&bytesA,sizeof(DWORD),NULL);
365     if (!SUCCEEDED(res)) return res;
366
367     /* write A string (with '\0') */
368     filePathA=HeapAlloc(GetProcessHeap(),0,bytesA);
369     if (!filePathA)
370         return E_OUTOFMEMORY;
371     WideCharToMultiByte( CP_ACP, 0, filePathW, -1, filePathA, bytesA, NULL, &bUsedDefault);
372     res=IStream_Write(pStm,filePathA,bytesA,NULL);
373     HeapFree(GetProcessHeap(),0,filePathA);
374     if (!SUCCEEDED(res)) return res;
375
376     /* write a DWORD 0xDEADFFFF */
377     res=IStream_Write(pStm,&DEADFFFF,sizeof(DWORD),NULL);
378     if (!SUCCEEDED(res)) return res;
379
380     /* write 5 zero DWORDs */
381     for(i=0;i<5;i++)
382     {
383         res=IStream_Write(pStm,&ZERO,sizeof(DWORD),NULL);
384         if (!SUCCEEDED(res)) return res;
385     }
386
387     /* Write the wide version if:
388      *    + couldn't convert to CP_ACP, 
389      * or + it's a directory, 
390      * or + there's a character > 0xFF 
391      */
392     len = lstrlenW(filePathW);
393     bWriteWide = (bUsedDefault || (len > 0 && filePathW[len-1]=='\\' ));
394     if (!bWriteWide)
395     {
396         WCHAR* pch;
397         for(pch=filePathW;*pch;++pch) 
398         {
399             if (*pch > 0xFF)
400             {
401                 bWriteWide = TRUE;
402                 break;
403             }
404         }
405     }
406
407     if (!bWriteWide)
408     {
409         res=IStream_Write(pStm,&ZERO,sizeof(DWORD),NULL);
410         return res;
411     }
412
413     /* write bytes needed for the filepathW (without 0) + 6 */
414     bytesW = len*sizeof(WCHAR) + 6;
415     res=IStream_Write(pStm,&bytesW,sizeof(DWORD),NULL);
416     if (!SUCCEEDED(res)) return res;
417
418     /* try again, without the extra 6 */
419     bytesW -= 6;
420     res=IStream_Write(pStm,&bytesW,sizeof(DWORD),NULL);
421     if (!SUCCEEDED(res)) return res;
422
423     /* write a WORD 3 */
424     res=IStream_Write(pStm,&THREE,sizeof(WORD),NULL);
425     if (!SUCCEEDED(res)) return res;
426
427     /* write W string (no 0) */
428     res=IStream_Write(pStm,filePathW,bytesW,NULL);
429
430     return res;
431 }
432
433 /******************************************************************************
434  *        FileMoniker_GetSizeMax
435  */
436 static HRESULT WINAPI
437 FileMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
438 {
439     FileMonikerImpl *This = (FileMonikerImpl *)iface;
440
441     TRACE("(%p,%p)\n",iface,pcbSize);
442
443     if (!pcbSize)
444         return E_POINTER;
445
446     /* We could calculate exactly (see ...::Save()) but instead
447      * we'll make a quick over-estimate, like Windows (NT4, XP) does.
448      */
449     pcbSize->u.LowPart  = 0x38 + 4 * lstrlenW(This->filePathName);
450     pcbSize->u.HighPart = 0;
451
452     return S_OK;
453 }
454
455 /******************************************************************************
456  *        FileMoniker_Destroy (local function)
457  *******************************************************************************/
458 HRESULT WINAPI FileMonikerImpl_Destroy(FileMonikerImpl* This)
459 {
460     TRACE("(%p)\n",This);
461
462     if (This->pMarshal) IUnknown_Release(This->pMarshal);
463     HeapFree(GetProcessHeap(),0,This->filePathName);
464     HeapFree(GetProcessHeap(),0,This);
465
466     return S_OK;
467 }
468
469 /******************************************************************************
470  *                  FileMoniker_BindToObject
471  */
472 static HRESULT WINAPI
473 FileMonikerImpl_BindToObject(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
474                              REFIID riid, VOID** ppvResult)
475 {
476     HRESULT   res=E_FAIL;
477     CLSID     clsID;
478     IUnknown* pObj=0;
479     IRunningObjectTable *prot=0;
480     IPersistFile  *ppf=0;
481     IClassFactory *pcf=0;
482     IClassActivator *pca=0;
483
484     FileMonikerImpl *This = (FileMonikerImpl *)iface;
485
486     *ppvResult=0;
487
488     TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
489
490     if(pmkToLeft==NULL){
491
492         res=IBindCtx_GetRunningObjectTable(pbc,&prot);
493
494         if (SUCCEEDED(res)){
495             /* if the requested class was loaded before ! we don't need to reload it */
496             res = IRunningObjectTable_GetObject(prot,iface,&pObj);
497
498             if (res==S_FALSE){
499                 /* first activation of this class */
500                 res=GetClassFile(This->filePathName,&clsID);
501                 if (SUCCEEDED(res)){
502
503                     res=CoCreateInstance(&clsID,NULL,CLSCTX_ALL,&IID_IPersistFile,(void**)&ppf);
504                     if (SUCCEEDED(res)){
505
506                         res=IPersistFile_Load(ppf,This->filePathName,STGM_READ);
507                         if (SUCCEEDED(res)){
508
509                             pObj=(IUnknown*)ppf;
510                             IUnknown_AddRef(pObj);
511                         }
512                     }
513                 }
514             }
515         }
516     }
517     else{
518         res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IClassFactory,(void**)&pcf);
519
520         if (res==E_NOINTERFACE){
521
522             res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IClassActivator,(void**)&pca);
523
524             if (res==E_NOINTERFACE)
525                 return MK_E_INTERMEDIATEINTERFACENOTSUPPORTED;
526         }
527         if (pcf!=NULL){
528
529             IClassFactory_CreateInstance(pcf,NULL,&IID_IPersistFile,(void**)&ppf);
530
531             res=IPersistFile_Load(ppf,This->filePathName,STGM_READ);
532
533             if (SUCCEEDED(res)){
534
535                 pObj=(IUnknown*)ppf;
536                 IUnknown_AddRef(pObj);
537             }
538         }
539         if (pca!=NULL){
540
541             FIXME("()\n");
542
543             /*res=GetClassFile(This->filePathName,&clsID);
544
545             if (SUCCEEDED(res)){
546
547                 res=IClassActivator_GetClassObject(pca,&clsID,CLSCTX_ALL,0,&IID_IPersistFile,(void**)&ppf);
548
549                 if (SUCCEEDED(res)){
550
551                     pObj=(IUnknown*)ppf;
552                     IUnknown_AddRef(pObj);
553                 }
554             }*/
555         }
556     }
557
558     if (pObj!=NULL){
559         /* get the requested interface from the loaded class */
560         res= IUnknown_QueryInterface(pObj,riid,ppvResult);
561
562         IBindCtx_RegisterObjectBound(pbc,(IUnknown*)*ppvResult);
563
564         IUnknown_Release(pObj);
565     }
566
567     if (prot!=NULL)
568         IRunningObjectTable_Release(prot);
569
570     if (ppf!=NULL)
571         IPersistFile_Release(ppf);
572
573     if (pca!=NULL)
574         IClassActivator_Release(pca);
575
576     if (pcf!=NULL)
577         IClassFactory_Release(pcf);
578
579     return res;
580 }
581
582 /******************************************************************************
583  *        FileMoniker_BindToStorage
584  */
585 static HRESULT WINAPI
586 FileMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
587                               REFIID riid, VOID** ppvObject)
588 {
589     LPOLESTR filePath=0;
590     IStorage *pstg=0;
591     HRESULT res;
592
593     TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvObject);
594
595     if (pmkToLeft==NULL){
596
597         if (IsEqualIID(&IID_IStorage, riid)){
598
599             /* get the file name */
600             IMoniker_GetDisplayName(iface,pbc,pmkToLeft,&filePath);
601
602             /* verifie if the file contains a storage object */
603             res=StgIsStorageFile(filePath);
604
605             if(res==S_OK){
606
607                 res=StgOpenStorage(filePath,NULL,STGM_READWRITE|STGM_SHARE_DENY_WRITE,NULL,0,&pstg);
608
609                 if (SUCCEEDED(res)){
610
611                     *ppvObject=pstg;
612
613                     IStorage_AddRef(pstg);
614
615                     return res;
616                 }
617             }
618             CoTaskMemFree(filePath);
619         }
620         else
621             if ( (IsEqualIID(&IID_IStream, riid)) || (IsEqualIID(&IID_ILockBytes, riid)) )
622                 return E_FAIL;
623             else
624                 return E_NOINTERFACE;
625     }
626     else {
627
628         FIXME("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvObject);
629
630         return E_NOTIMPL;
631     }
632     return res;
633 }
634
635 /******************************************************************************
636  *        FileMoniker_Reduce
637  ******************************************************************************/
638 static HRESULT WINAPI
639 FileMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
640                        IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
641 {
642     TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
643
644     if (ppmkReduced==NULL)
645         return E_POINTER;
646
647     IMoniker_AddRef(iface);
648
649     *ppmkReduced=iface;
650
651     return MK_S_REDUCED_TO_SELF;
652 }
653
654 /******************************************************************************
655  *        FileMoniker_ComposeWith
656  */
657 static HRESULT WINAPI
658 FileMonikerImpl_ComposeWith(IMoniker* iface, IMoniker* pmkRight,
659                             BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
660 {
661     HRESULT res;
662     LPOLESTR str1=0,str2=0,*strDec1=0,*strDec2=0,newStr=0;
663     static const WCHAR twoPoint[]={'.','.',0};
664     static const WCHAR bkSlash[]={'\\',0};
665     IBindCtx *bind=0;
666     int i=0,j=0,lastIdx1=0,lastIdx2=0;
667     DWORD mkSys;
668
669     TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
670
671     if (ppmkComposite==NULL)
672         return E_POINTER;
673
674     if (pmkRight==NULL)
675         return E_INVALIDARG;
676
677     *ppmkComposite=0;
678
679     IMoniker_IsSystemMoniker(pmkRight,&mkSys);
680
681     /* check if we have two filemonikers to compose or not */
682     if(mkSys==MKSYS_FILEMONIKER){
683
684         CreateBindCtx(0,&bind);
685
686         IMoniker_GetDisplayName(iface,bind,NULL,&str1);
687         IMoniker_GetDisplayName(pmkRight,bind,NULL,&str2);
688
689         /* decompose pathnames of the two monikers : (to prepare the path merge operation ) */
690         lastIdx1=FileMonikerImpl_DecomposePath(str1,&strDec1)-1;
691         lastIdx2=FileMonikerImpl_DecomposePath(str2,&strDec2)-1;
692
693         if ((lastIdx1==-1 && lastIdx2>-1)||(lastIdx1==1 && lstrcmpW(strDec1[0],twoPoint)==0))
694             return MK_E_SYNTAX;
695
696         if(lstrcmpW(strDec1[lastIdx1],bkSlash)==0)
697             lastIdx1--;
698
699         /* for etch "..\" in the left of str2 remove the right element from str1 */
700         for(i=0; ( (lastIdx1>=0) && (strDec2[i]!=NULL) && (lstrcmpW(strDec2[i],twoPoint)==0) ) ;i+=2){
701
702             lastIdx1-=2;
703         }
704
705         /* the length of the composed path string  is raised by the sum of the two paths lengths  */
706         newStr=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(lstrlenW(str1)+lstrlenW(str2)+1));
707
708           if (newStr==NULL)
709                 return E_OUTOFMEMORY;
710
711         /* new path is the concatenation of the rest of str1 and str2 */
712         for(*newStr=0,j=0;j<=lastIdx1;j++)
713             strcatW(newStr,strDec1[j]);
714
715         if ((strDec2[i]==NULL && lastIdx1>-1 && lastIdx2>-1) || lstrcmpW(strDec2[i],bkSlash)!=0)
716             strcatW(newStr,bkSlash);
717
718         for(j=i;j<=lastIdx2;j++)
719             strcatW(newStr,strDec2[j]);
720
721         /* create a new moniker with the new string */
722         res=CreateFileMoniker(newStr,ppmkComposite);
723
724         /* free all strings space memory used by this function */
725         HeapFree(GetProcessHeap(),0,newStr);
726
727         for(i=0; strDec1[i]!=NULL;i++)
728             CoTaskMemFree(strDec1[i]);
729         for(i=0; strDec2[i]!=NULL;i++)
730             CoTaskMemFree(strDec2[i]);
731         CoTaskMemFree(strDec1);
732         CoTaskMemFree(strDec2);
733
734         CoTaskMemFree(str1);
735         CoTaskMemFree(str2);
736
737         return res;
738     }
739     else if(mkSys==MKSYS_ANTIMONIKER){
740
741         *ppmkComposite=NULL;
742         return S_OK;
743     }
744     else if (fOnlyIfNotGeneric){
745
746         *ppmkComposite=NULL;
747         return MK_E_NEEDGENERIC;
748     }
749     else
750
751         return CreateGenericComposite(iface,pmkRight,ppmkComposite);
752 }
753
754 /******************************************************************************
755  *        FileMoniker_Enum
756  */
757 static HRESULT WINAPI
758 FileMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
759 {
760     TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
761
762     if (ppenumMoniker == NULL)
763         return E_POINTER;
764
765     *ppenumMoniker = NULL;
766
767     return S_OK;
768 }
769
770 /******************************************************************************
771  *        FileMoniker_IsEqual
772  */
773 static HRESULT WINAPI
774 FileMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
775 {
776     FileMonikerImpl *This = (FileMonikerImpl *)iface;
777     CLSID clsid;
778     LPOLESTR filePath;
779     IBindCtx* bind;
780     HRESULT res;
781
782     TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
783
784     if (pmkOtherMoniker==NULL)
785         return S_FALSE;
786
787     IMoniker_GetClassID(pmkOtherMoniker,&clsid);
788
789     if (!IsEqualCLSID(&clsid,&CLSID_FileMoniker))
790         return S_FALSE;
791
792     res = CreateBindCtx(0,&bind);
793     if (FAILED(res)) return res;
794
795     if (SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&filePath))) {
796         int result = lstrcmpiW(filePath, This->filePathName);
797         CoTaskMemFree(filePath);
798         if ( result == 0 ) return S_OK;
799     }
800     return S_FALSE;
801
802 }
803
804 /******************************************************************************
805  *        FileMoniker_Hash
806  */
807 static HRESULT WINAPI
808 FileMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
809 {
810     FileMonikerImpl *This = (FileMonikerImpl *)iface;
811
812     int  h = 0,i,skip,len;
813     int  off = 0;
814     LPOLESTR val;
815
816     if (pdwHash==NULL)
817         return E_POINTER;
818
819     val =  This->filePathName;
820     len = lstrlenW(val);
821
822     if (len < 16) {
823         for (i = len ; i > 0; i--) {
824             h = (h * 37) + val[off++];
825         }
826     } else {
827         /* only sample some characters */
828         skip = len / 8;
829         for (i = len ; i > 0; i -= skip, off += skip) {
830             h = (h * 39) + val[off];
831         }
832     }
833
834     *pdwHash=h;
835
836     return S_OK;
837 }
838
839 /******************************************************************************
840  *        FileMoniker_IsRunning
841  */
842 static HRESULT WINAPI
843 FileMonikerImpl_IsRunning(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
844                           IMoniker* pmkNewlyRunning)
845 {
846     IRunningObjectTable* rot;
847     HRESULT res;
848
849     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
850
851     if ( (pmkNewlyRunning!=NULL) && (IMoniker_IsEqual(pmkNewlyRunning,iface)==S_OK) )
852         return S_OK;
853
854     if (pbc==NULL)
855         return E_POINTER;
856
857     res=IBindCtx_GetRunningObjectTable(pbc,&rot);
858
859     if (FAILED(res))
860         return res;
861
862     res = IRunningObjectTable_IsRunning(rot,iface);
863
864     IRunningObjectTable_Release(rot);
865
866     return res;
867 }
868
869 /******************************************************************************
870  *        FileMoniker_GetTimeOfLastChange
871  ******************************************************************************/
872 static HRESULT WINAPI
873 FileMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc,
874                                     IMoniker* pmkToLeft, FILETIME* pFileTime)
875 {
876     FileMonikerImpl *This = (FileMonikerImpl *)iface;
877     IRunningObjectTable* rot;
878     HRESULT res;
879     WIN32_FILE_ATTRIBUTE_DATA info;
880
881     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pFileTime);
882
883     if (pFileTime==NULL)
884         return E_POINTER;
885
886     if (pmkToLeft!=NULL)
887         return E_INVALIDARG;
888
889     res=IBindCtx_GetRunningObjectTable(pbc,&rot);
890
891     if (FAILED(res))
892         return res;
893
894     res= IRunningObjectTable_GetTimeOfLastChange(rot,iface,pFileTime);
895
896     if (FAILED(res)){ /* the moniker is not registered */
897
898         if (!GetFileAttributesExW(This->filePathName,GetFileExInfoStandard,&info))
899             return MK_E_NOOBJECT;
900
901         *pFileTime=info.ftLastWriteTime;
902     }
903
904     return S_OK;
905 }
906
907 /******************************************************************************
908  *        FileMoniker_Inverse
909  */
910 static HRESULT WINAPI
911 FileMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
912 {
913     TRACE("(%p,%p)\n",iface,ppmk);
914
915     return CreateAntiMoniker(ppmk);
916 }
917
918 /******************************************************************************
919  *        FileMoniker_CommonPrefixWith
920  */
921 static HRESULT WINAPI
922 FileMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
923 {
924
925     LPOLESTR pathThis,pathOther,*stringTable1,*stringTable2,commonPath;
926     IBindCtx *pbind;
927     DWORD mkSys;
928     ULONG nb1,nb2,i,sameIdx;
929     BOOL machimeNameCase=FALSE;
930
931     if (ppmkPrefix==NULL)
932         return E_POINTER;
933
934     if (pmkOther==NULL)
935         return E_INVALIDARG;
936
937     *ppmkPrefix=0;
938
939     /* check if we have the same type of moniker */
940     IMoniker_IsSystemMoniker(pmkOther,&mkSys);
941
942     if(mkSys==MKSYS_FILEMONIKER){
943         HRESULT ret;
944
945         CreateBindCtx(0,&pbind);
946
947         /* create a string based on common part of the two paths */
948
949         IMoniker_GetDisplayName(iface,pbind,NULL,&pathThis);
950         IMoniker_GetDisplayName(pmkOther,pbind,NULL,&pathOther);
951
952         nb1=FileMonikerImpl_DecomposePath(pathThis,&stringTable1);
953         nb2=FileMonikerImpl_DecomposePath(pathOther,&stringTable2);
954
955         if (nb1==0 || nb2==0)
956             return MK_E_NOPREFIX;
957
958         commonPath=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(min(lstrlenW(pathThis),lstrlenW(pathOther))+1));
959
960         *commonPath=0;
961
962         for(sameIdx=0; ( (stringTable1[sameIdx]!=NULL) &&
963                          (stringTable2[sameIdx]!=NULL) &&
964                          (lstrcmpiW(stringTable1[sameIdx],stringTable2[sameIdx])==0)); sameIdx++);
965
966         if (sameIdx > 1 && *stringTable1[0]=='\\' && *stringTable2[1]=='\\'){
967
968             machimeNameCase=TRUE;
969
970             for(i=2;i<sameIdx;i++)
971
972                 if( (*stringTable1[i]=='\\') && (i+1 < sameIdx) && (*stringTable1[i+1]=='\\') ){
973                     machimeNameCase=FALSE;
974                     break;
975             }
976         }
977
978         if (machimeNameCase && *stringTable1[sameIdx-1]=='\\')
979             sameIdx--;
980
981         if (machimeNameCase && (sameIdx<=3) && (nb1 > 3 || nb2 > 3) )
982             ret = MK_E_NOPREFIX;
983         else
984         {
985             for(i=0;i<sameIdx;i++)
986                 strcatW(commonPath,stringTable1[i]);
987     
988             for(i=0;i<nb1;i++)
989                 CoTaskMemFree(stringTable1[i]);
990     
991             CoTaskMemFree(stringTable1);
992     
993             for(i=0;i<nb2;i++)
994                 CoTaskMemFree(stringTable2[i]);
995     
996             CoTaskMemFree(stringTable2);
997     
998             ret = CreateFileMoniker(commonPath,ppmkPrefix);
999         }
1000         HeapFree(GetProcessHeap(),0,commonPath);
1001         return ret;
1002     }
1003     else
1004         return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
1005 }
1006
1007 /******************************************************************************
1008  *        DecomposePath (local function)
1009  */
1010 int FileMonikerImpl_DecomposePath(LPCOLESTR str, LPOLESTR** stringTable)
1011 {
1012     static const WCHAR bSlash[] = {'\\',0};
1013     WCHAR word[MAX_PATH];
1014     int i=0,j,tabIndex=0;
1015     LPOLESTR *strgtable ;
1016
1017     int len=lstrlenW(str);
1018
1019     TRACE("%s, %p\n", debugstr_w(str), *stringTable);
1020
1021     strgtable =CoTaskMemAlloc(len*sizeof(LPOLESTR));
1022
1023     if (strgtable==NULL)
1024         return E_OUTOFMEMORY;
1025
1026     while(str[i]!=0){
1027
1028         if(str[i]==bSlash[0]){
1029
1030             strgtable[tabIndex]=CoTaskMemAlloc(2*sizeof(WCHAR));
1031
1032             if (strgtable[tabIndex]==NULL)
1033                 return E_OUTOFMEMORY;
1034
1035             strcpyW(strgtable[tabIndex++],bSlash);
1036
1037             i++;
1038
1039         }
1040         else {
1041
1042             for(j=0; str[i]!=0 && str[i]!=bSlash[0] ; i++,j++)
1043                 word[j]=str[i];
1044
1045             word[j]=0;
1046
1047             strgtable[tabIndex]=CoTaskMemAlloc(sizeof(WCHAR)*(j+1));
1048
1049             if (strgtable[tabIndex]==NULL)
1050                 return E_OUTOFMEMORY;
1051
1052             strcpyW(strgtable[tabIndex++],word);
1053         }
1054     }
1055     strgtable[tabIndex]=NULL;
1056
1057     *stringTable=strgtable;
1058
1059     return tabIndex;
1060 }
1061
1062 /******************************************************************************
1063  *        FileMoniker_RelativePathTo
1064  */
1065 static HRESULT WINAPI
1066 FileMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
1067 {
1068     IBindCtx *bind;
1069     HRESULT res;
1070     LPOLESTR str1=0,str2=0,*tabStr1=0,*tabStr2=0,relPath=0;
1071     DWORD len1=0,len2=0,sameIdx=0,j=0;
1072     static const WCHAR back[] ={'.','.','\\',0};
1073
1074     TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
1075
1076     if (ppmkRelPath==NULL)
1077         return E_POINTER;
1078
1079     if (pmOther==NULL)
1080         return E_INVALIDARG;
1081
1082     res=CreateBindCtx(0,&bind);
1083     if (FAILED(res))
1084         return res;
1085
1086     res=IMoniker_GetDisplayName(iface,bind,NULL,&str1);
1087     if (FAILED(res))
1088         return res;
1089     res=IMoniker_GetDisplayName(pmOther,bind,NULL,&str2);
1090     if (FAILED(res))
1091         return res;
1092
1093     len1=FileMonikerImpl_DecomposePath(str1,&tabStr1);
1094     len2=FileMonikerImpl_DecomposePath(str2,&tabStr2);
1095
1096     if (FAILED(len1) || FAILED(len2))
1097         return E_OUTOFMEMORY;
1098
1099     /* count the number of similar items from the begin of the two paths */
1100     for(sameIdx=0; ( (tabStr1[sameIdx]!=NULL) &&
1101                    (tabStr2[sameIdx]!=NULL) &&
1102                (lstrcmpiW(tabStr1[sameIdx],tabStr2[sameIdx])==0)); sameIdx++);
1103
1104     /* begin the construction of relativePath */
1105     /* if the two paths have a consecutive similar item from the begin ! the relativePath will be composed */
1106     /* by "..\\" in the begin */
1107     relPath=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(1+lstrlenW(str1)+lstrlenW(str2)));
1108
1109     *relPath=0;
1110
1111     if (len2>0 && !(len1==1 && len2==1 && sameIdx==0))
1112         for(j=sameIdx;(tabStr1[j] != NULL); j++)
1113             if (*tabStr1[j]!='\\')
1114                 strcatW(relPath,back);
1115
1116     /* add items of the second path (similar items with the first path are not included) to the relativePath */
1117     for(j=sameIdx;tabStr2[j]!=NULL;j++)
1118         strcatW(relPath,tabStr2[j]);
1119
1120     res=CreateFileMoniker(relPath,ppmkRelPath);
1121
1122     for(j=0; tabStr1[j]!=NULL;j++)
1123         CoTaskMemFree(tabStr1[j]);
1124     for(j=0; tabStr2[j]!=NULL;j++)
1125         CoTaskMemFree(tabStr2[j]);
1126     CoTaskMemFree(tabStr1);
1127     CoTaskMemFree(tabStr2);
1128     CoTaskMemFree(str1);
1129     CoTaskMemFree(str2);
1130     HeapFree(GetProcessHeap(),0,relPath);
1131
1132     if (len1==0 || len2==0 || (len1==1 && len2==1 && sameIdx==0))
1133         return MK_S_HIM;
1134
1135     return res;
1136 }
1137
1138 /******************************************************************************
1139  *        FileMoniker_GetDisplayName
1140  */
1141 static HRESULT WINAPI
1142 FileMonikerImpl_GetDisplayName(IMoniker* iface, IBindCtx* pbc,
1143                                IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
1144 {
1145     FileMonikerImpl *This = (FileMonikerImpl *)iface;
1146
1147     int len=lstrlenW(This->filePathName);
1148
1149     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
1150
1151     if (ppszDisplayName==NULL)
1152         return E_POINTER;
1153
1154     if (pmkToLeft!=NULL)
1155         return E_INVALIDARG;
1156
1157     *ppszDisplayName=CoTaskMemAlloc(sizeof(WCHAR)*(len+1));
1158     if (*ppszDisplayName==NULL)
1159         return E_OUTOFMEMORY;
1160
1161     strcpyW(*ppszDisplayName,This->filePathName);
1162
1163     TRACE("-- %s\n", debugstr_w(*ppszDisplayName));
1164     
1165     return S_OK;
1166 }
1167
1168 /******************************************************************************
1169  *        FileMoniker_ParseDisplayName
1170  */
1171 static HRESULT WINAPI
1172 FileMonikerImpl_ParseDisplayName(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
1173                      LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut)
1174 {
1175     FIXME("(%p,%p,%p,%p,%p,%p),stub!\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
1176     return E_NOTIMPL;
1177 }
1178
1179 /******************************************************************************
1180  *        FileMoniker_IsSystemMoniker
1181  */
1182 static HRESULT WINAPI
1183 FileMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
1184 {
1185     TRACE("(%p,%p)\n",iface,pwdMksys);
1186
1187     if (!pwdMksys)
1188         return E_POINTER;
1189
1190     (*pwdMksys)=MKSYS_FILEMONIKER;
1191
1192     return S_OK;
1193 }
1194
1195 /*******************************************************************************
1196  *        FileMonikerIROTData_QueryInterface
1197  */
1198 static HRESULT WINAPI
1199 FileMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
1200 {
1201
1202     IMoniker *This = impl_from_IROTData(iface);
1203
1204     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
1205
1206     return FileMonikerImpl_QueryInterface(This, riid, ppvObject);
1207 }
1208
1209 /***********************************************************************
1210  *        FileMonikerIROTData_AddRef
1211  */
1212 static ULONG WINAPI
1213 FileMonikerROTDataImpl_AddRef(IROTData *iface)
1214 {
1215     IMoniker *This = impl_from_IROTData(iface);
1216
1217     TRACE("(%p)\n",This);
1218
1219     return IMoniker_AddRef(This);
1220 }
1221
1222 /***********************************************************************
1223  *        FileMonikerIROTData_Release
1224  */
1225 static ULONG WINAPI
1226 FileMonikerROTDataImpl_Release(IROTData* iface)
1227 {
1228     IMoniker *This = impl_from_IROTData(iface);
1229
1230     TRACE("(%p)\n",This);
1231
1232     return FileMonikerImpl_Release(This);
1233 }
1234
1235 /******************************************************************************
1236  *        FileMonikerIROTData_GetComparaisonData
1237  */
1238 static HRESULT WINAPI
1239 FileMonikerROTDataImpl_GetComparisonData(IROTData* iface, BYTE* pbData,
1240                                           ULONG cbMax, ULONG* pcbData)
1241 {
1242     IMoniker *This = impl_from_IROTData(iface);
1243     FileMonikerImpl *This1 = (FileMonikerImpl *)This;
1244     int len = (strlenW(This1->filePathName)+1);
1245     int i;
1246     LPWSTR pszFileName;
1247
1248     TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
1249
1250     *pcbData = sizeof(CLSID) + len * sizeof(WCHAR);
1251     if (cbMax < *pcbData)
1252         return E_OUTOFMEMORY;
1253
1254     memcpy(pbData, &CLSID_FileMoniker, sizeof(CLSID));
1255     pszFileName = (LPWSTR)(pbData+sizeof(CLSID));
1256     for (i = 0; i < len; i++)
1257         pszFileName[i] = toupperW(This1->filePathName[i]);
1258
1259     return S_OK;
1260 }
1261
1262 /*
1263  * Virtual function table for the FileMonikerImpl class which include IPersist,
1264  * IPersistStream and IMoniker functions.
1265  */
1266 static const IMonikerVtbl VT_FileMonikerImpl =
1267 {
1268     FileMonikerImpl_QueryInterface,
1269     FileMonikerImpl_AddRef,
1270     FileMonikerImpl_Release,
1271     FileMonikerImpl_GetClassID,
1272     FileMonikerImpl_IsDirty,
1273     FileMonikerImpl_Load,
1274     FileMonikerImpl_Save,
1275     FileMonikerImpl_GetSizeMax,
1276     FileMonikerImpl_BindToObject,
1277     FileMonikerImpl_BindToStorage,
1278     FileMonikerImpl_Reduce,
1279     FileMonikerImpl_ComposeWith,
1280     FileMonikerImpl_Enum,
1281     FileMonikerImpl_IsEqual,
1282     FileMonikerImpl_Hash,
1283     FileMonikerImpl_IsRunning,
1284     FileMonikerImpl_GetTimeOfLastChange,
1285     FileMonikerImpl_Inverse,
1286     FileMonikerImpl_CommonPrefixWith,
1287     FileMonikerImpl_RelativePathTo,
1288     FileMonikerImpl_GetDisplayName,
1289     FileMonikerImpl_ParseDisplayName,
1290     FileMonikerImpl_IsSystemMoniker
1291 };
1292
1293 /* Virtual function table for the IROTData class. */
1294 static const IROTDataVtbl VT_ROTDataImpl =
1295 {
1296     FileMonikerROTDataImpl_QueryInterface,
1297     FileMonikerROTDataImpl_AddRef,
1298     FileMonikerROTDataImpl_Release,
1299     FileMonikerROTDataImpl_GetComparisonData
1300 };
1301
1302 /******************************************************************************
1303  *         FileMoniker_Construct (local function)
1304  */
1305 static HRESULT WINAPI
1306 FileMonikerImpl_Construct(FileMonikerImpl* This, LPCOLESTR lpszPathName)
1307 {
1308     int nb=0,i;
1309     int sizeStr=lstrlenW(lpszPathName);
1310     LPOLESTR *tabStr=0;
1311     static const WCHAR twoPoint[]={'.','.',0};
1312     static const WCHAR bkSlash[]={'\\',0};
1313     BYTE addBkSlash;
1314
1315     TRACE("(%p,%s)\n",This,debugstr_w(lpszPathName));
1316
1317     /* Initialize the virtual fgunction table. */
1318     This->lpvtbl1      = &VT_FileMonikerImpl;
1319     This->lpvtbl2      = &VT_ROTDataImpl;
1320     This->ref          = 0;
1321     This->pMarshal     = NULL;
1322
1323     This->filePathName=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(sizeStr+1));
1324
1325     if (This->filePathName==NULL)
1326         return E_OUTOFMEMORY;
1327
1328     strcpyW(This->filePathName,lpszPathName);
1329
1330     nb=FileMonikerImpl_DecomposePath(This->filePathName,&tabStr);
1331
1332     if (nb > 0 ){
1333
1334         addBkSlash=1;
1335         if (lstrcmpW(tabStr[0],twoPoint)!=0)
1336             addBkSlash=0;
1337         else
1338             for(i=0;i<nb;i++){
1339
1340                 if ( (lstrcmpW(tabStr[i],twoPoint)!=0) && (lstrcmpW(tabStr[i],bkSlash)!=0) ){
1341                     addBkSlash=0;
1342                     break;
1343                 }
1344                 else
1345
1346                     if (lstrcmpW(tabStr[i],bkSlash)==0 && i<nb-1 && lstrcmpW(tabStr[i+1],bkSlash)==0){
1347                         *tabStr[i]=0;
1348                         sizeStr--;
1349                         addBkSlash=0;
1350                         break;
1351                     }
1352             }
1353
1354         if (lstrcmpW(tabStr[nb-1],bkSlash)==0)
1355             addBkSlash=0;
1356
1357         This->filePathName=HeapReAlloc(GetProcessHeap(),0,This->filePathName,(sizeStr+1)*sizeof(WCHAR));
1358
1359         *This->filePathName=0;
1360
1361         for(i=0;tabStr[i]!=NULL;i++)
1362             strcatW(This->filePathName,tabStr[i]);
1363
1364         if (addBkSlash)
1365             strcatW(This->filePathName,bkSlash);
1366     }
1367
1368     for(i=0; tabStr[i]!=NULL;i++)
1369         CoTaskMemFree(tabStr[i]);
1370     CoTaskMemFree(tabStr);
1371
1372     return S_OK;
1373 }
1374
1375 /******************************************************************************
1376  *        CreateFileMoniker (OLE32.@)
1377  ******************************************************************************/
1378 HRESULT WINAPI CreateFileMoniker(LPCOLESTR lpszPathName, LPMONIKER * ppmk)
1379 {
1380     FileMonikerImpl* newFileMoniker;
1381     HRESULT  hr;
1382
1383     TRACE("(%s,%p)\n",debugstr_w(lpszPathName),ppmk);
1384
1385     if (!ppmk)
1386         return E_POINTER;
1387
1388     if(!lpszPathName)
1389         return MK_E_SYNTAX;
1390
1391     *ppmk=NULL;
1392
1393     newFileMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(FileMonikerImpl));
1394
1395     if (!newFileMoniker)
1396         return E_OUTOFMEMORY;
1397
1398     hr = FileMonikerImpl_Construct(newFileMoniker,lpszPathName);
1399
1400     if (SUCCEEDED(hr))
1401         hr = FileMonikerImpl_QueryInterface((IMoniker*)newFileMoniker,&IID_IMoniker,(void**)ppmk);
1402     else
1403         HeapFree(GetProcessHeap(),0,newFileMoniker);
1404
1405     return hr;
1406 }
1407
1408 static HRESULT WINAPI FileMonikerCF_QueryInterface(LPCLASSFACTORY iface,
1409                                                   REFIID riid, LPVOID *ppv)
1410 {
1411     *ppv = NULL;
1412     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
1413     {
1414         *ppv = iface;
1415         IUnknown_AddRef(iface);
1416         return S_OK;
1417     }
1418     return E_NOINTERFACE;
1419 }
1420
1421 static ULONG WINAPI FileMonikerCF_AddRef(LPCLASSFACTORY iface)
1422 {
1423     return 2; /* non-heap based object */
1424 }
1425
1426 static ULONG WINAPI FileMonikerCF_Release(LPCLASSFACTORY iface)
1427 {
1428     return 1; /* non-heap based object */
1429 }
1430
1431 static HRESULT WINAPI FileMonikerCF_CreateInstance(LPCLASSFACTORY iface,
1432     LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
1433 {
1434     FileMonikerImpl* newFileMoniker;
1435     HRESULT  hr;
1436     static const WCHAR wszEmpty[] = { 0 };
1437
1438     TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
1439
1440     *ppv = NULL;
1441
1442     if (pUnk)
1443         return CLASS_E_NOAGGREGATION;
1444
1445     newFileMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(FileMonikerImpl));
1446     if (!newFileMoniker)
1447         return E_OUTOFMEMORY;
1448
1449     hr = FileMonikerImpl_Construct(newFileMoniker, wszEmpty);
1450
1451     if (SUCCEEDED(hr))
1452         hr = FileMonikerImpl_QueryInterface((IMoniker*)newFileMoniker, riid, ppv);
1453     if (FAILED(hr))
1454         HeapFree(GetProcessHeap(),0,newFileMoniker);
1455
1456     return hr;
1457 }
1458
1459 static HRESULT WINAPI FileMonikerCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
1460 {
1461     FIXME("(%d), stub!\n",fLock);
1462     return S_OK;
1463 }
1464
1465 static const IClassFactoryVtbl FileMonikerCFVtbl =
1466 {
1467     FileMonikerCF_QueryInterface,
1468     FileMonikerCF_AddRef,
1469     FileMonikerCF_Release,
1470     FileMonikerCF_CreateInstance,
1471     FileMonikerCF_LockServer
1472 };
1473 static const IClassFactoryVtbl *FileMonikerCF = &FileMonikerCFVtbl;
1474
1475 HRESULT FileMonikerCF_Create(REFIID riid, LPVOID *ppv)
1476 {
1477     return IClassFactory_QueryInterface((IClassFactory *)&FileMonikerCF, riid, ppv);
1478 }