4 * Copyright 1995 Martin von Loewis
5 * Copyright 1998 Justin Bradford
6 * Copyright 1999 Francis Beaudet
7 * Copyright 1999 Sylvain St-Germain
8 * Copyright 2002 Marcus Meissner
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
44 #include "wine/unicode.h"
45 #include "wine/winbase16.h"
46 #include "compobj_private.h"
49 #include "wine/debug.h"
51 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
53 static HTASK16 hETask
= 0;
54 static WORD Table_ETask
[62];
56 static LPMALLOC16 currentMalloc16
=NULL
;
58 /* --- IMalloc16 implementation */
64 const IMalloc16Vtbl
*lpVtbl
;
66 /* IMalloc16 fields */
69 /******************************************************************************
70 * IMalloc16_QueryInterface [COMPOBJ.500]
72 HRESULT
IMalloc16_fnQueryInterface(IMalloc16
* iface
,REFIID refiid
,LPVOID
*obj
) {
73 IMalloc16Impl
*This
= (IMalloc16Impl
*)iface
;
75 TRACE("(%p)->QueryInterface(%s,%p)\n",This
,debugstr_guid(refiid
),obj
);
76 if ( !memcmp(&IID_IUnknown
,refiid
,sizeof(IID_IUnknown
)) ||
77 !memcmp(&IID_IMalloc
,refiid
,sizeof(IID_IMalloc
))
82 return OLE_E_ENUM_NOMORE
;
85 /******************************************************************************
86 * IMalloc16_AddRef [COMPOBJ.501]
88 ULONG
IMalloc16_fnAddRef(IMalloc16
* iface
) {
89 IMalloc16Impl
*This
= (IMalloc16Impl
*)iface
;
90 TRACE("(%p)->AddRef()\n",This
);
91 return 1; /* cannot be freed */
94 /******************************************************************************
95 * IMalloc16_Release [COMPOBJ.502]
97 ULONG
IMalloc16_fnRelease(IMalloc16
* iface
) {
98 IMalloc16Impl
*This
= (IMalloc16Impl
*)iface
;
99 TRACE("(%p)->Release()\n",This
);
100 return 1; /* cannot be freed */
103 /******************************************************************************
104 * IMalloc16_Alloc [COMPOBJ.503]
106 SEGPTR
IMalloc16_fnAlloc(IMalloc16
* iface
,DWORD cb
) {
107 IMalloc16Impl
*This
= (IMalloc16Impl
*)iface
;
108 TRACE("(%p)->Alloc(%ld)\n",This
,cb
);
109 return MapLS( HeapAlloc( GetProcessHeap(), 0, cb
) );
112 /******************************************************************************
113 * IMalloc16_Free [COMPOBJ.505]
115 VOID
IMalloc16_fnFree(IMalloc16
* iface
,SEGPTR pv
)
117 void *ptr
= MapSL(pv
);
118 IMalloc16Impl
*This
= (IMalloc16Impl
*)iface
;
119 TRACE("(%p)->Free(%08lx)\n",This
,pv
);
121 HeapFree( GetProcessHeap(), 0, ptr
);
124 /******************************************************************************
125 * IMalloc16_Realloc [COMPOBJ.504]
127 SEGPTR
IMalloc16_fnRealloc(IMalloc16
* iface
,SEGPTR pv
,DWORD cb
)
130 IMalloc16Impl
*This
= (IMalloc16Impl
*)iface
;
131 TRACE("(%p)->Realloc(%08lx,%ld)\n",This
,pv
,cb
);
133 ret
= IMalloc16_fnAlloc(iface
, cb
);
135 ret
= MapLS( HeapReAlloc( GetProcessHeap(), 0, MapSL(pv
), cb
) );
138 IMalloc16_fnFree(iface
, pv
);
144 /******************************************************************************
145 * IMalloc16_GetSize [COMPOBJ.506]
147 DWORD
IMalloc16_fnGetSize(const IMalloc16
* iface
,SEGPTR pv
)
149 IMalloc16Impl
*This
= (IMalloc16Impl
*)iface
;
150 TRACE("(%p)->GetSize(%08lx)\n",This
,pv
);
151 return HeapSize( GetProcessHeap(), 0, MapSL(pv
) );
154 /******************************************************************************
155 * IMalloc16_DidAlloc [COMPOBJ.507]
157 INT16
IMalloc16_fnDidAlloc(const IMalloc16
* iface
,LPVOID pv
) {
158 IMalloc16
*This
= (IMalloc16
*)iface
;
159 TRACE("(%p)->DidAlloc(%p)\n",This
,pv
);
163 /******************************************************************************
164 * IMalloc16_HeapMinimize [COMPOBJ.508]
166 LPVOID
IMalloc16_fnHeapMinimize(IMalloc16
* iface
) {
167 IMalloc16Impl
*This
= (IMalloc16Impl
*)iface
;
168 TRACE("(%p)->HeapMinimize()\n",This
);
172 /******************************************************************************
173 * IMalloc16_Constructor [VTABLE]
176 IMalloc16_Constructor()
178 static IMalloc16Vtbl vt16
;
179 static SEGPTR msegvt16
;
181 HMODULE16 hcomp
= GetModuleHandle16("COMPOBJ");
183 This
= HeapAlloc( GetProcessHeap(), 0, sizeof(IMalloc16Impl
) );
186 #define VTENT(x) vt16.x = (void*)GetProcAddress16(hcomp,"IMalloc16_"#x);assert(vt16.x)
187 VTENT(QueryInterface
);
197 msegvt16
= MapLS( &vt16
);
199 This
->lpVtbl
= (const IMalloc16Vtbl
*)msegvt16
;
201 return (LPMALLOC16
)MapLS( This
);
205 /***********************************************************************
206 * CoGetMalloc [COMPOBJ.4]
208 * The current win16 IMalloc
210 HRESULT WINAPI
CoGetMalloc16(
211 DWORD dwMemContext
, /* [in] unknown */
212 LPMALLOC16
* lpMalloc
/* [out] current win16 malloc interface */
215 currentMalloc16
= IMalloc16_Constructor();
216 *lpMalloc
= currentMalloc16
;
220 /***********************************************************************
221 * CoCreateStandardMalloc [COMPOBJ.71]
223 HRESULT WINAPI
CoCreateStandardMalloc16(DWORD dwMemContext
,
224 LPMALLOC16
*lpMalloc
)
226 /* FIXME: docu says we shouldn't return the same allocator as in
228 *lpMalloc
= IMalloc16_Constructor();
232 /******************************************************************************
233 * CoInitialize [COMPOBJ.2]
234 * Set the win16 IMalloc used for memory management
236 HRESULT WINAPI
CoInitialize16(
237 LPVOID lpReserved
/* [in] pointer to win16 malloc interface */
239 currentMalloc16
= (LPMALLOC16
)lpReserved
;
243 /***********************************************************************
244 * CoUninitialize [COMPOBJ.3]
245 * Don't know what it does.
246 * 3-Nov-98 -- this was originally misspelled, I changed it to what I
247 * believe is the correct spelling
249 void WINAPI
CoUninitialize16(void)
252 CoFreeAllLibraries();
255 /***********************************************************************
256 * IsEqualGUID [COMPOBJ.18]
258 * Compares two Unique Identifiers.
263 BOOL16 WINAPI
IsEqualGUID16(
264 GUID
* g1
, /* [in] unique id 1 */
265 GUID
* g2
) /* [in] unique id 2 */
267 return !memcmp( g1
, g2
, sizeof(GUID
) );
270 /******************************************************************************
271 * CLSIDFromString [COMPOBJ.20]
272 * Converts a unique identifier from its string representation into
275 * Class id: DWORD-WORD-WORD-BYTES[2]-BYTES[6]
280 HRESULT WINAPI
CLSIDFromString16(
281 LPCOLESTR16 idstr
, /* [in] string representation of guid */
282 CLSID
*id
) /* [out] GUID converted from string */
285 return __CLSIDFromStringA(idstr
,id
);
288 /******************************************************************************
289 * _xmalloc16 [internal]
290 * Allocates size bytes from the standard ole16 allocator.
293 * the allocated segmented pointer and a HRESULT
296 _xmalloc16(DWORD size
, SEGPTR
*ptr
) {
300 if (CoGetMalloc16(0,&mllc
))
301 return E_OUTOFMEMORY
;
303 args
[0] = (DWORD
)mllc
;
305 /* No need for a Callback entry, we have WOWCallback16Ex which does
306 * everything we need.
308 if (!WOWCallback16Ex(
309 (DWORD
)((const IMalloc16Vtbl
*)MapSL(
310 (SEGPTR
)((LPMALLOC16
)MapSL((SEGPTR
)mllc
))->lpVtbl
)
317 ERR("CallTo16 IMalloc16 (%ld) failed\n",size
);
323 /******************************************************************************
324 * StringFromCLSID [COMPOBJ.19]
325 * Converts a GUID into the respective string representation.
326 * The target string is allocated using the OLE IMalloc.
329 * the string representation and HRESULT
332 HRESULT WINAPI
StringFromCLSID16(
333 REFCLSID id
, /* [in] the GUID to be converted */
334 LPOLESTR16
*idstr
/* [out] a pointer to a to-be-allocated segmented pointer pointing to the resulting string */
339 ret
= _xmalloc16(40,(SEGPTR
*)idstr
);
342 return WINE_StringFromCLSID(id
,MapSL((SEGPTR
)*idstr
));
345 /******************************************************************************
346 * ProgIDFromCLSID [COMPOBJ.62]
347 * Converts a class id into the respective Program ID. (By using a registry lookup)
348 * RETURNS S_OK on success
349 * riid associated with the progid
351 HRESULT WINAPI
ProgIDFromCLSID16(
352 REFCLSID clsid
, /* [in] class id as found in registry */
353 LPOLESTR16
*lplpszProgID
/* [out] associated Prog ID */
355 static const WCHAR wszProgID
[] = {'P','r','o','g','I','D',0};
361 ret
= COM_OpenKeyForCLSID(clsid
, wszProgID
, KEY_READ
, &hkey
);
365 if (RegQueryValueA(hkey
, NULL
, NULL
, &len
))
366 ret
= REGDB_E_READREGDB
;
370 buffer
= HeapAlloc(GetProcessHeap(), 0, len
);
371 if (RegQueryValueA(hkey
, NULL
, buffer
, &len
))
372 ret
= REGDB_E_READREGDB
;
376 ret
= _xmalloc16(len
, (SEGPTR
*)lplpszProgID
);
378 strcpy(MapSL((SEGPTR
)*lplpszProgID
),buffer
);
380 HeapFree(GetProcessHeap(), 0, buffer
);
386 /***********************************************************************
387 * LookupETask (COMPOBJ.94)
389 HRESULT WINAPI
LookupETask16(HTASK16
*hTask
,LPVOID p
) {
390 FIXME("(%p,%p),stub!\n",hTask
,p
);
391 if ((*hTask
= GetCurrentTask()) == hETask
) {
392 memcpy(p
, Table_ETask
, sizeof(Table_ETask
));
397 /***********************************************************************
398 * SetETask (COMPOBJ.95)
400 HRESULT WINAPI
SetETask16(HTASK16 hTask
, LPVOID p
) {
401 FIXME("(%04x,%p),stub!\n",hTask
,p
);
406 /***********************************************************************
407 * CALLOBJECTINWOW (COMPOBJ.201)
409 HRESULT WINAPI
CallObjectInWOW(LPVOID p1
,LPVOID p2
) {
410 FIXME("(%p,%p),stub!\n",p1
,p2
);
414 /******************************************************************************
415 * CoRegisterClassObject [COMPOBJ.5]
417 * Don't know where it registers it ...
419 HRESULT WINAPI
CoRegisterClassObject16(
422 DWORD dwClsContext
, /* [in] CLSCTX flags indicating the context in which to run the executable */
423 DWORD flags
, /* [in] REGCLS flags indicating how connections are made */
426 FIXME("(%s,%p,0x%08lx,0x%08lx,%p),stub\n",
427 debugstr_guid(rclsid
),pUnk
,dwClsContext
,flags
,lpdwRegister
432 /******************************************************************************
433 * CoRevokeClassObject [COMPOBJ.6]
436 HRESULT WINAPI
CoRevokeClassObject16(DWORD dwRegister
) /* [in] token on class obj */
438 FIXME("(0x%08lx),stub!\n", dwRegister
);
442 /******************************************************************************
443 * CoFileTimeToDosDateTime [COMPOBJ.30]
445 BOOL16 WINAPI
CoFileTimeToDosDateTime16(const FILETIME
*ft
, LPWORD lpDosDate
, LPWORD lpDosTime
)
447 return FileTimeToDosDateTime(ft
, lpDosDate
, lpDosTime
);
450 /******************************************************************************
451 * CoDosDateTimeToFileTime [COMPOBJ.31]
453 BOOL16 WINAPI
CoDosDateTimeToFileTime16(WORD wDosDate
, WORD wDosTime
, FILETIME
*ft
)
455 return DosDateTimeToFileTime(wDosDate
, wDosTime
, ft
);
458 /******************************************************************************
459 * CoRegisterMessageFilter [COMPOBJ.27]
461 HRESULT WINAPI
CoRegisterMessageFilter16(
462 LPMESSAGEFILTER lpMessageFilter
,
463 LPMESSAGEFILTER
*lplpMessageFilter
465 FIXME("(%p,%p),stub!\n",lpMessageFilter
,lplpMessageFilter
);
469 /******************************************************************************
470 * CoLockObjectExternal [COMPOBJ.63]
472 HRESULT WINAPI
CoLockObjectExternal16(
473 LPUNKNOWN pUnk
, /* [in] object to be locked */
474 BOOL16 fLock
, /* [in] do lock */
475 BOOL16 fLastUnlockReleases
/* [in] ? */
477 FIXME("(%p,%d,%d),stub!\n",pUnk
,fLock
,fLastUnlockReleases
);
481 /***********************************************************************
482 * CoGetState [COMPOBJ.115]
484 HRESULT WINAPI
CoGetState16(LPDWORD state
)
486 FIXME("(%p),stub!\n", state
);
492 /***********************************************************************
493 * DllEntryPoint [COMPOBJ.116]
495 * Initialization code for the COMPOBJ DLL
499 BOOL WINAPI
COMPOBJ_DllEntryPoint(DWORD Reason
, HINSTANCE16 hInst
, WORD ds
, WORD HeapSize
, DWORD res1
, WORD res2
)
501 TRACE("(%08lx, %04x, %04x, %04x, %08lx, %04x)\n", Reason
, hInst
, ds
, HeapSize
, res1
, res2
);
505 /***********************************************************************
506 * CoMemAlloc [COMPOBJ.151]
508 SEGPTR WINAPI
CoMemAlloc(DWORD size
, DWORD dwMemContext
, DWORD x
) {
512 /* FIXME: check context handling */
513 TRACE("(%ld, 0x%08lx, 0x%08lx)\n", size
, dwMemContext
, x
);
514 hres
= _xmalloc16(size
, &segptr
);
520 /******************************************************************************
521 * CLSIDFromProgID [COMPOBJ.61]
523 * Converts a program ID into the respective GUID.
526 * progid [I] program id as found in registry
527 * riid [O] associated CLSID
531 * Failure: CO_E_CLASSSTRING - the given ProgID cannot be found.
533 HRESULT WINAPI
CLSIDFromProgID16(LPCOLESTR16 progid
, LPCLSID riid
)
540 buf
= HeapAlloc(GetProcessHeap(),0,strlen(progid
)+8);
541 sprintf(buf
,"%s\\CLSID",progid
);
542 if ((err
=RegOpenKeyA(HKEY_CLASSES_ROOT
,buf
,&xhkey
))) {
543 HeapFree(GetProcessHeap(),0,buf
);
544 return CO_E_CLASSSTRING
;
546 HeapFree(GetProcessHeap(),0,buf
);
547 buf2len
= sizeof(buf2
);
548 if ((err
=RegQueryValueA(xhkey
,NULL
,buf2
,&buf2len
))) {
550 return CO_E_CLASSSTRING
;
553 return __CLSIDFromStringA(buf2
,riid
);
556 /***********************************************************************
557 * CoGetClassObject [COMPOBJ.7]
560 HRESULT WINAPI
CoGetClassObject16(
561 REFCLSID rclsid
, DWORD dwClsContext
, COSERVERINFO
*pServerInfo
,
562 REFIID iid
, LPVOID
*ppv
)
564 FIXME(", stub!\n\tCLSID:\t%s,\n\tIID:\t%s\n", debugstr_guid(rclsid
), debugstr_guid(iid
));
567 FIXME("\tpServerInfo: name=%s\n",debugstr_w(pServerInfo
->pwszName
));
568 FIXME("\t\tpAuthInfo=%p\n",pServerInfo
->pAuthInfo
);
573 /***********************************************************************
574 * CoCreateInstance [COMPOBJ.13]
576 HRESULT WINAPI
CoCreateInstance16(
583 FIXME("(%s, %p, %lx, %s, %p), stub!\n",
584 debugstr_guid(rclsid
), pUnkOuter
, dwClsContext
, debugstr_guid(iid
),
590 /***********************************************************************
591 * DllGetClassObject [OLE2.4]
593 HRESULT WINAPI
DllGetClassObject16(REFCLSID rclsid
, REFIID iid
, LPVOID
*ppv
)
595 FIXME("(%s, %s, %p): stub\n", debugstr_guid(rclsid
), debugstr_guid(iid
), ppv
);
599 /******************************************************************************
600 * GetRunningObjectTable (OLE2.30)
603 GetRunningObjectTable16(DWORD reserved
, LPRUNNINGOBJECTTABLE
*pprot
)
605 FIXME("(%ld,%p),stub!\n",reserved
,pprot
);