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 HINSTANCE16 COMPOBJ_hInstance
= 0;
54 static int COMPOBJ_Attach
= 0;
59 LPMALLOC16 currentMalloc16
=NULL
;
61 /* --- IMalloc16 implementation */
67 IMalloc16Vtbl
*lpVtbl
;
69 /* IMalloc16 fields */
72 /******************************************************************************
73 * IMalloc16_QueryInterface [COMPOBJ.500]
75 HRESULT WINAPI
IMalloc16_fnQueryInterface(IMalloc16
* iface
,REFIID refiid
,LPVOID
*obj
) {
76 ICOM_THIS(IMalloc16Impl
,iface
);
78 TRACE("(%p)->QueryInterface(%s,%p)\n",This
,debugstr_guid(refiid
),obj
);
79 if ( !memcmp(&IID_IUnknown
,refiid
,sizeof(IID_IUnknown
)) ||
80 !memcmp(&IID_IMalloc
,refiid
,sizeof(IID_IMalloc
))
85 return OLE_E_ENUM_NOMORE
;
88 /******************************************************************************
89 * IMalloc16_AddRef [COMPOBJ.501]
91 ULONG WINAPI
IMalloc16_fnAddRef(IMalloc16
* iface
) {
92 ICOM_THIS(IMalloc16Impl
,iface
);
93 TRACE("(%p)->AddRef()\n",This
);
94 return 1; /* cannot be freed */
97 /******************************************************************************
98 * IMalloc16_Release [COMPOBJ.502]
100 ULONG WINAPI
IMalloc16_fnRelease(IMalloc16
* iface
) {
101 ICOM_THIS(IMalloc16Impl
,iface
);
102 TRACE("(%p)->Release()\n",This
);
103 return 1; /* cannot be freed */
106 /******************************************************************************
107 * IMalloc16_Alloc [COMPOBJ.503]
109 SEGPTR WINAPI
IMalloc16_fnAlloc(IMalloc16
* iface
,DWORD cb
) {
110 ICOM_THIS(IMalloc16Impl
,iface
);
111 TRACE("(%p)->Alloc(%ld)\n",This
,cb
);
112 return MapLS( HeapAlloc( GetProcessHeap(), 0, cb
) );
115 /******************************************************************************
116 * IMalloc16_Free [COMPOBJ.505]
118 VOID WINAPI
IMalloc16_fnFree(IMalloc16
* iface
,SEGPTR pv
)
120 void *ptr
= MapSL(pv
);
121 ICOM_THIS(IMalloc16Impl
,iface
);
122 TRACE("(%p)->Free(%08lx)\n",This
,pv
);
124 HeapFree( GetProcessHeap(), 0, ptr
);
127 /******************************************************************************
128 * IMalloc16_Realloc [COMPOBJ.504]
130 SEGPTR WINAPI
IMalloc16_fnRealloc(IMalloc16
* iface
,SEGPTR pv
,DWORD cb
)
133 ICOM_THIS(IMalloc16Impl
,iface
);
134 TRACE("(%p)->Realloc(%08lx,%ld)\n",This
,pv
,cb
);
136 ret
= IMalloc16_fnAlloc(iface
, cb
);
138 ret
= MapLS( HeapReAlloc( GetProcessHeap(), 0, MapSL(pv
), cb
) );
141 IMalloc16_fnFree(iface
, pv
);
147 /******************************************************************************
148 * IMalloc16_GetSize [COMPOBJ.506]
150 DWORD WINAPI
IMalloc16_fnGetSize(const IMalloc16
* iface
,SEGPTR pv
)
152 ICOM_THIS(IMalloc16Impl
,iface
);
153 TRACE("(%p)->GetSize(%08lx)\n",This
,pv
);
154 return HeapSize( GetProcessHeap(), 0, MapSL(pv
) );
157 /******************************************************************************
158 * IMalloc16_DidAlloc [COMPOBJ.507]
160 INT16 WINAPI
IMalloc16_fnDidAlloc(const IMalloc16
* iface
,LPVOID pv
) {
161 ICOM_THIS(IMalloc16
,iface
);
162 TRACE("(%p)->DidAlloc(%p)\n",This
,pv
);
166 /******************************************************************************
167 * IMalloc16_HeapMinimize [COMPOBJ.508]
169 LPVOID WINAPI
IMalloc16_fnHeapMinimize(IMalloc16
* iface
) {
170 ICOM_THIS(IMalloc16Impl
,iface
);
171 TRACE("(%p)->HeapMinimize()\n",This
);
175 /******************************************************************************
176 * IMalloc16_Constructor [VTABLE]
179 IMalloc16_Constructor()
181 static ICOM_VTABLE(IMalloc16
) vt16
;
182 static SEGPTR msegvt16
;
184 HMODULE16 hcomp
= GetModuleHandle16("COMPOBJ");
186 This
= HeapAlloc( GetProcessHeap(), 0, sizeof(IMalloc16Impl
) );
189 #define VTENT(x) vt16.x = (void*)GetProcAddress16(hcomp,"IMalloc16_"#x);assert(vt16.x)
190 VTENT(QueryInterface
);
200 msegvt16
= MapLS( &vt16
);
202 This
->lpVtbl
= (ICOM_VTABLE(IMalloc16
)*)msegvt16
;
204 return (LPMALLOC16
)MapLS( This
);
208 /***********************************************************************
209 * CoGetMalloc [COMPOBJ.4]
211 * The current win16 IMalloc
213 HRESULT WINAPI
CoGetMalloc16(
214 DWORD dwMemContext
, /* [in] unknown */
215 LPMALLOC16
* lpMalloc
/* [out] current win16 malloc interface */
218 currentMalloc16
= IMalloc16_Constructor();
219 *lpMalloc
= currentMalloc16
;
223 /***********************************************************************
224 * CoCreateStandardMalloc [COMPOBJ.71]
226 HRESULT WINAPI
CoCreateStandardMalloc16(DWORD dwMemContext
,
227 LPMALLOC16
*lpMalloc
)
229 /* FIXME: docu says we shouldn't return the same allocator as in
231 *lpMalloc
= IMalloc16_Constructor();
235 /******************************************************************************
236 * CoInitialize [COMPOBJ.2]
237 * Set the win16 IMalloc used for memory management
239 HRESULT WINAPI
CoInitialize16(
240 LPVOID lpReserved
/* [in] pointer to win16 malloc interface */
242 currentMalloc16
= (LPMALLOC16
)lpReserved
;
246 /***********************************************************************
247 * CoUninitialize [COMPOBJ.3]
248 * Don't know what it does.
249 * 3-Nov-98 -- this was originally misspelled, I changed it to what I
250 * believe is the correct spelling
252 void WINAPI
CoUninitialize16(void)
255 CoFreeAllLibraries();
258 /***********************************************************************
259 * IsEqualGUID [COMPOBJ.18]
261 * Compares two Unique Identifiers.
266 BOOL16 WINAPI
IsEqualGUID16(
267 GUID
* g1
, /* [in] unique id 1 */
268 GUID
* g2
) /* [in] unique id 2 */
270 return !memcmp( g1
, g2
, sizeof(GUID
) );
273 /******************************************************************************
274 * CLSIDFromString [COMPOBJ.20]
275 * Converts a unique identifier from its string representation into
278 * Class id: DWORD-WORD-WORD-BYTES[2]-BYTES[6]
283 HRESULT WINAPI
CLSIDFromString16(
284 LPCOLESTR16 idstr
, /* [in] string representation of guid */
285 CLSID
*id
) /* [out] GUID converted from string */
288 return __CLSIDFromStringA(idstr
,id
);
291 extern BOOL WINAPI
K32WOWCallback16Ex( DWORD vpfn16
, DWORD dwFlags
,
292 DWORD cbArgs
, LPVOID pArgs
,
293 LPDWORD pdwRetCode
);
295 /******************************************************************************
296 * _xmalloc16 [internal]
297 * Allocates size bytes from the standard ole16 allocator.
300 * the allocated segmented pointer and a HRESULT
303 _xmalloc16(DWORD size
, SEGPTR
*ptr
) {
307 if (CoGetMalloc16(0,&mllc
))
308 return E_OUTOFMEMORY
;
310 args
[0] = (DWORD
)mllc
;
312 /* No need for a Callback entry, we have WOWCallback16Ex which does
313 * everything we need.
315 if (!K32WOWCallback16Ex(
316 (DWORD
)((ICOM_VTABLE(IMalloc16
)*)MapSL(
317 (SEGPTR
)((LPMALLOC16
)MapSL((SEGPTR
)mllc
))->lpVtbl
)
324 ERR("CallTo16 IMalloc16 (%ld) failed\n",size
);
330 /******************************************************************************
331 * StringFromCLSID [COMPOBJ.19]
332 * Converts a GUID into the respective string representation.
333 * The target string is allocated using the OLE IMalloc.
336 * the string representation and HRESULT
339 HRESULT WINAPI
StringFromCLSID16(
340 REFCLSID id
, /* [in] the GUID to be converted */
341 LPOLESTR16
*idstr
/* [out] a pointer to a to-be-allocated segmented pointer pointing to the resulting string */
346 ret
= _xmalloc16(40,(SEGPTR
*)idstr
);
349 return WINE_StringFromCLSID(id
,MapSL((SEGPTR
)*idstr
));
352 /******************************************************************************
353 * ProgIDFromCLSID [COMPOBJ.62]
354 * Converts a class id into the respective Program ID. (By using a registry lookup)
355 * RETURNS S_OK on success
356 * riid associated with the progid
358 HRESULT WINAPI
ProgIDFromCLSID16(
359 REFCLSID clsid
, /* [in] class id as found in registry */
360 LPOLESTR16
*lplpszProgID
/* [out] associated Prog ID */
362 char strCLSID
[50], *buf
, *buf2
;
367 WINE_StringFromCLSID(clsid
, strCLSID
);
369 buf
= HeapAlloc(GetProcessHeap(), 0, strlen(strCLSID
)+14);
370 sprintf(buf
,"CLSID\\%s\\ProgID", strCLSID
);
371 if (RegOpenKeyA(HKEY_CLASSES_ROOT
, buf
, &xhkey
))
372 ret
= REGDB_E_CLASSNOTREG
;
374 HeapFree(GetProcessHeap(), 0, buf
);
378 buf2
= HeapAlloc(GetProcessHeap(), 0, 255);
380 if (RegQueryValueA(xhkey
, NULL
, buf2
, &buf2len
))
381 ret
= REGDB_E_CLASSNOTREG
;
385 ret
= _xmalloc16(buf2len
+1, (SEGPTR
*)lplpszProgID
);
387 strcpy(MapSL((SEGPTR
)*lplpszProgID
),buf2
);
389 HeapFree(GetProcessHeap(), 0, buf2
);
395 /***********************************************************************
396 * LookupETask (COMPOBJ.94)
398 HRESULT WINAPI
LookupETask16(HTASK16
*hTask
,LPVOID p
) {
399 FIXME("(%p,%p),stub!\n",hTask
,p
);
400 if ((*hTask
= GetCurrentTask()) == hETask
) {
401 memcpy(p
, Table_ETask
, sizeof(Table_ETask
));
406 /***********************************************************************
407 * SetETask (COMPOBJ.95)
409 HRESULT WINAPI
SetETask16(HTASK16 hTask
, LPVOID p
) {
410 FIXME("(%04x,%p),stub!\n",hTask
,p
);
415 /***********************************************************************
416 * CALLOBJECTINWOW (COMPOBJ.201)
418 HRESULT WINAPI
CallObjectInWOW(LPVOID p1
,LPVOID p2
) {
419 FIXME("(%p,%p),stub!\n",p1
,p2
);
423 /******************************************************************************
424 * CoRegisterClassObject [COMPOBJ.5]
426 * Don't know where it registers it ...
428 HRESULT WINAPI
CoRegisterClassObject16(
431 DWORD dwClsContext
, /* [in] CLSCTX flags indicating the context in which to run the executable */
432 DWORD flags
, /* [in] REGCLS flags indicating how connections are made */
437 WINE_StringFromCLSID(rclsid
,buf
);
439 FIXME("(%s,%p,0x%08lx,0x%08lx,%p),stub\n",
440 buf
,pUnk
,dwClsContext
,flags
,lpdwRegister
445 /******************************************************************************
446 * CoRevokeClassObject [COMPOBJ.6]
449 HRESULT WINAPI
CoRevokeClassObject16(DWORD dwRegister
) /* [in] token on class obj */
451 FIXME("(0x%08lx),stub!\n", dwRegister
);
455 /******************************************************************************
456 * CoFileTimeToDosDateTime [COMPOBJ.30]
458 BOOL16 WINAPI
CoFileTimeToDosDateTime16(const FILETIME
*ft
, LPWORD lpDosDate
, LPWORD lpDosTime
)
460 return FileTimeToDosDateTime(ft
, lpDosDate
, lpDosTime
);
463 /******************************************************************************
464 * CoDosDateTimeToFileTime [COMPOBJ.31]
466 BOOL16 WINAPI
CoDosDateTimeToFileTime16(WORD wDosDate
, WORD wDosTime
, FILETIME
*ft
)
468 return DosDateTimeToFileTime(wDosDate
, wDosTime
, ft
);
471 /******************************************************************************
472 * CoRegisterMessageFilter [COMPOBJ.27]
474 HRESULT WINAPI
CoRegisterMessageFilter16(
475 LPMESSAGEFILTER lpMessageFilter
,
476 LPMESSAGEFILTER
*lplpMessageFilter
478 FIXME("(%p,%p),stub!\n",lpMessageFilter
,lplpMessageFilter
);
482 /******************************************************************************
483 * CoLockObjectExternal [COMPOBJ.63]
485 HRESULT WINAPI
CoLockObjectExternal16(
486 LPUNKNOWN pUnk
, /* [in] object to be locked */
487 BOOL16 fLock
, /* [in] do lock */
488 BOOL16 fLastUnlockReleases
/* [in] ? */
490 FIXME("(%p,%d,%d),stub!\n",pUnk
,fLock
,fLastUnlockReleases
);
494 /***********************************************************************
495 * CoGetState [COMPOBJ.115]
497 HRESULT WINAPI
CoGetState16(LPDWORD state
)
499 FIXME("(%p),stub!\n", state
);
505 /***********************************************************************
506 * DllEntryPoint [COMPOBJ.116]
508 * Initialization code for the COMPOBJ DLL
512 BOOL WINAPI
COMPOBJ_DllEntryPoint(DWORD Reason
, HINSTANCE16 hInst
, WORD ds
, WORD HeapSize
, DWORD res1
, WORD res2
)
514 TRACE("(%08lx, %04x, %04x, %04x, %08lx, %04x)\n", Reason
, hInst
, ds
, HeapSize
, res1
, res2
);
517 case DLL_PROCESS_ATTACH
:
518 if (!COMPOBJ_Attach
++) COMPOBJ_hInstance
= hInst
;
521 case DLL_PROCESS_DETACH
:
522 if(!--COMPOBJ_Attach
)
523 COMPOBJ_hInstance
= 0;