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 * Retrieve the current win16 IMalloc interface.
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 /******************************************************************************
292 * _xmalloc16 [internal]
293 * Allocates size bytes from the standard ole16 allocator.
296 * the allocated segmented pointer and a HRESULT
299 _xmalloc16(DWORD size
, SEGPTR
*ptr
) {
303 if (CoGetMalloc16(0,&mllc
))
304 return E_OUTOFMEMORY
;
306 args
[0] = (DWORD
)mllc
;
308 /* No need for a Callback entry, we have WOWCallback16Ex which does
309 * everything we need.
311 if (!WOWCallback16Ex(
312 (DWORD
)((const IMalloc16Vtbl
*)MapSL(
313 (SEGPTR
)((LPMALLOC16
)MapSL((SEGPTR
)mllc
))->lpVtbl
)
320 ERR("CallTo16 IMalloc16 (%ld) failed\n",size
);
326 /******************************************************************************
327 * StringFromCLSID [COMPOBJ.19]
328 * Converts a GUID into the respective string representation.
329 * The target string is allocated using the OLE IMalloc.
332 * the string representation and HRESULT
335 HRESULT WINAPI
StringFromCLSID16(
336 REFCLSID id
, /* [in] the GUID to be converted */
337 LPOLESTR16
*idstr
/* [out] a pointer to a to-be-allocated segmented pointer pointing to the resulting string */
342 ret
= _xmalloc16(40,(SEGPTR
*)idstr
);
345 return WINE_StringFromCLSID(id
,MapSL((SEGPTR
)*idstr
));
348 /******************************************************************************
349 * ProgIDFromCLSID [COMPOBJ.62]
351 * Converts a class id into the respective Program ID. (By using a registry lookup)
355 * riid associated with the progid
357 HRESULT WINAPI
ProgIDFromCLSID16(
358 REFCLSID clsid
, /* [in] class id as found in registry */
359 LPOLESTR16
*lplpszProgID
/* [out] associated Prog ID */
361 static const WCHAR wszProgID
[] = {'P','r','o','g','I','D',0};
367 ret
= COM_OpenKeyForCLSID(clsid
, wszProgID
, KEY_READ
, &hkey
);
371 if (RegQueryValueA(hkey
, NULL
, NULL
, &len
))
372 ret
= REGDB_E_READREGDB
;
376 buffer
= HeapAlloc(GetProcessHeap(), 0, len
);
377 if (RegQueryValueA(hkey
, NULL
, buffer
, &len
))
378 ret
= REGDB_E_READREGDB
;
382 ret
= _xmalloc16(len
, (SEGPTR
*)lplpszProgID
);
384 strcpy(MapSL((SEGPTR
)*lplpszProgID
),buffer
);
386 HeapFree(GetProcessHeap(), 0, buffer
);
392 /***********************************************************************
393 * LookupETask (COMPOBJ.94)
395 HRESULT WINAPI
LookupETask16(HTASK16
*hTask
,LPVOID p
) {
396 FIXME("(%p,%p),stub!\n",hTask
,p
);
397 if ((*hTask
= GetCurrentTask()) == hETask
) {
398 memcpy(p
, Table_ETask
, sizeof(Table_ETask
));
403 /***********************************************************************
404 * SetETask (COMPOBJ.95)
406 HRESULT WINAPI
SetETask16(HTASK16 hTask
, LPVOID p
) {
407 FIXME("(%04x,%p),stub!\n",hTask
,p
);
412 /***********************************************************************
413 * CALLOBJECTINWOW (COMPOBJ.201)
415 HRESULT WINAPI
CallObjectInWOW(LPVOID p1
,LPVOID p2
) {
416 FIXME("(%p,%p),stub!\n",p1
,p2
);
420 /******************************************************************************
421 * CoRegisterClassObject [COMPOBJ.5]
423 * Don't know where it registers it ...
425 HRESULT WINAPI
CoRegisterClassObject16(
428 DWORD dwClsContext
, /* [in] CLSCTX flags indicating the context in which to run the executable */
429 DWORD flags
, /* [in] REGCLS flags indicating how connections are made */
432 FIXME("(%s,%p,0x%08lx,0x%08lx,%p),stub\n",
433 debugstr_guid(rclsid
),pUnk
,dwClsContext
,flags
,lpdwRegister
438 /******************************************************************************
439 * CoRevokeClassObject [COMPOBJ.6]
442 HRESULT WINAPI
CoRevokeClassObject16(DWORD dwRegister
) /* [in] token on class obj */
444 FIXME("(0x%08lx),stub!\n", dwRegister
);
448 /******************************************************************************
449 * CoFileTimeToDosDateTime [COMPOBJ.30]
451 BOOL16 WINAPI
CoFileTimeToDosDateTime16(const FILETIME
*ft
, LPWORD lpDosDate
, LPWORD lpDosTime
)
453 return FileTimeToDosDateTime(ft
, lpDosDate
, lpDosTime
);
456 /******************************************************************************
457 * CoDosDateTimeToFileTime [COMPOBJ.31]
459 BOOL16 WINAPI
CoDosDateTimeToFileTime16(WORD wDosDate
, WORD wDosTime
, FILETIME
*ft
)
461 return DosDateTimeToFileTime(wDosDate
, wDosTime
, ft
);
464 /******************************************************************************
465 * CoRegisterMessageFilter [COMPOBJ.27]
467 HRESULT WINAPI
CoRegisterMessageFilter16(
468 LPMESSAGEFILTER lpMessageFilter
,
469 LPMESSAGEFILTER
*lplpMessageFilter
471 FIXME("(%p,%p),stub!\n",lpMessageFilter
,lplpMessageFilter
);
475 /******************************************************************************
476 * CoLockObjectExternal [COMPOBJ.63]
478 HRESULT WINAPI
CoLockObjectExternal16(
479 LPUNKNOWN pUnk
, /* [in] object to be locked */
480 BOOL16 fLock
, /* [in] do lock */
481 BOOL16 fLastUnlockReleases
/* [in] ? */
483 FIXME("(%p,%d,%d),stub!\n",pUnk
,fLock
,fLastUnlockReleases
);
487 /***********************************************************************
488 * CoGetState [COMPOBJ.115]
490 HRESULT WINAPI
CoGetState16(LPDWORD state
)
492 FIXME("(%p),stub!\n", state
);
498 /***********************************************************************
499 * DllEntryPoint [COMPOBJ.116]
501 * Initialization code for the COMPOBJ DLL
505 BOOL WINAPI
COMPOBJ_DllEntryPoint(DWORD Reason
, HINSTANCE16 hInst
, WORD ds
, WORD HeapSize
, DWORD res1
, WORD res2
)
507 TRACE("(%08lx, %04x, %04x, %04x, %08lx, %04x)\n", Reason
, hInst
, ds
, HeapSize
, res1
, res2
);
511 /***********************************************************************
512 * CoMemAlloc [COMPOBJ.151]
514 SEGPTR WINAPI
CoMemAlloc(DWORD size
, DWORD dwMemContext
, DWORD x
) {
518 /* FIXME: check context handling */
519 TRACE("(%ld, 0x%08lx, 0x%08lx)\n", size
, dwMemContext
, x
);
520 hres
= _xmalloc16(size
, &segptr
);
526 /******************************************************************************
527 * CLSIDFromProgID [COMPOBJ.61]
529 * Converts a program ID into the respective GUID.
532 * progid [I] program id as found in registry
533 * riid [O] associated CLSID
537 * Failure: CO_E_CLASSSTRING - the given ProgID cannot be found.
539 HRESULT WINAPI
CLSIDFromProgID16(LPCOLESTR16 progid
, LPCLSID riid
)
546 buf
= HeapAlloc(GetProcessHeap(),0,strlen(progid
)+8);
547 sprintf(buf
,"%s\\CLSID",progid
);
548 if ((err
=RegOpenKeyA(HKEY_CLASSES_ROOT
,buf
,&xhkey
))) {
549 HeapFree(GetProcessHeap(),0,buf
);
550 return CO_E_CLASSSTRING
;
552 HeapFree(GetProcessHeap(),0,buf
);
553 buf2len
= sizeof(buf2
);
554 if ((err
=RegQueryValueA(xhkey
,NULL
,buf2
,&buf2len
))) {
556 return CO_E_CLASSSTRING
;
559 return __CLSIDFromStringA(buf2
,riid
);
562 /***********************************************************************
563 * CoGetClassObject [COMPOBJ.7]
566 HRESULT WINAPI
CoGetClassObject16(
567 REFCLSID rclsid
, DWORD dwClsContext
, COSERVERINFO
*pServerInfo
,
568 REFIID iid
, LPVOID
*ppv
)
570 FIXME(", stub!\n\tCLSID:\t%s,\n\tIID:\t%s\n", debugstr_guid(rclsid
), debugstr_guid(iid
));
573 FIXME("\tpServerInfo: name=%s\n",debugstr_w(pServerInfo
->pwszName
));
574 FIXME("\t\tpAuthInfo=%p\n",pServerInfo
->pAuthInfo
);
579 /***********************************************************************
580 * CoCreateInstance [COMPOBJ.13]
582 HRESULT WINAPI
CoCreateInstance16(
589 FIXME("(%s, %p, %lx, %s, %p), stub!\n",
590 debugstr_guid(rclsid
), pUnkOuter
, dwClsContext
, debugstr_guid(iid
),
596 /***********************************************************************
597 * DllGetClassObject [OLE2.4]
599 HRESULT WINAPI
DllGetClassObject16(REFCLSID rclsid
, REFIID iid
, LPVOID
*ppv
)
601 FIXME("(%s, %s, %p): stub\n", debugstr_guid(rclsid
), debugstr_guid(iid
), ppv
);
605 /******************************************************************************
606 * GetRunningObjectTable (OLE2.30)
609 GetRunningObjectTable16(DWORD reserved
, LPRUNNINGOBJECTTABLE
*pprot
)
611 FIXME("(%ld,%p),stub!\n",reserved
,pprot
);