4 * Copyright 1997 Marcus Meissner
6 * 2000 Francois Jacques
7 * 2001 Huw D M Davies for CodeWeavers
8 * 2005 Robert Shearman, for CodeWeavers
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 * --------------------------------------------------------------------------------------
25 * Known problems (2000, Francois Jacques)
27 * - Tested using OLEVIEW (Platform SDK tool) only.
29 * - dual interface dispinterfaces. vtable-interface ITypeInfo instances are
30 * creating by doing a straight copy of the dispinterface instance and just changing
31 * its typekind. Pointed structures aren't copied - only the address of the pointers.
33 * - locale stuff is partially implemented but hasn't been tested.
35 * - typelib file is still read in its entirety, but it is released now.
37 * --------------------------------------------------------------------------------------
38 * Known problems left from previous implementation (1999, Rein Klazes) :
40 * -. Data structures are straightforward, but slow for look-ups.
41 * -. (related) nothing is hashed
42 * -. Most error return values are just guessed not checked with windows
44 * -. lousy fatal error handling
49 #include "wine/port.h"
58 #define NONAMELESSUNION
59 #define NONAMELESSSTRUCT
68 #include "wine/unicode.h"
71 #include "wine/debug.h"
73 #include "wine/list.h"
75 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
76 WINE_DECLARE_DEBUG_CHANNEL(typelib
);
78 static HRESULT
typedescvt_to_variantvt(ITypeInfo
*tinfo
, const TYPEDESC
*tdesc
, VARTYPE
*vt
);
79 static HRESULT
TLB_AllocAndInitVarDesc(const VARDESC
*src
, VARDESC
**dest_ptr
);
81 /****************************************************************************
84 * Takes p_iVal (which is in little endian) and returns it
85 * in the host machine's byte order.
87 #ifdef WORDS_BIGENDIAN
88 static WORD
FromLEWord(WORD p_iVal
)
90 return (((p_iVal
& 0x00FF) << 8) |
91 ((p_iVal
& 0xFF00) >> 8));
95 static DWORD
FromLEDWord(DWORD p_iVal
)
97 return (((p_iVal
& 0x000000FF) << 24) |
98 ((p_iVal
& 0x0000FF00) << 8) |
99 ((p_iVal
& 0x00FF0000) >> 8) |
100 ((p_iVal
& 0xFF000000) >> 24));
103 #define FromLEWord(X) (X)
104 #define FromLEDWord(X) (X)
107 #define DISPATCH_HREF_OFFSET 0x01000000
108 #define DISPATCH_HREF_MASK 0xff000000
110 /****************************************************************************
113 * Fix byte order in any structure if necessary
115 #ifdef WORDS_BIGENDIAN
116 static void FromLEWords(void *p_Val
, int p_iSize
)
120 p_iSize
/= sizeof(WORD
);
123 *Val
= FromLEWord(*Val
);
130 static void FromLEDWords(void *p_Val
, int p_iSize
)
134 p_iSize
/= sizeof(DWORD
);
137 *Val
= FromLEDWord(*Val
);
143 #define FromLEWords(X,Y) /*nothing*/
144 #define FromLEDWords(X,Y) /*nothing*/
148 * Find a typelib key which matches a requested maj.min version.
150 static BOOL
find_typelib_key( REFGUID guid
, WORD
*wMaj
, WORD
*wMin
)
152 static const WCHAR typelibW
[] = {'T','y','p','e','l','i','b','\\',0};
159 memcpy( buffer
, typelibW
, sizeof(typelibW
) );
160 StringFromGUID2( guid
, buffer
+ strlenW(buffer
), 40 );
162 if (RegOpenKeyExW( HKEY_CLASSES_ROOT
, buffer
, 0, KEY_READ
, &hkey
) != ERROR_SUCCESS
)
165 len
= sizeof(key_name
);
167 while (RegEnumKeyExA(hkey
, i
++, key_name
, &len
, NULL
, NULL
, NULL
, NULL
) == ERROR_SUCCESS
)
171 if (sscanf(key_name
, "%x.%x", &v_maj
, &v_min
) == 2)
173 TRACE("found %s: %x.%x\n", debugstr_w(buffer
), v_maj
, v_min
);
180 break; /* exact match */
182 if (v_min
> best_min
) best_min
= v_min
;
185 len
= sizeof(key_name
);
196 /* get the path of a typelib key, in the form "Typelib\\<guid>\\<maj>.<min>" */
197 /* buffer must be at least 60 characters long */
198 static WCHAR
*get_typelib_key( REFGUID guid
, WORD wMaj
, WORD wMin
, WCHAR
*buffer
)
200 static const WCHAR TypelibW
[] = {'T','y','p','e','l','i','b','\\',0};
201 static const WCHAR VersionFormatW
[] = {'\\','%','x','.','%','x',0};
203 memcpy( buffer
, TypelibW
, sizeof(TypelibW
) );
204 StringFromGUID2( guid
, buffer
+ strlenW(buffer
), 40 );
205 sprintfW( buffer
+ strlenW(buffer
), VersionFormatW
, wMaj
, wMin
);
209 /* get the path of an interface key, in the form "Interface\\<guid>" */
210 /* buffer must be at least 50 characters long */
211 static WCHAR
*get_interface_key( REFGUID guid
, WCHAR
*buffer
)
213 static const WCHAR InterfaceW
[] = {'I','n','t','e','r','f','a','c','e','\\',0};
215 memcpy( buffer
, InterfaceW
, sizeof(InterfaceW
) );
216 StringFromGUID2( guid
, buffer
+ strlenW(buffer
), 40 );
220 /* get the lcid subkey for a typelib, in the form "<lcid>\\<syskind>" */
221 /* buffer must be at least 16 characters long */
222 static WCHAR
*get_lcid_subkey( LCID lcid
, SYSKIND syskind
, WCHAR
*buffer
)
224 static const WCHAR LcidFormatW
[] = {'%','l','x','\\',0};
225 static const WCHAR win16W
[] = {'w','i','n','1','6',0};
226 static const WCHAR win32W
[] = {'w','i','n','3','2',0};
228 sprintfW( buffer
, LcidFormatW
, lcid
);
231 case SYS_WIN16
: strcatW( buffer
, win16W
); break;
232 case SYS_WIN32
: strcatW( buffer
, win32W
); break;
234 TRACE("Typelib is for unsupported syskind %i\n", syskind
);
240 static int TLB_ReadTypeLib(LPCWSTR pszFileName
, LPWSTR pszPath
, UINT cchPath
, ITypeLib2
**ppTypeLib
);
243 /****************************************************************************
244 * QueryPathOfRegTypeLib [OLEAUT32.164]
246 * Gets the path to a registered type library.
249 * guid [I] referenced guid
250 * wMaj [I] major version
251 * wMin [I] minor version
253 * path [O] path of typelib
257 * Failure: If the type library is not registered then TYPE_E_LIBNOTREGISTERED
258 * or TYPE_E_REGISTRYACCESS if the type library registration key couldn't be
261 HRESULT WINAPI
QueryPathOfRegTypeLib(
268 HRESULT hr
= TYPE_E_LIBNOTREGISTERED
;
272 WCHAR Path
[MAX_PATH
];
275 TRACE_(typelib
)("(%s, %x.%x, 0x%x, %p)\n", debugstr_guid(guid
), wMaj
, wMin
, lcid
, path
);
277 if (!find_typelib_key( guid
, &wMaj
, &wMin
)) return TYPE_E_LIBNOTREGISTERED
;
278 get_typelib_key( guid
, wMaj
, wMin
, buffer
);
280 res
= RegOpenKeyExW( HKEY_CLASSES_ROOT
, buffer
, 0, KEY_READ
, &hkey
);
281 if (res
== ERROR_FILE_NOT_FOUND
)
283 TRACE_(typelib
)("%s not found\n", debugstr_w(buffer
));
284 return TYPE_E_LIBNOTREGISTERED
;
286 else if (res
!= ERROR_SUCCESS
)
288 TRACE_(typelib
)("failed to open %s for read access\n", debugstr_w(buffer
));
289 return TYPE_E_REGISTRYACCESS
;
294 LONG dwPathLen
= sizeof(Path
);
296 get_lcid_subkey( myLCID
, SYS_WIN32
, buffer
);
298 if (RegQueryValueW(hkey
, buffer
, Path
, &dwPathLen
))
302 else if (myLCID
== lcid
)
304 /* try with sub-langid */
305 myLCID
= SUBLANGID(lcid
);
307 else if ((myLCID
== SUBLANGID(lcid
)) && myLCID
)
309 /* try with system langid */
319 *path
= SysAllocString( Path
);
324 TRACE_(typelib
)("-- 0x%08x\n", hr
);
328 /******************************************************************************
329 * CreateTypeLib [OLEAUT32.160] creates a typelib
335 HRESULT WINAPI
CreateTypeLib(
336 SYSKIND syskind
, LPCOLESTR szFile
, ICreateTypeLib
** ppctlib
338 FIXME("(%d,%s,%p), stub!\n",syskind
,debugstr_w(szFile
),ppctlib
);
342 /******************************************************************************
343 * LoadTypeLib [OLEAUT32.161]
345 * Loads a type library
348 * szFile [I] Name of file to load from.
349 * pptLib [O] Pointer that receives ITypeLib object on success.
356 * LoadTypeLibEx, LoadRegTypeLib, CreateTypeLib.
358 HRESULT WINAPI
LoadTypeLib(const OLECHAR
*szFile
, ITypeLib
* *pptLib
)
360 TRACE("(%s,%p)\n",debugstr_w(szFile
), pptLib
);
361 return LoadTypeLibEx(szFile
, REGKIND_DEFAULT
, pptLib
);
364 /******************************************************************************
365 * LoadTypeLibEx [OLEAUT32.183]
367 * Loads and optionally registers a type library
373 HRESULT WINAPI
LoadTypeLibEx(
374 LPCOLESTR szFile
, /* [in] Name of file to load from */
375 REGKIND regkind
, /* [in] Specify kind of registration */
376 ITypeLib
**pptLib
) /* [out] Pointer to pointer to loaded type library */
378 WCHAR szPath
[MAX_PATH
+1];
381 TRACE("(%s,%d,%p)\n",debugstr_w(szFile
), regkind
, pptLib
);
385 res
= TLB_ReadTypeLib(szFile
, szPath
, MAX_PATH
+ 1, (ITypeLib2
**)pptLib
);
390 case REGKIND_DEFAULT
:
391 /* don't register typelibs supplied with full path. Experimentation confirms the following */
392 if (((szFile
[0] == '\\') && (szFile
[1] == '\\')) ||
393 (szFile
[0] && (szFile
[1] == ':'))) break;
394 /* else fall-through */
396 case REGKIND_REGISTER
:
397 if (!SUCCEEDED(res
= RegisterTypeLib(*pptLib
, (LPOLESTR
)szPath
, NULL
)))
399 IUnknown_Release(*pptLib
);
407 TRACE(" returns %08x\n",res
);
411 /******************************************************************************
412 * LoadRegTypeLib [OLEAUT32.162]
414 * Loads a registered type library.
417 * rguid [I] GUID of the registered type library.
418 * wVerMajor [I] major version.
419 * wVerMinor [I] minor version.
420 * lcid [I] locale ID.
421 * ppTLib [O] pointer that receives an ITypeLib object on success.
425 * Failure: Any HRESULT code returned from QueryPathOfRegTypeLib or
428 HRESULT WINAPI
LoadRegTypeLib(
440 res
= QueryPathOfRegTypeLib( rguid
, wVerMajor
, wVerMinor
, lcid
, &bstr
);
444 res
= LoadTypeLib(bstr
, ppTLib
);
448 TRACE("(IID: %s) load %s (%p)\n",debugstr_guid(rguid
), SUCCEEDED(res
)? "SUCCESS":"FAILED", *ppTLib
);
454 /* some string constants shared between RegisterTypeLib and UnRegisterTypeLib */
455 static const WCHAR TypeLibW
[] = {'T','y','p','e','L','i','b',0};
456 static const WCHAR FLAGSW
[] = {'F','L','A','G','S',0};
457 static const WCHAR HELPDIRW
[] = {'H','E','L','P','D','I','R',0};
458 static const WCHAR ProxyStubClsidW
[] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d',0};
459 static const WCHAR ProxyStubClsid32W
[] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0};
461 /******************************************************************************
462 * RegisterTypeLib [OLEAUT32.163]
463 * Adds information about a type library to the System Registry
465 * Docs: ITypeLib FAR * ptlib
466 * Docs: OLECHAR FAR* szFullPath
467 * Docs: OLECHAR FAR* szHelpDir
473 HRESULT WINAPI
RegisterTypeLib(
474 ITypeLib
* ptlib
, /* [in] Pointer to the library*/
475 OLECHAR
* szFullPath
, /* [in] full Path of the library*/
476 OLECHAR
* szHelpDir
) /* [in] dir to the helpfile for the library,
479 static const WCHAR PSOA
[] = {'{','0','0','0','2','0','4','2','4','-',
480 '0','0','0','0','-','0','0','0','0','-','C','0','0','0','-',
481 '0','0','0','0','0','0','0','0','0','0','4','6','}',0};
491 if (ptlib
== NULL
|| szFullPath
== NULL
)
494 if (!SUCCEEDED(ITypeLib_GetLibAttr(ptlib
, &attr
)))
497 get_typelib_key( &attr
->guid
, attr
->wMajorVerNum
, attr
->wMinorVerNum
, keyName
);
500 if (RegCreateKeyExW(HKEY_CLASSES_ROOT
, keyName
, 0, NULL
, 0,
501 KEY_WRITE
, NULL
, &key
, NULL
) == ERROR_SUCCESS
)
505 /* Set the human-readable name of the typelib */
506 if (SUCCEEDED(ITypeLib_GetDocumentation(ptlib
, -1, NULL
, &doc
, NULL
, NULL
)))
508 if (RegSetValueExW(key
, NULL
, 0, REG_SZ
,
509 (BYTE
*)doc
, (lstrlenW(doc
)+1) * sizeof(OLECHAR
)) != ERROR_SUCCESS
)
517 /* Make up the name of the typelib path subkey */
518 if (!get_lcid_subkey( attr
->lcid
, attr
->syskind
, tmp
)) res
= E_FAIL
;
520 /* Create the typelib path subkey */
521 if (res
== S_OK
&& RegCreateKeyExW(key
, tmp
, 0, NULL
, 0,
522 KEY_WRITE
, NULL
, &subKey
, NULL
) == ERROR_SUCCESS
)
524 if (RegSetValueExW(subKey
, NULL
, 0, REG_SZ
,
525 (BYTE
*)szFullPath
, (lstrlenW(szFullPath
)+1) * sizeof(OLECHAR
)) != ERROR_SUCCESS
)
533 /* Create the flags subkey */
534 if (res
== S_OK
&& RegCreateKeyExW(key
, FLAGSW
, 0, NULL
, 0,
535 KEY_WRITE
, NULL
, &subKey
, NULL
) == ERROR_SUCCESS
)
537 /* FIXME: is %u correct? */
538 static const WCHAR formatW
[] = {'%','u',0};
540 sprintfW(buf
, formatW
, attr
->wLibFlags
);
541 if (RegSetValueExW(subKey
, NULL
, 0, REG_SZ
,
542 (BYTE
*)buf
, (strlenW(buf
) + 1)*sizeof(WCHAR
) ) != ERROR_SUCCESS
)
550 /* create the helpdir subkey */
551 if (res
== S_OK
&& RegCreateKeyExW(key
, HELPDIRW
, 0, NULL
, 0,
552 KEY_WRITE
, NULL
, &subKey
, &disposition
) == ERROR_SUCCESS
)
554 BOOL freeHelpDir
= FALSE
;
557 /* if we created a new key, and helpDir was null, set the helpdir
558 to the directory which contains the typelib. However,
559 if we just opened an existing key, we leave the helpdir alone */
560 if ((disposition
== REG_CREATED_NEW_KEY
) && (szHelpDir
== NULL
)) {
561 szHelpDir
= SysAllocString(szFullPath
);
562 pIndexStr
= strrchrW(szHelpDir
, '\\');
569 /* if we have an szHelpDir, set it! */
570 if (szHelpDir
!= NULL
) {
571 if (RegSetValueExW(subKey
, NULL
, 0, REG_SZ
,
572 (BYTE
*)szHelpDir
, (lstrlenW(szHelpDir
)+1) * sizeof(OLECHAR
)) != ERROR_SUCCESS
) {
578 if (freeHelpDir
) SysFreeString(szHelpDir
);
590 /* register OLE Automation-compatible interfaces for this typelib */
591 types
= ITypeLib_GetTypeInfoCount(ptlib
);
592 for (tidx
=0; tidx
<types
; tidx
++) {
593 if (SUCCEEDED(ITypeLib_GetTypeInfoType(ptlib
, tidx
, &kind
))) {
594 LPOLESTR name
= NULL
;
595 ITypeInfo
*tinfo
= NULL
;
597 ITypeLib_GetDocumentation(ptlib
, tidx
, &name
, NULL
, NULL
, NULL
);
600 case TKIND_INTERFACE
:
601 TRACE_(typelib
)("%d: interface %s\n", tidx
, debugstr_w(name
));
602 ITypeLib_GetTypeInfo(ptlib
, tidx
, &tinfo
);
606 TRACE_(typelib
)("%d: dispinterface %s\n", tidx
, debugstr_w(name
));
607 ITypeLib_GetTypeInfo(ptlib
, tidx
, &tinfo
);
611 TRACE_(typelib
)("%d: %s\n", tidx
, debugstr_w(name
));
616 TYPEATTR
*tattr
= NULL
;
617 ITypeInfo_GetTypeAttr(tinfo
, &tattr
);
620 TRACE_(typelib
)("guid=%s, flags=%04x (",
621 debugstr_guid(&tattr
->guid
),
624 if (TRACE_ON(typelib
)) {
625 #define XX(x) if (TYPEFLAG_##x & tattr->wTypeFlags) MESSAGE(#x"|");
645 if (tattr
->wTypeFlags
& (TYPEFLAG_FOLEAUTOMATION
|TYPEFLAG_FDUAL
|TYPEFLAG_FDISPATCHABLE
))
647 /* register interface<->typelib coupling */
648 get_interface_key( &tattr
->guid
, keyName
);
649 if (RegCreateKeyExW(HKEY_CLASSES_ROOT
, keyName
, 0, NULL
, 0,
650 KEY_WRITE
, NULL
, &key
, NULL
) == ERROR_SUCCESS
)
653 RegSetValueExW(key
, NULL
, 0, REG_SZ
,
654 (BYTE
*)name
, (strlenW(name
)+1) * sizeof(OLECHAR
));
656 if (RegCreateKeyExW(key
, ProxyStubClsidW
, 0, NULL
, 0,
657 KEY_WRITE
, NULL
, &subKey
, NULL
) == ERROR_SUCCESS
) {
658 RegSetValueExW(subKey
, NULL
, 0, REG_SZ
,
659 (const BYTE
*)PSOA
, sizeof PSOA
);
663 if (RegCreateKeyExW(key
, ProxyStubClsid32W
, 0, NULL
, 0,
664 KEY_WRITE
, NULL
, &subKey
, NULL
) == ERROR_SUCCESS
) {
665 RegSetValueExW(subKey
, NULL
, 0, REG_SZ
,
666 (const BYTE
*)PSOA
, sizeof PSOA
);
670 if (RegCreateKeyExW(key
, TypeLibW
, 0, NULL
, 0,
671 KEY_WRITE
, NULL
, &subKey
, NULL
) == ERROR_SUCCESS
)
674 static const WCHAR fmtver
[] = {'%','x','.','%','x',0 };
675 static const WCHAR VersionW
[] = {'V','e','r','s','i','o','n',0};
677 StringFromGUID2(&attr
->guid
, buffer
, 40);
678 RegSetValueExW(subKey
, NULL
, 0, REG_SZ
,
679 (BYTE
*)buffer
, (strlenW(buffer
)+1) * sizeof(WCHAR
));
680 sprintfW(buffer
, fmtver
, attr
->wMajorVerNum
, attr
->wMinorVerNum
);
681 RegSetValueExW(subKey
, VersionW
, 0, REG_SZ
,
682 (BYTE
*)buffer
, (strlenW(buffer
)+1) * sizeof(WCHAR
));
690 ITypeInfo_ReleaseTypeAttr(tinfo
, tattr
);
693 ITypeInfo_Release(tinfo
);
700 ITypeLib_ReleaseTLibAttr(ptlib
, attr
);
706 /******************************************************************************
707 * UnRegisterTypeLib [OLEAUT32.186]
708 * Removes information about a type library from the System Registry
715 HRESULT WINAPI
UnRegisterTypeLib(
716 REFGUID libid
, /* [in] Guid of the library */
717 WORD wVerMajor
, /* [in] major version */
718 WORD wVerMinor
, /* [in] minor version */
719 LCID lcid
, /* [in] locale id */
722 BSTR tlibPath
= NULL
;
725 WCHAR subKeyName
[50];
728 BOOL deleteOtherStuff
;
731 TYPEATTR
* typeAttr
= NULL
;
733 ITypeInfo
* typeInfo
= NULL
;
734 ITypeLib
* typeLib
= NULL
;
737 TRACE("(IID: %s)\n",debugstr_guid(libid
));
739 /* Create the path to the key */
740 get_typelib_key( libid
, wVerMajor
, wVerMinor
, keyName
);
742 if (syskind
!= SYS_WIN16
&& syskind
!= SYS_WIN32
)
744 TRACE("Unsupported syskind %i\n", syskind
);
745 result
= E_INVALIDARG
;
749 /* get the path to the typelib on disk */
750 if (QueryPathOfRegTypeLib(libid
, wVerMajor
, wVerMinor
, lcid
, &tlibPath
) != S_OK
) {
751 result
= E_INVALIDARG
;
755 /* Try and open the key to the type library. */
756 if (RegOpenKeyExW(HKEY_CLASSES_ROOT
, keyName
, 0, KEY_READ
| KEY_WRITE
, &key
) != ERROR_SUCCESS
) {
757 result
= E_INVALIDARG
;
761 /* Try and load the type library */
762 if (LoadTypeLibEx(tlibPath
, REGKIND_NONE
, &typeLib
)) {
763 result
= TYPE_E_INVALIDSTATE
;
767 /* remove any types registered with this typelib */
768 numTypes
= ITypeLib_GetTypeInfoCount(typeLib
);
769 for (i
=0; i
<numTypes
; i
++) {
770 /* get the kind of type */
771 if (ITypeLib_GetTypeInfoType(typeLib
, i
, &kind
) != S_OK
) {
775 /* skip non-interfaces, and get type info for the type */
776 if ((kind
!= TKIND_INTERFACE
) && (kind
!= TKIND_DISPATCH
)) {
779 if (ITypeLib_GetTypeInfo(typeLib
, i
, &typeInfo
) != S_OK
) {
782 if (ITypeInfo_GetTypeAttr(typeInfo
, &typeAttr
) != S_OK
) {
786 /* the path to the type */
787 get_interface_key( &typeAttr
->guid
, subKeyName
);
789 /* Delete its bits */
790 if (RegOpenKeyExW(HKEY_CLASSES_ROOT
, subKeyName
, 0, KEY_WRITE
, &subKey
) != ERROR_SUCCESS
) {
793 RegDeleteKeyW(subKey
, ProxyStubClsidW
);
794 RegDeleteKeyW(subKey
, ProxyStubClsid32W
);
795 RegDeleteKeyW(subKey
, TypeLibW
);
798 RegDeleteKeyW(HKEY_CLASSES_ROOT
, subKeyName
);
801 if (typeAttr
) ITypeInfo_ReleaseTypeAttr(typeInfo
, typeAttr
);
803 if (typeInfo
) ITypeInfo_Release(typeInfo
);
807 /* Now, delete the type library path subkey */
808 get_lcid_subkey( lcid
, syskind
, subKeyName
);
809 RegDeleteKeyW(key
, subKeyName
);
810 *strrchrW( subKeyName
, '\\' ) = 0; /* remove last path component */
811 RegDeleteKeyW(key
, subKeyName
);
813 /* check if there is anything besides the FLAGS/HELPDIR keys.
814 If there is, we don't delete them */
815 tmpLength
= sizeof(subKeyName
)/sizeof(WCHAR
);
816 deleteOtherStuff
= TRUE
;
818 while(RegEnumKeyExW(key
, i
++, subKeyName
, &tmpLength
, NULL
, NULL
, NULL
, NULL
) == ERROR_SUCCESS
) {
819 tmpLength
= sizeof(subKeyName
)/sizeof(WCHAR
);
821 /* if its not FLAGS or HELPDIR, then we must keep the rest of the key */
822 if (!strcmpW(subKeyName
, FLAGSW
)) continue;
823 if (!strcmpW(subKeyName
, HELPDIRW
)) continue;
824 deleteOtherStuff
= FALSE
;
828 /* only delete the other parts of the key if we're absolutely sure */
829 if (deleteOtherStuff
) {
830 RegDeleteKeyW(key
, FLAGSW
);
831 RegDeleteKeyW(key
, HELPDIRW
);
835 RegDeleteKeyW(HKEY_CLASSES_ROOT
, keyName
);
836 *strrchrW( keyName
, '\\' ) = 0; /* remove last path component */
837 RegDeleteKeyW(HKEY_CLASSES_ROOT
, keyName
);
841 if (tlibPath
) SysFreeString(tlibPath
);
842 if (typeLib
) ITypeLib_Release(typeLib
);
843 if (subKey
) RegCloseKey(subKey
);
844 if (key
) RegCloseKey(key
);
848 /*======================= ITypeLib implementation =======================*/
850 typedef struct tagTLBCustData
854 struct tagTLBCustData
* next
;
857 /* data structure for import typelibs */
858 typedef struct tagTLBImpLib
860 int offset
; /* offset in the file (MSFT)
861 offset in nametable (SLTG)
862 just used to identify library while reading
864 GUID guid
; /* libid */
865 BSTR name
; /* name */
867 LCID lcid
; /* lcid of imported typelib */
869 WORD wVersionMajor
; /* major version number */
870 WORD wVersionMinor
; /* minor version number */
872 struct tagITypeLibImpl
*pImpTypeLib
; /* pointer to loaded typelib, or
873 NULL if not yet loaded */
874 struct tagTLBImpLib
* next
;
877 /* internal ITypeLib data */
878 typedef struct tagITypeLibImpl
880 const ITypeLib2Vtbl
*lpVtbl
;
881 const ITypeCompVtbl
*lpVtblTypeComp
;
883 TLIBATTR LibAttr
; /* guid,lcid,syskind,version,flags */
885 /* strings can be stored in tlb as multibyte strings BUT they are *always*
886 * exported to the application as a UNICODE string.
892 unsigned long dwHelpContext
;
893 int TypeInfoCount
; /* nr of typeinfo's in librarry */
894 struct tagITypeInfoImpl
*pTypeInfo
; /* linked list of type info data */
895 int ctCustData
; /* number of items in cust data list */
896 TLBCustData
* pCustData
; /* linked list to cust data */
897 TLBImpLib
* pImpLibs
; /* linked list to all imported typelibs */
898 int ctTypeDesc
; /* number of items in type desc array */
899 TYPEDESC
* pTypeDesc
; /* array of TypeDescriptions found in the
900 library. Only used while reading MSFT
902 struct list ref_list
; /* list of ref types in this typelib */
903 HREFTYPE dispatch_href
; /* reference to IDispatch, -1 if unused */
906 /* typelibs are cached, keyed by path and index, so store the linked list info within them */
907 struct tagITypeLibImpl
*next
, *prev
;
912 static const ITypeLib2Vtbl tlbvt
;
913 static const ITypeCompVtbl tlbtcvt
;
915 static inline ITypeLibImpl
*impl_from_ITypeComp( ITypeComp
*iface
)
917 return (ITypeLibImpl
*)((char*)iface
- FIELD_OFFSET(ITypeLibImpl
, lpVtblTypeComp
));
920 /* ITypeLib methods */
921 static ITypeLib2
* ITypeLib2_Constructor_MSFT(LPVOID pLib
, DWORD dwTLBLength
);
922 static ITypeLib2
* ITypeLib2_Constructor_SLTG(LPVOID pLib
, DWORD dwTLBLength
);
924 /*======================= ITypeInfo implementation =======================*/
926 /* data for referenced types */
927 typedef struct tagTLBRefType
929 INT index
; /* Type index for internal ref or for external ref
930 it the format is SLTG. -2 indicates to
933 GUID guid
; /* guid of the referenced type */
934 /* if index == TLB_REF_USE_GUID */
936 HREFTYPE reference
; /* The href of this ref */
937 TLBImpLib
*pImpTLInfo
; /* If ref is external ptr to library data
938 TLB_REF_INTERNAL for internal refs
939 TLB_REF_NOT_FOUND for broken refs */
944 #define TLB_REF_USE_GUID -2
946 #define TLB_REF_INTERNAL (void*)-2
947 #define TLB_REF_NOT_FOUND (void*)-1
949 /* internal Parameter data */
950 typedef struct tagTLBParDesc
954 TLBCustData
* pCustData
; /* linked list to cust data */
957 /* internal Function data */
958 typedef struct tagTLBFuncDesc
960 FUNCDESC funcdesc
; /* lots of info on the function and its attributes. */
961 BSTR Name
; /* the name of this function */
962 TLBParDesc
*pParamDesc
; /* array with param names and custom data */
964 int HelpStringContext
;
966 BSTR Entry
; /* if its Hiword==0, it numeric; -1 is not present*/
968 TLBCustData
* pCustData
; /* linked list to cust data; */
969 struct tagTLBFuncDesc
* next
;
972 /* internal Variable data */
973 typedef struct tagTLBVarDesc
975 VARDESC vardesc
; /* lots of info on the variable and its attributes. */
976 BSTR Name
; /* the name of this variable */
978 int HelpStringContext
; /* FIXME: where? */
981 TLBCustData
* pCustData
;/* linked list to cust data; */
982 struct tagTLBVarDesc
* next
;
985 /* internal implemented interface data */
986 typedef struct tagTLBImplType
988 HREFTYPE hRef
; /* hRef of interface */
989 int implflags
; /* IMPLFLAG_*s */
991 TLBCustData
* pCustData
;/* linked list to custom data; */
992 struct tagTLBImplType
*next
;
995 /* internal TypeInfo data */
996 typedef struct tagITypeInfoImpl
998 const ITypeInfo2Vtbl
*lpVtbl
;
999 const ITypeCompVtbl
*lpVtblTypeComp
;
1001 BOOL no_free_data
; /* don't free data structurees */
1002 TYPEATTR TypeAttr
; /* _lots_ of type information. */
1003 ITypeLibImpl
* pTypeLib
; /* back pointer to typelib */
1004 int index
; /* index in this typelib; */
1005 HREFTYPE hreftype
; /* hreftype for app object binding */
1006 /* type libs seem to store the doc strings in ascii
1007 * so why should we do it in unicode?
1012 unsigned long dwHelpContext
;
1013 unsigned long dwHelpStringContext
;
1016 TLBFuncDesc
* funclist
; /* linked list with function descriptions */
1019 TLBVarDesc
* varlist
; /* linked list with variable descriptions */
1021 /* Implemented Interfaces */
1022 TLBImplType
* impltypelist
;
1025 TLBCustData
* pCustData
; /* linked list to cust data; */
1026 struct tagITypeInfoImpl
* next
;
1029 static inline ITypeInfoImpl
*info_impl_from_ITypeComp( ITypeComp
*iface
)
1031 return (ITypeInfoImpl
*)((char*)iface
- FIELD_OFFSET(ITypeInfoImpl
, lpVtblTypeComp
));
1034 static const ITypeInfo2Vtbl tinfvt
;
1035 static const ITypeCompVtbl tcompvt
;
1037 static ITypeInfo2
* WINAPI
ITypeInfo_Constructor(void);
1039 typedef struct tagTLBContext
1041 unsigned int oStart
; /* start of TLB in file */
1042 unsigned int pos
; /* current pos */
1043 unsigned int length
; /* total length */
1044 void *mapping
; /* memory mapping */
1045 MSFT_SegDir
* pTblDir
;
1046 ITypeLibImpl
* pLibInfo
;
1050 static void MSFT_DoRefType(TLBContext
*pcx
, ITypeLibImpl
*pTL
, int offset
);
1055 static void dump_TypeDesc(const TYPEDESC
*pTD
,char *szVarType
) {
1056 if (pTD
->vt
& VT_RESERVED
)
1057 szVarType
+= strlen(strcpy(szVarType
, "reserved | "));
1058 if (pTD
->vt
& VT_BYREF
)
1059 szVarType
+= strlen(strcpy(szVarType
, "ref to "));
1060 if (pTD
->vt
& VT_ARRAY
)
1061 szVarType
+= strlen(strcpy(szVarType
, "array of "));
1062 if (pTD
->vt
& VT_VECTOR
)
1063 szVarType
+= strlen(strcpy(szVarType
, "vector of "));
1064 switch(pTD
->vt
& VT_TYPEMASK
) {
1065 case VT_UI1
: sprintf(szVarType
, "VT_UI1"); break;
1066 case VT_I2
: sprintf(szVarType
, "VT_I2"); break;
1067 case VT_I4
: sprintf(szVarType
, "VT_I4"); break;
1068 case VT_R4
: sprintf(szVarType
, "VT_R4"); break;
1069 case VT_R8
: sprintf(szVarType
, "VT_R8"); break;
1070 case VT_BOOL
: sprintf(szVarType
, "VT_BOOL"); break;
1071 case VT_ERROR
: sprintf(szVarType
, "VT_ERROR"); break;
1072 case VT_CY
: sprintf(szVarType
, "VT_CY"); break;
1073 case VT_DATE
: sprintf(szVarType
, "VT_DATE"); break;
1074 case VT_BSTR
: sprintf(szVarType
, "VT_BSTR"); break;
1075 case VT_UNKNOWN
: sprintf(szVarType
, "VT_UNKNOWN"); break;
1076 case VT_DISPATCH
: sprintf(szVarType
, "VT_DISPATCH"); break;
1077 case VT_I1
: sprintf(szVarType
, "VT_I1"); break;
1078 case VT_UI2
: sprintf(szVarType
, "VT_UI2"); break;
1079 case VT_UI4
: sprintf(szVarType
, "VT_UI4"); break;
1080 case VT_INT
: sprintf(szVarType
, "VT_INT"); break;
1081 case VT_UINT
: sprintf(szVarType
, "VT_UINT"); break;
1082 case VT_VARIANT
: sprintf(szVarType
, "VT_VARIANT"); break;
1083 case VT_VOID
: sprintf(szVarType
, "VT_VOID"); break;
1084 case VT_HRESULT
: sprintf(szVarType
, "VT_HRESULT"); break;
1085 case VT_USERDEFINED
: sprintf(szVarType
, "VT_USERDEFINED ref = %x",
1086 pTD
->u
.hreftype
); break;
1087 case VT_PTR
: sprintf(szVarType
, "ptr to ");
1088 dump_TypeDesc(pTD
->u
.lptdesc
, szVarType
+ 7);
1090 case VT_SAFEARRAY
: sprintf(szVarType
, "safearray of ");
1091 dump_TypeDesc(pTD
->u
.lptdesc
, szVarType
+ 13);
1093 case VT_CARRAY
: sprintf(szVarType
, "%d dim array of ",
1094 pTD
->u
.lpadesc
->cDims
); /* FIXME print out sizes */
1095 dump_TypeDesc(&pTD
->u
.lpadesc
->tdescElem
, szVarType
+ strlen(szVarType
));
1098 default: sprintf(szVarType
, "unknown(%d)", pTD
->vt
& VT_TYPEMASK
); break;
1102 static void dump_ELEMDESC(const ELEMDESC
*edesc
) {
1104 USHORT flags
= edesc
->u
.paramdesc
.wParamFlags
;
1105 dump_TypeDesc(&edesc
->tdesc
,buf
);
1106 MESSAGE("\t\ttdesc.vartype %d (%s)\n",edesc
->tdesc
.vt
,buf
);
1107 MESSAGE("\t\tu.paramdesc.wParamFlags");
1108 if (!flags
) MESSAGE(" PARAMFLAGS_NONE");
1109 if (flags
& PARAMFLAG_FIN
) MESSAGE(" PARAMFLAG_FIN");
1110 if (flags
& PARAMFLAG_FOUT
) MESSAGE(" PARAMFLAG_FOUT");
1111 if (flags
& PARAMFLAG_FLCID
) MESSAGE(" PARAMFLAG_FLCID");
1112 if (flags
& PARAMFLAG_FRETVAL
) MESSAGE(" PARAMFLAG_FRETVAL");
1113 if (flags
& PARAMFLAG_FOPT
) MESSAGE(" PARAMFLAG_FOPT");
1114 if (flags
& PARAMFLAG_FHASDEFAULT
) MESSAGE(" PARAMFLAG_FHASDEFAULT");
1115 if (flags
& PARAMFLAG_FHASCUSTDATA
) MESSAGE(" PARAMFLAG_FHASCUSTDATA");
1116 MESSAGE("\n\t\tu.paramdesc.lpex %p\n",edesc
->u
.paramdesc
.pparamdescex
);
1118 static void dump_FUNCDESC(const FUNCDESC
*funcdesc
) {
1120 MESSAGE("memid is %08x\n",funcdesc
->memid
);
1121 for (i
=0;i
<funcdesc
->cParams
;i
++) {
1122 MESSAGE("Param %d:\n",i
);
1123 dump_ELEMDESC(funcdesc
->lprgelemdescParam
+i
);
1125 MESSAGE("\tfunckind: %d (",funcdesc
->funckind
);
1126 switch (funcdesc
->funckind
) {
1127 case FUNC_VIRTUAL
: MESSAGE("virtual");break;
1128 case FUNC_PUREVIRTUAL
: MESSAGE("pure virtual");break;
1129 case FUNC_NONVIRTUAL
: MESSAGE("nonvirtual");break;
1130 case FUNC_STATIC
: MESSAGE("static");break;
1131 case FUNC_DISPATCH
: MESSAGE("dispatch");break;
1132 default: MESSAGE("unknown");break;
1134 MESSAGE(")\n\tinvkind: %d (",funcdesc
->invkind
);
1135 switch (funcdesc
->invkind
) {
1136 case INVOKE_FUNC
: MESSAGE("func");break;
1137 case INVOKE_PROPERTYGET
: MESSAGE("property get");break;
1138 case INVOKE_PROPERTYPUT
: MESSAGE("property put");break;
1139 case INVOKE_PROPERTYPUTREF
: MESSAGE("property put ref");break;
1141 MESSAGE(")\n\tcallconv: %d (",funcdesc
->callconv
);
1142 switch (funcdesc
->callconv
) {
1143 case CC_CDECL
: MESSAGE("cdecl");break;
1144 case CC_PASCAL
: MESSAGE("pascal");break;
1145 case CC_STDCALL
: MESSAGE("stdcall");break;
1146 case CC_SYSCALL
: MESSAGE("syscall");break;
1149 MESSAGE(")\n\toVft: %d\n", funcdesc
->oVft
);
1150 MESSAGE("\tcParamsOpt: %d\n", funcdesc
->cParamsOpt
);
1151 MESSAGE("\twFlags: %x\n", funcdesc
->wFuncFlags
);
1153 MESSAGE("\telemdescFunc (return value type):\n");
1154 dump_ELEMDESC(&funcdesc
->elemdescFunc
);
1157 static const char * const typekind_desc
[] =
1170 static void dump_TLBFuncDescOne(const TLBFuncDesc
* pfd
)
1173 MESSAGE("%s(%u)\n", debugstr_w(pfd
->Name
), pfd
->funcdesc
.cParams
);
1174 for (i
=0;i
<pfd
->funcdesc
.cParams
;i
++)
1175 MESSAGE("\tparm%d: %s\n",i
,debugstr_w(pfd
->pParamDesc
[i
].Name
));
1178 dump_FUNCDESC(&(pfd
->funcdesc
));
1180 MESSAGE("\thelpstring: %s\n", debugstr_w(pfd
->HelpString
));
1181 MESSAGE("\tentry: %s\n", (pfd
->Entry
== (void *)-1) ? "invalid" : debugstr_w(pfd
->Entry
));
1183 static void dump_TLBFuncDesc(const TLBFuncDesc
* pfd
)
1187 dump_TLBFuncDescOne(pfd
);
1191 static void dump_TLBVarDesc(const TLBVarDesc
* pvd
)
1195 TRACE_(typelib
)("%s\n", debugstr_w(pvd
->Name
));
1200 static void dump_TLBImpLib(const TLBImpLib
*import
)
1202 TRACE_(typelib
)("%s %s\n", debugstr_guid(&(import
->guid
)),
1203 debugstr_w(import
->name
));
1204 TRACE_(typelib
)("v%d.%d lcid=%x offset=%x\n", import
->wVersionMajor
,
1205 import
->wVersionMinor
, import
->lcid
, import
->offset
);
1208 static void dump_TLBRefType(const ITypeLibImpl
*pTL
)
1212 LIST_FOR_EACH_ENTRY(ref
, &pTL
->ref_list
, TLBRefType
, entry
)
1214 TRACE_(typelib
)("href:0x%08x\n", ref
->reference
);
1215 if(ref
->index
== -1)
1216 TRACE_(typelib
)("%s\n", debugstr_guid(&(ref
->guid
)));
1218 TRACE_(typelib
)("type no: %d\n", ref
->index
);
1220 if(ref
->pImpTLInfo
!= TLB_REF_INTERNAL
&& ref
->pImpTLInfo
!= TLB_REF_NOT_FOUND
)
1222 TRACE_(typelib
)("in lib\n");
1223 dump_TLBImpLib(ref
->pImpTLInfo
);
1228 static void dump_TLBImplType(const TLBImplType
* impl
)
1232 "implementing/inheriting interface hRef = %x implflags %x\n",
1233 impl
->hRef
, impl
->implflags
);
1238 static void dump_Variant(const VARIANT
* pvar
)
1242 TRACE("%p->{%s%s", pvar
, debugstr_VT(pvar
), debugstr_VF(pvar
));
1246 if (V_ISBYREF(pvar
) || V_TYPE(pvar
) == VT_UNKNOWN
||
1247 V_TYPE(pvar
) == VT_DISPATCH
|| V_TYPE(pvar
) == VT_RECORD
)
1249 TRACE(",%p", V_BYREF(pvar
));
1251 else if (V_ISARRAY(pvar
) || V_ISVECTOR(pvar
))
1253 TRACE(",%p", V_ARRAY(pvar
));
1255 else switch (V_TYPE(pvar
))
1257 case VT_I1
: TRACE(",%d", V_I1(pvar
)); break;
1258 case VT_UI1
: TRACE(",%d", V_UI1(pvar
)); break;
1259 case VT_I2
: TRACE(",%d", V_I2(pvar
)); break;
1260 case VT_UI2
: TRACE(",%d", V_UI2(pvar
)); break;
1262 case VT_I4
: TRACE(",%d", V_I4(pvar
)); break;
1264 case VT_UI4
: TRACE(",%d", V_UI4(pvar
)); break;
1265 case VT_I8
: TRACE(",0x%08x,0x%08x", (ULONG
)(V_I8(pvar
) >> 32),
1266 (ULONG
)(V_I8(pvar
) & 0xffffffff)); break;
1267 case VT_UI8
: TRACE(",0x%08x,0x%08x", (ULONG
)(V_UI8(pvar
) >> 32),
1268 (ULONG
)(V_UI8(pvar
) & 0xffffffff)); break;
1269 case VT_R4
: TRACE(",%3.3e", V_R4(pvar
)); break;
1270 case VT_R8
: TRACE(",%3.3e", V_R8(pvar
)); break;
1271 case VT_BOOL
: TRACE(",%s", V_BOOL(pvar
) ? "TRUE" : "FALSE"); break;
1272 case VT_BSTR
: TRACE(",%s", debugstr_w(V_BSTR(pvar
))); break;
1273 case VT_CY
: TRACE(",0x%08x,0x%08x", V_CY(pvar
).s
.Hi
,
1274 V_CY(pvar
).s
.Lo
); break;
1276 if(!VariantTimeToSystemTime(V_DATE(pvar
), &st
))
1277 TRACE(",<invalid>");
1279 TRACE(",%04d/%02d/%02d %02d:%02d:%02d", st
.wYear
, st
.wMonth
, st
.wDay
,
1280 st
.wHour
, st
.wMinute
, st
.wSecond
);
1284 case VT_USERDEFINED
:
1286 case VT_NULL
: break;
1287 default: TRACE(",?"); break;
1293 static void dump_DispParms(const DISPPARAMS
* pdp
)
1297 TRACE("args=%u named args=%u\n", pdp
->cArgs
, pdp
->cNamedArgs
);
1299 if (pdp
->cNamedArgs
&& pdp
->rgdispidNamedArgs
)
1301 TRACE("named args:\n");
1302 for (index
= 0; index
< pdp
->cNamedArgs
; index
++)
1303 TRACE( "\t0x%x\n", pdp
->rgdispidNamedArgs
[index
] );
1306 if (pdp
->cArgs
&& pdp
->rgvarg
)
1309 for (index
= 0; index
< pdp
->cArgs
; index
++)
1310 dump_Variant( &pdp
->rgvarg
[index
] );
1314 static void dump_TypeInfo(const ITypeInfoImpl
* pty
)
1316 TRACE("%p ref=%u\n", pty
, pty
->ref
);
1317 TRACE("%s %s\n", debugstr_w(pty
->Name
), debugstr_w(pty
->DocString
));
1318 TRACE("attr:%s\n", debugstr_guid(&(pty
->TypeAttr
.guid
)));
1319 TRACE("kind:%s\n", typekind_desc
[pty
->TypeAttr
.typekind
]);
1320 TRACE("fct:%u var:%u impl:%u\n",
1321 pty
->TypeAttr
.cFuncs
, pty
->TypeAttr
.cVars
, pty
->TypeAttr
.cImplTypes
);
1322 TRACE("wTypeFlags: 0x%04x\n", pty
->TypeAttr
.wTypeFlags
);
1323 TRACE("parent tlb:%p index in TLB:%u\n",pty
->pTypeLib
, pty
->index
);
1324 if (pty
->TypeAttr
.typekind
== TKIND_MODULE
) TRACE("dllname:%s\n", debugstr_w(pty
->DllName
));
1326 dump_TLBFuncDesc(pty
->funclist
);
1327 dump_TLBVarDesc(pty
->varlist
);
1328 dump_TLBImplType(pty
->impltypelist
);
1331 static void dump_VARDESC(const VARDESC
*v
)
1333 MESSAGE("memid %d\n",v
->memid
);
1334 MESSAGE("lpstrSchema %s\n",debugstr_w(v
->lpstrSchema
));
1335 MESSAGE("oInst %d\n",v
->u
.oInst
);
1336 dump_ELEMDESC(&(v
->elemdescVar
));
1337 MESSAGE("wVarFlags %x\n",v
->wVarFlags
);
1338 MESSAGE("varkind %d\n",v
->varkind
);
1341 static TYPEDESC stndTypeDesc
[VT_LPWSTR
+1]=
1343 /* VT_LPWSTR is largest type that */
1344 /* may appear in type description*/
1345 {{0}, 0},{{0}, 1},{{0}, 2},{{0}, 3},{{0}, 4},
1346 {{0}, 5},{{0}, 6},{{0}, 7},{{0}, 8},{{0}, 9},
1347 {{0},10},{{0},11},{{0},12},{{0},13},{{0},14},
1348 {{0},15},{{0},16},{{0},17},{{0},18},{{0},19},
1349 {{0},20},{{0},21},{{0},22},{{0},23},{{0},24},
1350 {{0},25},{{0},26},{{0},27},{{0},28},{{0},29},
1354 static void TLB_abort(void)
1358 static void * TLB_Alloc(unsigned size
)
1361 if((ret
=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,size
))==NULL
){
1363 ERR("cannot allocate memory\n");
1368 static void TLB_Free(void * ptr
)
1370 HeapFree(GetProcessHeap(), 0, ptr
);
1373 /* returns the size required for a deep copy of a typedesc into a
1375 static SIZE_T
TLB_SizeTypeDesc( const TYPEDESC
*tdesc
, BOOL alloc_initial_space
)
1379 if (alloc_initial_space
)
1380 size
+= sizeof(TYPEDESC
);
1386 size
+= TLB_SizeTypeDesc(tdesc
->u
.lptdesc
, TRUE
);
1389 size
+= FIELD_OFFSET(ARRAYDESC
, rgbounds
[tdesc
->u
.lpadesc
->cDims
]);
1390 size
+= TLB_SizeTypeDesc(&tdesc
->u
.lpadesc
->tdescElem
, FALSE
);
1396 /* deep copy a typedesc into a flat buffer */
1397 static void *TLB_CopyTypeDesc( TYPEDESC
*dest
, const TYPEDESC
*src
, void *buffer
)
1402 buffer
= (char *)buffer
+ sizeof(TYPEDESC
);
1411 dest
->u
.lptdesc
= buffer
;
1412 buffer
= TLB_CopyTypeDesc(NULL
, src
->u
.lptdesc
, buffer
);
1415 dest
->u
.lpadesc
= buffer
;
1416 memcpy(dest
->u
.lpadesc
, src
->u
.lpadesc
, FIELD_OFFSET(ARRAYDESC
, rgbounds
[src
->u
.lpadesc
->cDims
]));
1417 buffer
= (char *)buffer
+ FIELD_OFFSET(ARRAYDESC
, rgbounds
[src
->u
.lpadesc
->cDims
]);
1418 buffer
= TLB_CopyTypeDesc(&dest
->u
.lpadesc
->tdescElem
, &src
->u
.lpadesc
->tdescElem
, buffer
);
1424 /**********************************************************************
1426 * Functions for reading MSFT typelibs (those created by CreateTypeLib2)
1428 static inline unsigned int MSFT_Tell(TLBContext
*pcx
)
1433 static inline void MSFT_Seek(TLBContext
*pcx
, long where
)
1435 if (where
!= DO_NOT_SEEK
)
1437 where
+= pcx
->oStart
;
1438 if (where
> pcx
->length
)
1441 ERR("seek beyond end (%ld/%d)\n", where
, pcx
->length
);
1449 static DWORD
MSFT_Read(void *buffer
, DWORD count
, TLBContext
*pcx
, long where
)
1451 TRACE_(typelib
)("pos=0x%08x len=0x%08x 0x%08x 0x%08x 0x%08lx\n",
1452 pcx
->pos
, count
, pcx
->oStart
, pcx
->length
, where
);
1454 MSFT_Seek(pcx
, where
);
1455 if (pcx
->pos
+ count
> pcx
->length
) count
= pcx
->length
- pcx
->pos
;
1456 memcpy( buffer
, (char *)pcx
->mapping
+ pcx
->pos
, count
);
1461 static DWORD
MSFT_ReadLEDWords(void *buffer
, DWORD count
, TLBContext
*pcx
,
1466 ret
= MSFT_Read(buffer
, count
, pcx
, where
);
1467 FromLEDWords(buffer
, ret
);
1472 static DWORD
MSFT_ReadLEWords(void *buffer
, DWORD count
, TLBContext
*pcx
,
1477 ret
= MSFT_Read(buffer
, count
, pcx
, where
);
1478 FromLEWords(buffer
, ret
);
1483 static void MSFT_ReadGuid( GUID
*pGuid
, int offset
, TLBContext
*pcx
)
1485 if(offset
<0 || pcx
->pTblDir
->pGuidTab
.offset
<0){
1486 memset(pGuid
,0, sizeof(GUID
));
1489 MSFT_Read(pGuid
, sizeof(GUID
), pcx
, pcx
->pTblDir
->pGuidTab
.offset
+offset
);
1490 pGuid
->Data1
= FromLEDWord(pGuid
->Data1
);
1491 pGuid
->Data2
= FromLEWord(pGuid
->Data2
);
1492 pGuid
->Data3
= FromLEWord(pGuid
->Data3
);
1493 TRACE_(typelib
)("%s\n", debugstr_guid(pGuid
));
1496 static HREFTYPE
MSFT_ReadHreftype( TLBContext
*pcx
, int offset
)
1498 MSFT_NameIntro niName
;
1502 ERR_(typelib
)("bad offset %d\n", offset
);
1506 MSFT_ReadLEDWords(&niName
, sizeof(niName
), pcx
,
1507 pcx
->pTblDir
->pNametab
.offset
+offset
);
1509 return niName
.hreftype
;
1512 static BSTR
MSFT_ReadName( TLBContext
*pcx
, int offset
)
1515 MSFT_NameIntro niName
;
1517 BSTR bstrName
= NULL
;
1521 ERR_(typelib
)("bad offset %d\n", offset
);
1524 MSFT_ReadLEDWords(&niName
, sizeof(niName
), pcx
,
1525 pcx
->pTblDir
->pNametab
.offset
+offset
);
1526 niName
.namelen
&= 0xFF; /* FIXME: correct ? */
1527 name
=TLB_Alloc((niName
.namelen
& 0xff) +1);
1528 MSFT_Read(name
, (niName
.namelen
& 0xff), pcx
, DO_NOT_SEEK
);
1529 name
[niName
.namelen
& 0xff]='\0';
1531 lengthInChars
= MultiByteToWideChar(CP_ACP
, MB_PRECOMPOSED
| MB_ERR_INVALID_CHARS
,
1534 /* no invalid characters in string */
1537 bstrName
= SysAllocStringByteLen(NULL
, lengthInChars
* sizeof(WCHAR
));
1539 /* don't check for invalid character since this has been done previously */
1540 MultiByteToWideChar(CP_ACP
, MB_PRECOMPOSED
, name
, -1, bstrName
, lengthInChars
);
1544 TRACE_(typelib
)("%s %d\n", debugstr_w(bstrName
), lengthInChars
);
1548 static BSTR
MSFT_ReadString( TLBContext
*pcx
, int offset
)
1555 if(offset
<0) return NULL
;
1556 MSFT_ReadLEWords(&length
, sizeof(INT16
), pcx
, pcx
->pTblDir
->pStringtab
.offset
+offset
);
1557 if(length
<= 0) return 0;
1558 string
=TLB_Alloc(length
+1);
1559 MSFT_Read(string
, length
, pcx
, DO_NOT_SEEK
);
1560 string
[length
]='\0';
1562 lengthInChars
= MultiByteToWideChar(CP_ACP
, MB_PRECOMPOSED
| MB_ERR_INVALID_CHARS
,
1563 string
, -1, NULL
, 0);
1565 /* no invalid characters in string */
1568 bstr
= SysAllocStringByteLen(NULL
, lengthInChars
* sizeof(WCHAR
));
1570 /* don't check for invalid character since this has been done previously */
1571 MultiByteToWideChar(CP_ACP
, MB_PRECOMPOSED
, string
, -1, bstr
, lengthInChars
);
1575 TRACE_(typelib
)("%s %d\n", debugstr_w(bstr
), lengthInChars
);
1579 * read a value and fill a VARIANT structure
1581 static void MSFT_ReadValue( VARIANT
* pVar
, int offset
, TLBContext
*pcx
)
1585 TRACE_(typelib
)("\n");
1587 if(offset
<0) { /* data are packed in here */
1588 V_VT(pVar
) = (offset
& 0x7c000000 )>> 26;
1589 V_I4(pVar
) = offset
& 0x3ffffff;
1592 MSFT_ReadLEWords(&(V_VT(pVar
)), sizeof(VARTYPE
), pcx
,
1593 pcx
->pTblDir
->pCustData
.offset
+ offset
);
1594 TRACE_(typelib
)("Vartype = %x\n", V_VT(pVar
));
1595 switch (V_VT(pVar
)){
1596 case VT_EMPTY
: /* FIXME: is this right? */
1597 case VT_NULL
: /* FIXME: is this right? */
1598 case VT_I2
: /* this should not happen */
1609 case VT_VOID
: /* FIXME: is this right? */
1617 case VT_DECIMAL
: /* FIXME: is this right? */
1620 /* pointer types with known behaviour */
1623 MSFT_ReadLEDWords(&size
, sizeof(INT
), pcx
, DO_NOT_SEEK
);
1626 DWORD origPos
= MSFT_Tell(pcx
), nullPos
;
1629 MSFT_Read(&next
, 1, pcx
, DO_NOT_SEEK
);
1631 nullPos
= MSFT_Tell(pcx
);
1632 size
= nullPos
- origPos
;
1633 MSFT_Seek(pcx
, origPos
);
1635 ptr
=TLB_Alloc(size
);/* allocate temp buffer */
1636 MSFT_Read(ptr
, size
, pcx
, DO_NOT_SEEK
);/* read string (ANSI) */
1637 V_BSTR(pVar
)=SysAllocStringLen(NULL
,size
);
1638 /* FIXME: do we need a AtoW conversion here? */
1639 V_UNION(pVar
, bstrVal
[size
])='\0';
1640 while(size
--) V_UNION(pVar
, bstrVal
[size
])=ptr
[size
];
1644 /* FIXME: this will not work AT ALL when the variant contains a pointer */
1651 case VT_USERDEFINED
:
1657 case VT_STREAMED_OBJECT
:
1658 case VT_STORED_OBJECT
:
1659 case VT_BLOB_OBJECT
:
1664 FIXME("VARTYPE %d is not supported, setting pointer to NULL\n",
1668 if(size
>0) /* (big|small) endian correct? */
1669 MSFT_Read(&(V_I2(pVar
)), size
, pcx
, DO_NOT_SEEK
);
1673 * create a linked list with custom data
1675 static int MSFT_CustData( TLBContext
*pcx
, int offset
, TLBCustData
** ppCustData
)
1681 TRACE_(typelib
)("\n");
1685 pNew
=TLB_Alloc(sizeof(TLBCustData
));
1686 MSFT_ReadLEDWords(&entry
, sizeof(entry
), pcx
, pcx
->pTblDir
->pCDGuids
.offset
+offset
);
1687 MSFT_ReadGuid(&(pNew
->guid
), entry
.GuidOffset
, pcx
);
1688 MSFT_ReadValue(&(pNew
->data
), entry
.DataOffset
, pcx
);
1689 /* add new custom data at head of the list */
1690 pNew
->next
=*ppCustData
;
1692 offset
= entry
.next
;
1697 static void MSFT_GetTdesc(TLBContext
*pcx
, INT type
, TYPEDESC
*pTd
,
1701 pTd
->vt
=type
& VT_TYPEMASK
;
1703 *pTd
=pcx
->pLibInfo
->pTypeDesc
[type
/(2*sizeof(INT
))];
1705 if(pTd
->vt
== VT_USERDEFINED
)
1706 MSFT_DoRefType(pcx
, pTI
->pTypeLib
, pTd
->u
.hreftype
);
1708 TRACE_(typelib
)("vt type = %X\n", pTd
->vt
);
1711 static void MSFT_ResolveReferencedTypes(TLBContext
*pcx
, ITypeInfoImpl
*pTI
, TYPEDESC
*lpTypeDesc
)
1713 /* resolve referenced type if any */
1716 switch (lpTypeDesc
->vt
)
1719 lpTypeDesc
= lpTypeDesc
->u
.lptdesc
;
1723 lpTypeDesc
= & (lpTypeDesc
->u
.lpadesc
->tdescElem
);
1726 case VT_USERDEFINED
:
1727 MSFT_DoRefType(pcx
, pTI
->pTypeLib
,
1728 lpTypeDesc
->u
.hreftype
);
1740 MSFT_DoFuncs(TLBContext
* pcx
,
1745 TLBFuncDesc
** pptfd
)
1748 * member information is stored in a data structure at offset
1749 * indicated by the memoffset field of the typeinfo structure
1750 * There are several distinctive parts.
1751 * The first part starts with a field that holds the total length
1752 * of this (first) part excluding this field. Then follow the records,
1753 * for each member there is one record.
1755 * The first entry is always the length of the record (including this
1757 * The rest of the record depends on the type of the member. If there is
1758 * a field indicating the member type (function, variable, interface, etc)
1759 * I have not found it yet. At this time we depend on the information
1760 * in the type info and the usual order how things are stored.
1762 * Second follows an array sized nrMEM*sizeof(INT) with a member id
1765 * Third is an equal sized array with file offsets to the name entry
1768 * The fourth and last (?) part is an array with offsets to the records
1769 * in the first part of this file segment.
1772 int infolen
, nameoffset
, reclength
, nrattributes
, i
;
1773 int recoffset
= offset
+ sizeof(INT
);
1775 char *recbuf
= HeapAlloc(GetProcessHeap(), 0, 0xffff);
1776 MSFT_FuncRecord
* pFuncRec
=(MSFT_FuncRecord
*) recbuf
;
1777 TLBFuncDesc
*ptfd_prev
= NULL
;
1779 TRACE_(typelib
)("\n");
1781 MSFT_ReadLEDWords(&infolen
, sizeof(INT
), pcx
, offset
);
1783 for ( i
= 0; i
< cFuncs
; i
++ )
1785 *pptfd
= TLB_Alloc(sizeof(TLBFuncDesc
));
1787 /* name, eventually add to a hash table */
1788 MSFT_ReadLEDWords(&nameoffset
, sizeof(INT
), pcx
,
1789 offset
+ infolen
+ (cFuncs
+ cVars
+ i
+ 1) * sizeof(INT
));
1791 /* nameoffset is sometimes -1 on the second half of a propget/propput
1792 * pair of functions */
1793 if ((nameoffset
== -1) && (i
> 0))
1794 (*pptfd
)->Name
= SysAllocString(ptfd_prev
->Name
);
1796 (*pptfd
)->Name
= MSFT_ReadName(pcx
, nameoffset
);
1798 /* read the function information record */
1799 MSFT_ReadLEDWords(&reclength
, sizeof(INT
), pcx
, recoffset
);
1801 reclength
&= 0xffff;
1803 MSFT_ReadLEDWords(pFuncRec
, reclength
- sizeof(INT
), pcx
, DO_NOT_SEEK
);
1805 /* do the attributes */
1806 nrattributes
= (reclength
- pFuncRec
->nrargs
* 3 * sizeof(int) - 0x18)
1809 if ( nrattributes
> 0 )
1811 (*pptfd
)->helpcontext
= pFuncRec
->OptAttr
[0] ;
1813 if ( nrattributes
> 1 )
1815 (*pptfd
)->HelpString
= MSFT_ReadString(pcx
,
1816 pFuncRec
->OptAttr
[1]) ;
1818 if ( nrattributes
> 2 )
1820 if ( pFuncRec
->FKCCIC
& 0x2000 )
1822 if (HIWORD(pFuncRec
->OptAttr
[2]) != 0)
1823 ERR("ordinal 0x%08x invalid, HIWORD != 0\n", pFuncRec
->OptAttr
[2]);
1824 (*pptfd
)->Entry
= (BSTR
)pFuncRec
->OptAttr
[2];
1828 (*pptfd
)->Entry
= MSFT_ReadString(pcx
,
1829 pFuncRec
->OptAttr
[2]);
1831 if( nrattributes
> 5 )
1833 (*pptfd
)->HelpStringContext
= pFuncRec
->OptAttr
[5] ;
1835 if ( nrattributes
> 6 && pFuncRec
->FKCCIC
& 0x80 )
1838 pFuncRec
->OptAttr
[6],
1839 &(*pptfd
)->pCustData
);
1845 (*pptfd
)->Entry
= (BSTR
)-1;
1850 /* fill the FuncDesc Structure */
1851 MSFT_ReadLEDWords( & (*pptfd
)->funcdesc
.memid
, sizeof(INT
), pcx
,
1852 offset
+ infolen
+ ( i
+ 1) * sizeof(INT
));
1854 (*pptfd
)->funcdesc
.funckind
= (pFuncRec
->FKCCIC
) & 0x7;
1855 (*pptfd
)->funcdesc
.invkind
= (pFuncRec
->FKCCIC
) >> 3 & 0xF;
1856 (*pptfd
)->funcdesc
.callconv
= (pFuncRec
->FKCCIC
) >> 8 & 0xF;
1857 (*pptfd
)->funcdesc
.cParams
= pFuncRec
->nrargs
;
1858 (*pptfd
)->funcdesc
.cParamsOpt
= pFuncRec
->nroargs
;
1859 (*pptfd
)->funcdesc
.oVft
= pFuncRec
->VtableOffset
;
1860 (*pptfd
)->funcdesc
.wFuncFlags
= LOWORD(pFuncRec
->Flags
) ;
1864 &(*pptfd
)->funcdesc
.elemdescFunc
.tdesc
,
1866 MSFT_ResolveReferencedTypes(pcx
, pTI
, &(*pptfd
)->funcdesc
.elemdescFunc
.tdesc
);
1868 /* do the parameters/arguments */
1869 if(pFuncRec
->nrargs
)
1872 MSFT_ParameterInfo paraminfo
;
1874 (*pptfd
)->funcdesc
.lprgelemdescParam
=
1875 TLB_Alloc(pFuncRec
->nrargs
* sizeof(ELEMDESC
));
1877 (*pptfd
)->pParamDesc
=
1878 TLB_Alloc(pFuncRec
->nrargs
* sizeof(TLBParDesc
));
1880 MSFT_ReadLEDWords(¶minfo
, sizeof(paraminfo
), pcx
,
1881 recoffset
+ reclength
- pFuncRec
->nrargs
* sizeof(MSFT_ParameterInfo
));
1883 for ( j
= 0 ; j
< pFuncRec
->nrargs
; j
++ )
1885 ELEMDESC
*elemdesc
= &(*pptfd
)->funcdesc
.lprgelemdescParam
[j
];
1892 elemdesc
->u
.paramdesc
.wParamFlags
= paraminfo
.Flags
;
1895 if (paraminfo
.oName
== -1)
1896 /* this occurs for [propput] or [propget] methods, so
1897 * we should just set the name of the parameter to the
1898 * name of the method. */
1899 (*pptfd
)->pParamDesc
[j
].Name
= SysAllocString((*pptfd
)->Name
);
1901 (*pptfd
)->pParamDesc
[j
].Name
=
1902 MSFT_ReadName( pcx
, paraminfo
.oName
);
1903 TRACE_(typelib
)("param[%d] = %s\n", j
, debugstr_w((*pptfd
)->pParamDesc
[j
].Name
));
1905 MSFT_ResolveReferencedTypes(pcx
, pTI
, &elemdesc
->tdesc
);
1908 if ( (elemdesc
->u
.paramdesc
.wParamFlags
& PARAMFLAG_FHASDEFAULT
) &&
1909 (pFuncRec
->FKCCIC
& 0x1000) )
1911 INT
* pInt
= (INT
*)((char *)pFuncRec
+
1913 (pFuncRec
->nrargs
* 4 + 1) * sizeof(INT
) );
1915 PARAMDESC
* pParamDesc
= &elemdesc
->u
.paramdesc
;
1917 pParamDesc
->pparamdescex
= TLB_Alloc(sizeof(PARAMDESCEX
));
1918 pParamDesc
->pparamdescex
->cBytes
= sizeof(PARAMDESCEX
);
1920 MSFT_ReadValue(&(pParamDesc
->pparamdescex
->varDefaultValue
),
1924 elemdesc
->u
.paramdesc
.pparamdescex
= NULL
;
1926 if ( nrattributes
> 7 + j
&& pFuncRec
->FKCCIC
& 0x80 )
1929 pFuncRec
->OptAttr
[7+j
],
1930 &(*pptfd
)->pParamDesc
[j
].pCustData
);
1933 /* SEEK value = jump to offset,
1934 * from there jump to the end of record,
1935 * go back by (j-1) arguments
1937 MSFT_ReadLEDWords( ¶minfo
,
1938 sizeof(MSFT_ParameterInfo
), pcx
,
1939 recoffset
+ reclength
- ((pFuncRec
->nrargs
- j
- 1)
1940 * sizeof(MSFT_ParameterInfo
)));
1944 /* scode is not used: archaic win16 stuff FIXME: right? */
1945 (*pptfd
)->funcdesc
.cScodes
= 0 ;
1946 (*pptfd
)->funcdesc
.lprgscode
= NULL
;
1949 pptfd
= & ((*pptfd
)->next
);
1950 recoffset
+= reclength
;
1952 HeapFree(GetProcessHeap(), 0, recbuf
);
1955 static void MSFT_DoVars(TLBContext
*pcx
, ITypeInfoImpl
*pTI
, int cFuncs
,
1956 int cVars
, int offset
, TLBVarDesc
** pptvd
)
1958 int infolen
, nameoffset
, reclength
;
1960 MSFT_VarRecord
* pVarRec
=(MSFT_VarRecord
*) recbuf
;
1964 TRACE_(typelib
)("\n");
1966 MSFT_ReadLEDWords(&infolen
,sizeof(INT
), pcx
, offset
);
1967 MSFT_ReadLEDWords(&recoffset
,sizeof(INT
), pcx
, offset
+ infolen
+
1968 ((cFuncs
+cVars
)*2+cFuncs
+ 1)*sizeof(INT
));
1969 recoffset
+= offset
+sizeof(INT
);
1970 for(i
=0;i
<cVars
;i
++){
1971 *pptvd
=TLB_Alloc(sizeof(TLBVarDesc
));
1972 /* name, eventually add to a hash table */
1973 MSFT_ReadLEDWords(&nameoffset
, sizeof(INT
), pcx
,
1974 offset
+ infolen
+ (2*cFuncs
+ cVars
+ i
+ 1) * sizeof(INT
));
1975 (*pptvd
)->Name
=MSFT_ReadName(pcx
, nameoffset
);
1976 /* read the variable information record */
1977 MSFT_ReadLEDWords(&reclength
, sizeof(INT
), pcx
, recoffset
);
1979 MSFT_ReadLEDWords(pVarRec
, reclength
- sizeof(INT
), pcx
, DO_NOT_SEEK
);
1981 if(reclength
>(6*sizeof(INT
)) )
1982 (*pptvd
)->HelpContext
=pVarRec
->HelpContext
;
1983 if(reclength
>(7*sizeof(INT
)) )
1984 (*pptvd
)->HelpString
= MSFT_ReadString(pcx
, pVarRec
->oHelpString
) ;
1985 if(reclength
>(8*sizeof(INT
)) )
1986 if(reclength
>(9*sizeof(INT
)) )
1987 (*pptvd
)->HelpStringContext
=pVarRec
->HelpStringContext
;
1988 /* fill the VarDesc Structure */
1989 MSFT_ReadLEDWords(&(*pptvd
)->vardesc
.memid
, sizeof(INT
), pcx
,
1990 offset
+ infolen
+ (cFuncs
+ i
+ 1) * sizeof(INT
));
1991 (*pptvd
)->vardesc
.varkind
= pVarRec
->VarKind
;
1992 (*pptvd
)->vardesc
.wVarFlags
= pVarRec
->Flags
;
1993 MSFT_GetTdesc(pcx
, pVarRec
->DataType
,
1994 &(*pptvd
)->vardesc
.elemdescVar
.tdesc
, pTI
);
1995 /* (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) FIXME?? */
1996 if(pVarRec
->VarKind
== VAR_CONST
){
1997 (*pptvd
)->vardesc
.u
.lpvarValue
=TLB_Alloc(sizeof(VARIANT
));
1998 MSFT_ReadValue((*pptvd
)->vardesc
.u
.lpvarValue
,
1999 pVarRec
->OffsValue
, pcx
);
2001 (*pptvd
)->vardesc
.u
.oInst
=pVarRec
->OffsValue
;
2002 MSFT_ResolveReferencedTypes(pcx
, pTI
, &(*pptvd
)->vardesc
.elemdescVar
.tdesc
);
2003 pptvd
=&((*pptvd
)->next
);
2004 recoffset
+= reclength
;
2007 /* fill in data for a hreftype (offset). When the referenced type is contained
2008 * in the typelib, it's just an (file) offset in the type info base dir.
2009 * If comes from import, it's an offset+1 in the ImpInfo table
2011 static void MSFT_DoRefType(TLBContext
*pcx
, ITypeLibImpl
*pTL
,
2017 TRACE_(typelib
)("TLB context %p, TLB offset %x\n", pcx
, offset
);
2019 LIST_FOR_EACH_ENTRY(ref
, &pTL
->ref_list
, TLBRefType
, entry
)
2021 if(ref
->reference
== offset
) return;
2024 ref
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*ref
));
2025 list_add_tail(&pTL
->ref_list
, &ref
->entry
);
2027 if(!MSFT_HREFTYPE_INTHISFILE( offset
)) {
2028 /* external typelib */
2029 MSFT_ImpInfo impinfo
;
2030 TLBImpLib
*pImpLib
=(pcx
->pLibInfo
->pImpLibs
);
2032 TRACE_(typelib
)("offset %x, masked offset %x\n", offset
, offset
+ (offset
& 0xfffffffc));
2034 MSFT_ReadLEDWords(&impinfo
, sizeof(impinfo
), pcx
,
2035 pcx
->pTblDir
->pImpInfo
.offset
+ (offset
& 0xfffffffc));
2036 for(j
=0;pImpLib
;j
++){ /* search the known offsets of all import libraries */
2037 if(pImpLib
->offset
==impinfo
.oImpFile
) break;
2038 pImpLib
=pImpLib
->next
;
2041 ref
->reference
= offset
;
2042 ref
->pImpTLInfo
= pImpLib
;
2043 if(impinfo
.flags
& MSFT_IMPINFO_OFFSET_IS_GUID
) {
2044 MSFT_ReadGuid(&ref
->guid
, impinfo
.oGuid
, pcx
);
2045 TRACE("importing by guid %s\n", debugstr_guid(&ref
->guid
));
2046 ref
->index
= TLB_REF_USE_GUID
;
2048 ref
->index
= impinfo
.oGuid
;
2050 ERR("Cannot find a reference\n");
2051 ref
->reference
= -1;
2052 ref
->pImpTLInfo
= TLB_REF_NOT_FOUND
;
2055 /* in this typelib */
2056 ref
->index
= MSFT_HREFTYPE_INDEX(offset
);
2057 ref
->reference
= offset
;
2058 ref
->pImpTLInfo
= TLB_REF_INTERNAL
;
2062 /* process Implemented Interfaces of a com class */
2063 static void MSFT_DoImplTypes(TLBContext
*pcx
, ITypeInfoImpl
*pTI
, int count
,
2067 MSFT_RefRecord refrec
;
2068 TLBImplType
**ppImpl
= &pTI
->impltypelist
;
2070 TRACE_(typelib
)("\n");
2072 for(i
=0;i
<count
;i
++){
2073 if(offset
<0) break; /* paranoia */
2074 *ppImpl
=TLB_Alloc(sizeof(**ppImpl
));
2075 MSFT_ReadLEDWords(&refrec
,sizeof(refrec
),pcx
,offset
+pcx
->pTblDir
->pRefTab
.offset
);
2076 MSFT_DoRefType(pcx
, pTI
->pTypeLib
, refrec
.reftype
);
2077 (*ppImpl
)->hRef
= refrec
.reftype
;
2078 (*ppImpl
)->implflags
=refrec
.flags
;
2079 (*ppImpl
)->ctCustData
=
2080 MSFT_CustData(pcx
, refrec
.oCustData
, &(*ppImpl
)->pCustData
);
2081 offset
=refrec
.onext
;
2082 ppImpl
=&((*ppImpl
)->next
);
2086 * process a typeinfo record
2088 static ITypeInfoImpl
* MSFT_DoTypeInfo(
2091 ITypeLibImpl
* pLibInfo
)
2093 MSFT_TypeInfoBase tiBase
;
2094 ITypeInfoImpl
*ptiRet
;
2096 TRACE_(typelib
)("count=%u\n", count
);
2098 ptiRet
= (ITypeInfoImpl
*) ITypeInfo_Constructor();
2099 MSFT_ReadLEDWords(&tiBase
, sizeof(tiBase
) ,pcx
,
2100 pcx
->pTblDir
->pTypeInfoTab
.offset
+count
*sizeof(tiBase
));
2102 /* this is where we are coming from */
2103 ptiRet
->pTypeLib
= pLibInfo
;
2104 ptiRet
->index
=count
;
2105 /* fill in the typeattr fields */
2107 MSFT_ReadGuid(&ptiRet
->TypeAttr
.guid
, tiBase
.posguid
, pcx
);
2108 ptiRet
->TypeAttr
.lcid
=pLibInfo
->LibAttr
.lcid
; /* FIXME: correct? */
2109 ptiRet
->TypeAttr
.lpstrSchema
=NULL
; /* reserved */
2110 ptiRet
->TypeAttr
.cbSizeInstance
=tiBase
.size
;
2111 ptiRet
->TypeAttr
.typekind
=tiBase
.typekind
& 0xF;
2112 ptiRet
->TypeAttr
.cFuncs
=LOWORD(tiBase
.cElement
);
2113 ptiRet
->TypeAttr
.cVars
=HIWORD(tiBase
.cElement
);
2114 ptiRet
->TypeAttr
.cbAlignment
=(tiBase
.typekind
>> 11 )& 0x1F; /* there are more flags there */
2115 ptiRet
->TypeAttr
.wTypeFlags
=tiBase
.flags
;
2116 ptiRet
->TypeAttr
.wMajorVerNum
=LOWORD(tiBase
.version
);
2117 ptiRet
->TypeAttr
.wMinorVerNum
=HIWORD(tiBase
.version
);
2118 ptiRet
->TypeAttr
.cImplTypes
=tiBase
.cImplTypes
;
2119 ptiRet
->TypeAttr
.cbSizeVft
=tiBase
.cbSizeVft
; /* FIXME: this is only the non inherited part */
2120 if(ptiRet
->TypeAttr
.typekind
== TKIND_ALIAS
)
2121 MSFT_GetTdesc(pcx
, tiBase
.datatype1
,
2122 &ptiRet
->TypeAttr
.tdescAlias
, ptiRet
);
2125 /* IDLDESC idldescType; *//* never saw this one != zero */
2127 /* name, eventually add to a hash table */
2128 ptiRet
->Name
=MSFT_ReadName(pcx
, tiBase
.NameOffset
);
2129 ptiRet
->hreftype
= MSFT_ReadHreftype(pcx
, tiBase
.NameOffset
);
2130 TRACE_(typelib
)("reading %s\n", debugstr_w(ptiRet
->Name
));
2132 ptiRet
->DocString
=MSFT_ReadString(pcx
, tiBase
.docstringoffs
);
2133 ptiRet
->dwHelpStringContext
=tiBase
.helpstringcontext
;
2134 ptiRet
->dwHelpContext
=tiBase
.helpcontext
;
2136 if (ptiRet
->TypeAttr
.typekind
== TKIND_MODULE
)
2137 ptiRet
->DllName
= MSFT_ReadString(pcx
, tiBase
.datatype1
);
2139 /* note: InfoType's Help file and HelpStringDll come from the containing
2140 * library. Further HelpString and Docstring appear to be the same thing :(
2143 if(ptiRet
->TypeAttr
.cFuncs
>0 )
2144 MSFT_DoFuncs(pcx
, ptiRet
, ptiRet
->TypeAttr
.cFuncs
,
2145 ptiRet
->TypeAttr
.cVars
,
2146 tiBase
.memoffset
, & ptiRet
->funclist
);
2148 if(ptiRet
->TypeAttr
.cVars
>0 )
2149 MSFT_DoVars(pcx
, ptiRet
, ptiRet
->TypeAttr
.cFuncs
,
2150 ptiRet
->TypeAttr
.cVars
,
2151 tiBase
.memoffset
, & ptiRet
->varlist
);
2152 if(ptiRet
->TypeAttr
.cImplTypes
>0 ) {
2153 switch(ptiRet
->TypeAttr
.typekind
)
2156 MSFT_DoImplTypes(pcx
, ptiRet
, ptiRet
->TypeAttr
.cImplTypes
,
2159 case TKIND_DISPATCH
:
2160 /* This is not -1 when the interface is a non-base dual interface or
2161 when a dispinterface wraps an interface ie the idl 'dispinterface x {interface y;};'.
2162 Note however that GetRefTypeOfImplType(0) always returns a ref to IDispatch and
2166 if (tiBase
.datatype1
!= -1)
2168 ptiRet
->impltypelist
= TLB_Alloc(sizeof(TLBImplType
));
2169 ptiRet
->impltypelist
->hRef
= tiBase
.datatype1
;
2170 MSFT_DoRefType(pcx
, pLibInfo
, tiBase
.datatype1
);
2174 ptiRet
->impltypelist
=TLB_Alloc(sizeof(TLBImplType
));
2175 MSFT_DoRefType(pcx
, pLibInfo
, tiBase
.datatype1
);
2176 ptiRet
->impltypelist
->hRef
= tiBase
.datatype1
;
2181 MSFT_CustData(pcx
, tiBase
.oCustData
, &ptiRet
->pCustData
);
2183 TRACE_(typelib
)("%s guid: %s kind:%s\n",
2184 debugstr_w(ptiRet
->Name
),
2185 debugstr_guid(&ptiRet
->TypeAttr
.guid
),
2186 typekind_desc
[ptiRet
->TypeAttr
.typekind
]);
2191 /* Because type library parsing has some degree of overhead, and some apps repeatedly load the same
2192 * typelibs over and over, we cache them here. According to MSDN Microsoft have a similar scheme in
2193 * place. This will cause a deliberate memory leak, but generally losing RAM for cycles is an acceptable
2196 static ITypeLibImpl
*tlb_cache_first
;
2197 static CRITICAL_SECTION cache_section
;
2198 static CRITICAL_SECTION_DEBUG cache_section_debug
=
2200 0, 0, &cache_section
,
2201 { &cache_section_debug
.ProcessLocksList
, &cache_section_debug
.ProcessLocksList
},
2202 0, 0, { (DWORD_PTR
)(__FILE__
": typelib loader cache") }
2204 static CRITICAL_SECTION cache_section
= { &cache_section_debug
, -1, 0, 0, 0, 0 };
2207 /****************************************************************************
2210 * find the type of the typelib file and map the typelib resource into
2213 #define MSFT_SIGNATURE 0x5446534D /* "MSFT" */
2214 #define SLTG_SIGNATURE 0x47544c53 /* "SLTG" */
2215 static int TLB_ReadTypeLib(LPCWSTR pszFileName
, LPWSTR pszPath
, UINT cchPath
, ITypeLib2
**ppTypeLib
)
2217 ITypeLibImpl
*entry
;
2218 int ret
= TYPE_E_CANTLOADLIBRARY
;
2221 LPWSTR index_str
, file
= (LPWSTR
)pszFileName
;
2225 index_str
= strrchrW(pszFileName
, '\\');
2226 if(index_str
&& *++index_str
!= '\0')
2229 long idx
= strtolW(index_str
, &end_ptr
, 10);
2230 if(*end_ptr
== '\0')
2232 int str_len
= index_str
- pszFileName
- 1;
2234 file
= HeapAlloc(GetProcessHeap(), 0, (str_len
+ 1) * sizeof(WCHAR
));
2235 memcpy(file
, pszFileName
, str_len
* sizeof(WCHAR
));
2240 if(!SearchPathW(NULL
, file
, NULL
, cchPath
, pszPath
, NULL
))
2242 if(strchrW(file
, '\\'))
2244 lstrcpyW(pszPath
, file
);
2248 int len
= GetSystemDirectoryW(pszPath
, cchPath
);
2249 pszPath
[len
] = '\\';
2250 memcpy(pszPath
+ len
+ 1, file
, (strlenW(file
) + 1) * sizeof(WCHAR
));
2254 if(file
!= pszFileName
) HeapFree(GetProcessHeap(), 0, file
);
2256 TRACE_(typelib
)("File %s index %d\n", debugstr_w(pszPath
), index
);
2258 /* We look the path up in the typelib cache. If found, we just addref it, and return the pointer. */
2259 EnterCriticalSection(&cache_section
);
2260 for (entry
= tlb_cache_first
; entry
!= NULL
; entry
= entry
->next
)
2262 if (!strcmpiW(entry
->path
, pszPath
) && entry
->index
== index
)
2264 TRACE("cache hit\n");
2265 *ppTypeLib
= (ITypeLib2
*)entry
;
2266 ITypeLib_AddRef(*ppTypeLib
);
2267 LeaveCriticalSection(&cache_section
);
2271 LeaveCriticalSection(&cache_section
);
2273 /* now actually load and parse the typelib */
2275 hinstDLL
= LoadLibraryExW(pszPath
, 0, DONT_RESOLVE_DLL_REFERENCES
|
2276 LOAD_LIBRARY_AS_DATAFILE
| LOAD_WITH_ALTERED_SEARCH_PATH
);
2280 static const WCHAR TYPELIBW
[] = {'T','Y','P','E','L','I','B',0};
2281 HRSRC hrsrc
= FindResourceW(hinstDLL
, MAKEINTRESOURCEW(index
), TYPELIBW
);
2284 HGLOBAL hGlobal
= LoadResource(hinstDLL
, hrsrc
);
2287 LPVOID pBase
= LockResource(hGlobal
);
2288 DWORD dwTLBLength
= SizeofResource(hinstDLL
, hrsrc
);
2292 /* try to load as incore resource */
2293 DWORD dwSignature
= FromLEDWord(*((DWORD
*) pBase
));
2294 if (dwSignature
== MSFT_SIGNATURE
)
2295 *ppTypeLib
= ITypeLib2_Constructor_MSFT(pBase
, dwTLBLength
);
2296 else if (dwSignature
== SLTG_SIGNATURE
)
2297 *ppTypeLib
= ITypeLib2_Constructor_SLTG(pBase
, dwTLBLength
);
2299 FIXME("Header type magic 0x%08x not supported.\n",dwSignature
);
2301 FreeResource( hGlobal
);
2304 FreeLibrary(hinstDLL
);
2308 HANDLE hFile
= CreateFileW(pszPath
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0 );
2309 if (INVALID_HANDLE_VALUE
!= hFile
)
2311 HANDLE hMapping
= CreateFileMappingW( hFile
, NULL
, PAGE_READONLY
| SEC_COMMIT
, 0, 0, NULL
);
2314 LPVOID pBase
= MapViewOfFile(hMapping
, FILE_MAP_READ
, 0, 0, 0);
2317 /* retrieve file size */
2318 DWORD dwTLBLength
= GetFileSize(hFile
, NULL
);
2319 DWORD dwSignature
= FromLEDWord(*((DWORD
*) pBase
));
2321 if (dwSignature
== MSFT_SIGNATURE
)
2322 *ppTypeLib
= ITypeLib2_Constructor_MSFT(pBase
, dwTLBLength
);
2323 else if (dwSignature
== SLTG_SIGNATURE
)
2324 *ppTypeLib
= ITypeLib2_Constructor_SLTG(pBase
, dwTLBLength
);
2326 UnmapViewOfFile(pBase
);
2328 CloseHandle(hMapping
);
2335 ITypeLibImpl
*impl
= (ITypeLibImpl
*)*ppTypeLib
;
2337 TRACE("adding to cache\n");
2338 impl
->path
= HeapAlloc(GetProcessHeap(), 0, (strlenW(pszPath
)+1) * sizeof(WCHAR
));
2339 lstrcpyW(impl
->path
, pszPath
);
2340 /* We should really canonicalise the path here. */
2341 impl
->index
= index
;
2343 /* FIXME: check if it has added already in the meantime */
2344 EnterCriticalSection(&cache_section
);
2345 if ((impl
->next
= tlb_cache_first
) != NULL
) impl
->next
->prev
= impl
;
2347 tlb_cache_first
= impl
;
2348 LeaveCriticalSection(&cache_section
);
2351 ERR("Loading of typelib %s failed with error %d\n", debugstr_w(pszFileName
), GetLastError());
2356 /*================== ITypeLib(2) Methods ===================================*/
2358 static ITypeLibImpl
* TypeLibImpl_Constructor(void)
2360 ITypeLibImpl
* pTypeLibImpl
;
2362 pTypeLibImpl
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(ITypeLibImpl
));
2363 if (!pTypeLibImpl
) return NULL
;
2365 pTypeLibImpl
->lpVtbl
= &tlbvt
;
2366 pTypeLibImpl
->lpVtblTypeComp
= &tlbtcvt
;
2367 pTypeLibImpl
->ref
= 1;
2369 list_init(&pTypeLibImpl
->ref_list
);
2370 pTypeLibImpl
->dispatch_href
= -1;
2372 return pTypeLibImpl
;
2375 /****************************************************************************
2376 * ITypeLib2_Constructor_MSFT
2378 * loading an MSFT typelib from an in-memory image
2380 static ITypeLib2
* ITypeLib2_Constructor_MSFT(LPVOID pLib
, DWORD dwTLBLength
)
2384 MSFT_Header tlbHeader
;
2385 MSFT_SegDir tlbSegDir
;
2386 ITypeLibImpl
* pTypeLibImpl
;
2388 TRACE("%p, TLB length = %d\n", pLib
, dwTLBLength
);
2390 pTypeLibImpl
= TypeLibImpl_Constructor();
2391 if (!pTypeLibImpl
) return NULL
;
2393 /* get pointer to beginning of typelib data */
2397 cx
.pLibInfo
= pTypeLibImpl
;
2398 cx
.length
= dwTLBLength
;
2401 MSFT_ReadLEDWords((void*)&tlbHeader
, sizeof(tlbHeader
), &cx
, 0);
2402 TRACE_(typelib
)("header:\n");
2403 TRACE_(typelib
)("\tmagic1=0x%08x ,magic2=0x%08x\n",tlbHeader
.magic1
,tlbHeader
.magic2
);
2404 if (tlbHeader
.magic1
!= MSFT_SIGNATURE
) {
2405 FIXME("Header type magic 0x%08x not supported.\n",tlbHeader
.magic1
);
2408 TRACE_(typelib
)("\tdispatchpos = 0x%x\n", tlbHeader
.dispatchpos
);
2410 /* there is a small amount of information here until the next important
2412 * the segment directory . Try to calculate the amount of data */
2413 lPSegDir
= sizeof(tlbHeader
) + (tlbHeader
.nrtypeinfos
)*4 + ((tlbHeader
.varflags
& HELPDLLFLAG
)? 4 :0);
2415 /* now read the segment directory */
2416 TRACE("read segment directory (at %ld)\n",lPSegDir
);
2417 MSFT_ReadLEDWords(&tlbSegDir
, sizeof(tlbSegDir
), &cx
, lPSegDir
);
2418 cx
.pTblDir
= &tlbSegDir
;
2420 /* just check two entries */
2421 if ( tlbSegDir
.pTypeInfoTab
.res0c
!= 0x0F || tlbSegDir
.pImpInfo
.res0c
!= 0x0F)
2423 ERR("cannot find the table directory, ptr=0x%lx\n",lPSegDir
);
2424 HeapFree(GetProcessHeap(),0,pTypeLibImpl
);
2428 /* now fill our internal data */
2429 /* TLIBATTR fields */
2430 MSFT_ReadGuid(&pTypeLibImpl
->LibAttr
.guid
, tlbHeader
.posguid
, &cx
);
2432 /* pTypeLibImpl->LibAttr.lcid = tlbHeader.lcid;*/
2433 /* Windows seems to have zero here, is this correct? */
2434 if(SUBLANGID(tlbHeader
.lcid
) == SUBLANG_NEUTRAL
)
2435 pTypeLibImpl
->LibAttr
.lcid
= MAKELCID(MAKELANGID(PRIMARYLANGID(tlbHeader
.lcid
),0),0);
2437 pTypeLibImpl
->LibAttr
.lcid
= 0;
2439 pTypeLibImpl
->LibAttr
.syskind
= tlbHeader
.varflags
& 0x0f; /* check the mask */
2440 pTypeLibImpl
->LibAttr
.wMajorVerNum
= LOWORD(tlbHeader
.version
);
2441 pTypeLibImpl
->LibAttr
.wMinorVerNum
= HIWORD(tlbHeader
.version
);
2442 pTypeLibImpl
->LibAttr
.wLibFlags
= (WORD
) tlbHeader
.flags
& 0xffff;/* check mask */
2444 /* name, eventually add to a hash table */
2445 pTypeLibImpl
->Name
= MSFT_ReadName(&cx
, tlbHeader
.NameOffset
);
2448 pTypeLibImpl
->DocString
= MSFT_ReadString(&cx
, tlbHeader
.helpstring
);
2449 pTypeLibImpl
->HelpFile
= MSFT_ReadString(&cx
, tlbHeader
.helpfile
);
2451 if( tlbHeader
.varflags
& HELPDLLFLAG
)
2454 MSFT_ReadLEDWords(&offset
, sizeof(offset
), &cx
, sizeof(tlbHeader
));
2455 pTypeLibImpl
->HelpStringDll
= MSFT_ReadString(&cx
, offset
);
2458 pTypeLibImpl
->dwHelpContext
= tlbHeader
.helpstringcontext
;
2461 if(tlbHeader
.CustomDataOffset
>= 0)
2463 pTypeLibImpl
->ctCustData
= MSFT_CustData(&cx
, tlbHeader
.CustomDataOffset
, &pTypeLibImpl
->pCustData
);
2466 /* fill in typedescriptions */
2467 if(tlbSegDir
.pTypdescTab
.length
> 0)
2469 int i
, j
, cTD
= tlbSegDir
.pTypdescTab
.length
/ (2*sizeof(INT
));
2471 pTypeLibImpl
->ctTypeDesc
= cTD
;
2472 pTypeLibImpl
->pTypeDesc
= TLB_Alloc( cTD
* sizeof(TYPEDESC
));
2473 MSFT_ReadLEWords(td
, sizeof(td
), &cx
, tlbSegDir
.pTypdescTab
.offset
);
2476 /* FIXME: add several sanity checks here */
2477 pTypeLibImpl
->pTypeDesc
[i
].vt
= td
[0] & VT_TYPEMASK
;
2478 if(td
[0] == VT_PTR
|| td
[0] == VT_SAFEARRAY
)
2480 /* FIXME: check safearray */
2482 pTypeLibImpl
->pTypeDesc
[i
].u
.lptdesc
= & stndTypeDesc
[td
[2]];
2484 pTypeLibImpl
->pTypeDesc
[i
].u
.lptdesc
= & pTypeLibImpl
->pTypeDesc
[td
[2]/8];
2486 else if(td
[0] == VT_CARRAY
)
2488 /* array descr table here */
2489 pTypeLibImpl
->pTypeDesc
[i
].u
.lpadesc
= (void *)((int) td
[2]); /* temp store offset in*/
2491 else if(td
[0] == VT_USERDEFINED
)
2493 pTypeLibImpl
->pTypeDesc
[i
].u
.hreftype
= MAKELONG(td
[2],td
[3]);
2495 if(++i
<cTD
) MSFT_ReadLEWords(td
, sizeof(td
), &cx
, DO_NOT_SEEK
);
2498 /* second time around to fill the array subscript info */
2501 if(pTypeLibImpl
->pTypeDesc
[i
].vt
!= VT_CARRAY
) continue;
2502 if(tlbSegDir
.pArrayDescriptions
.offset
>0)
2504 MSFT_ReadLEWords(td
, sizeof(td
), &cx
, tlbSegDir
.pArrayDescriptions
.offset
+ (int) pTypeLibImpl
->pTypeDesc
[i
].u
.lpadesc
);
2505 pTypeLibImpl
->pTypeDesc
[i
].u
.lpadesc
= TLB_Alloc(sizeof(ARRAYDESC
)+sizeof(SAFEARRAYBOUND
)*(td
[3]-1));
2508 pTypeLibImpl
->pTypeDesc
[i
].u
.lpadesc
->tdescElem
.vt
= td
[0] & VT_TYPEMASK
;
2510 pTypeLibImpl
->pTypeDesc
[i
].u
.lpadesc
->tdescElem
= stndTypeDesc
[td
[0]/8];
2512 pTypeLibImpl
->pTypeDesc
[i
].u
.lpadesc
->cDims
= td
[2];
2514 for(j
= 0; j
<td
[2]; j
++)
2516 MSFT_ReadLEDWords(& pTypeLibImpl
->pTypeDesc
[i
].u
.lpadesc
->rgbounds
[j
].cElements
,
2517 sizeof(INT
), &cx
, DO_NOT_SEEK
);
2518 MSFT_ReadLEDWords(& pTypeLibImpl
->pTypeDesc
[i
].u
.lpadesc
->rgbounds
[j
].lLbound
,
2519 sizeof(INT
), &cx
, DO_NOT_SEEK
);
2524 pTypeLibImpl
->pTypeDesc
[i
].u
.lpadesc
= NULL
;
2525 ERR("didn't find array description data\n");
2530 /* imported type libs */
2531 if(tlbSegDir
.pImpFiles
.offset
>0)
2533 TLBImpLib
**ppImpLib
= &(pTypeLibImpl
->pImpLibs
);
2534 int oGuid
, offset
= tlbSegDir
.pImpFiles
.offset
;
2537 while(offset
< tlbSegDir
.pImpFiles
.offset
+tlbSegDir
.pImpFiles
.length
)
2542 *ppImpLib
= TLB_Alloc(sizeof(TLBImpLib
));
2543 (*ppImpLib
)->offset
= offset
- tlbSegDir
.pImpFiles
.offset
;
2544 MSFT_ReadLEDWords(&oGuid
, sizeof(INT
), &cx
, offset
);
2546 MSFT_ReadLEDWords(&(*ppImpLib
)->lcid
, sizeof(LCID
), &cx
, DO_NOT_SEEK
);
2547 MSFT_ReadLEWords(&(*ppImpLib
)->wVersionMajor
, sizeof(WORD
), &cx
, DO_NOT_SEEK
);
2548 MSFT_ReadLEWords(&(*ppImpLib
)->wVersionMinor
, sizeof(WORD
), &cx
, DO_NOT_SEEK
);
2549 MSFT_ReadLEWords(& size
, sizeof(UINT16
), &cx
, DO_NOT_SEEK
);
2552 name
= TLB_Alloc(size
+1);
2553 MSFT_Read(name
, size
, &cx
, DO_NOT_SEEK
);
2554 len
= MultiByteToWideChar(CP_ACP
, 0, name
, -1, NULL
, 0 );
2555 (*ppImpLib
)->name
= TLB_Alloc(len
* sizeof(WCHAR
));
2556 MultiByteToWideChar(CP_ACP
, 0, name
, -1, (*ppImpLib
)->name
, len
);
2559 MSFT_ReadGuid(&(*ppImpLib
)->guid
, oGuid
, &cx
);
2560 offset
= (offset
+ sizeof(INT
) + sizeof(DWORD
) + sizeof(LCID
) + sizeof(UINT16
) + size
+ 3) & ~3;
2562 ppImpLib
= &(*ppImpLib
)->next
;
2566 pTypeLibImpl
->dispatch_href
= tlbHeader
.dispatchpos
;
2567 if(pTypeLibImpl
->dispatch_href
!= -1)
2568 MSFT_DoRefType(&cx
, pTypeLibImpl
, pTypeLibImpl
->dispatch_href
);
2571 if(tlbHeader
.nrtypeinfos
>= 0 )
2573 /*pTypeLibImpl->TypeInfoCount=tlbHeader.nrtypeinfos; */
2574 ITypeInfoImpl
**ppTI
= &(pTypeLibImpl
->pTypeInfo
);
2577 for(i
= 0; i
<(int)tlbHeader
.nrtypeinfos
; i
++)
2579 *ppTI
= MSFT_DoTypeInfo(&cx
, i
, pTypeLibImpl
);
2581 ppTI
= &((*ppTI
)->next
);
2582 (pTypeLibImpl
->TypeInfoCount
)++;
2586 TRACE("(%p)\n", pTypeLibImpl
);
2587 return (ITypeLib2
*) pTypeLibImpl
;
2591 static BSTR
TLB_MultiByteToBSTR(char *ptr
)
2597 len
= MultiByteToWideChar(CP_ACP
, 0, ptr
, -1, NULL
, 0);
2598 nameW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
2599 MultiByteToWideChar(CP_ACP
, 0, ptr
, -1, nameW
, len
);
2600 ret
= SysAllocString(nameW
);
2601 HeapFree(GetProcessHeap(), 0, nameW
);
2605 static BOOL
TLB_GUIDFromString(char *str
, GUID
*guid
)
2611 if(sscanf(str
, "%x-%hx-%hx-%hx", &guid
->Data1
, &guid
->Data2
, &guid
->Data3
, &s
) != 4) {
2612 FIXME("Can't parse guid %s\n", debugstr_guid(guid
));
2616 guid
->Data4
[0] = s
>> 8;
2617 guid
->Data4
[1] = s
& 0xff;
2620 for(i
= 0; i
< 6; i
++) {
2621 memcpy(b
, str
+ 24 + 2 * i
, 2);
2622 guid
->Data4
[i
+ 2] = strtol(b
, NULL
, 16);
2627 static WORD
SLTG_ReadString(char *ptr
, BSTR
*pBstr
)
2634 bytelen
= *(WORD
*)ptr
;
2635 if(bytelen
== 0xffff) return 2;
2636 len
= MultiByteToWideChar(CP_ACP
, 0, ptr
+ 2, bytelen
, NULL
, 0);
2637 nameW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
2638 len
= MultiByteToWideChar(CP_ACP
, 0, ptr
+ 2, bytelen
, nameW
, len
);
2639 *pBstr
= SysAllocStringLen(nameW
, len
);
2640 HeapFree(GetProcessHeap(), 0, nameW
);
2644 static WORD
SLTG_ReadStringA(char *ptr
, char **str
)
2649 bytelen
= *(WORD
*)ptr
;
2650 if(bytelen
== 0xffff) return 2;
2651 *str
= HeapAlloc(GetProcessHeap(), 0, bytelen
+ 1);
2652 memcpy(*str
, ptr
+ 2, bytelen
);
2653 (*str
)[bytelen
] = '\0';
2657 static DWORD
SLTG_ReadLibBlk(LPVOID pLibBlk
, ITypeLibImpl
*pTypeLibImpl
)
2659 char *ptr
= pLibBlk
;
2662 if((w
= *(WORD
*)ptr
) != SLTG_LIBBLK_MAGIC
) {
2663 FIXME("libblk magic = %04x\n", w
);
2668 if((w
= *(WORD
*)ptr
) != 0xffff) {
2669 FIXME("LibBlk.res06 = %04x. Assumung string and skipping\n", w
);
2674 ptr
+= SLTG_ReadString(ptr
, &pTypeLibImpl
->DocString
);
2676 ptr
+= SLTG_ReadString(ptr
, &pTypeLibImpl
->HelpFile
);
2678 pTypeLibImpl
->dwHelpContext
= *(DWORD
*)ptr
;
2681 pTypeLibImpl
->LibAttr
.syskind
= *(WORD
*)ptr
;
2684 if(SUBLANGID(*(WORD
*)ptr
) == SUBLANG_NEUTRAL
)
2685 pTypeLibImpl
->LibAttr
.lcid
= MAKELCID(MAKELANGID(PRIMARYLANGID(*(WORD
*)ptr
),0),0);
2687 pTypeLibImpl
->LibAttr
.lcid
= 0;
2690 ptr
+= 4; /* skip res12 */
2692 pTypeLibImpl
->LibAttr
.wLibFlags
= *(WORD
*)ptr
;
2695 pTypeLibImpl
->LibAttr
.wMajorVerNum
= *(WORD
*)ptr
;
2698 pTypeLibImpl
->LibAttr
.wMinorVerNum
= *(WORD
*)ptr
;
2701 memcpy(&pTypeLibImpl
->LibAttr
.guid
, ptr
, sizeof(GUID
));
2702 ptr
+= sizeof(GUID
);
2704 return ptr
- (char*)pLibBlk
;
2707 /* stores a mapping between the sltg typeinfo's references and the typelib's HREFTYPEs */
2712 } sltg_ref_lookup_t
;
2714 static HRESULT
sltg_get_typelib_ref(sltg_ref_lookup_t
*table
, DWORD typeinfo_ref
, HREFTYPE
*typelib_ref
)
2716 if(typeinfo_ref
< table
->num
)
2718 *typelib_ref
= table
->refs
[typeinfo_ref
];
2722 ERR("Unable to find reference\n");
2727 static WORD
*SLTG_DoType(WORD
*pType
, char *pBlk
, TYPEDESC
*pTD
, sltg_ref_lookup_t
*ref_lookup
)
2732 if((*pType
& 0xe00) == 0xe00) {
2734 pTD
->u
.lptdesc
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2736 pTD
= pTD
->u
.lptdesc
;
2738 switch(*pType
& 0x3f) {
2741 pTD
->u
.lptdesc
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2743 pTD
= pTD
->u
.lptdesc
;
2746 case VT_USERDEFINED
:
2747 pTD
->vt
= VT_USERDEFINED
;
2748 sltg_get_typelib_ref(ref_lookup
, *(++pType
) / 4, &pTD
->u
.hreftype
);
2754 /* *(pType+1) is offset to a SAFEARRAY, *(pType+2) is type of
2757 SAFEARRAY
*pSA
= (SAFEARRAY
*)(pBlk
+ *(++pType
));
2759 pTD
->vt
= VT_CARRAY
;
2760 pTD
->u
.lpadesc
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2762 (pSA
->cDims
- 1) * sizeof(SAFEARRAYBOUND
));
2763 pTD
->u
.lpadesc
->cDims
= pSA
->cDims
;
2764 memcpy(pTD
->u
.lpadesc
->rgbounds
, pSA
->rgsabound
,
2765 pSA
->cDims
* sizeof(SAFEARRAYBOUND
));
2767 pTD
= &pTD
->u
.lpadesc
->tdescElem
;
2773 /* FIXME: *(pType+1) gives an offset to SAFEARRAY, is this
2777 pTD
->vt
= VT_SAFEARRAY
;
2778 pTD
->u
.lptdesc
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2780 pTD
= pTD
->u
.lptdesc
;
2784 pTD
->vt
= *pType
& 0x3f;
2793 static WORD
*SLTG_DoElem(WORD
*pType
, char *pBlk
, ELEMDESC
*pElem
, sltg_ref_lookup_t
*ref_lookup
)
2795 /* Handle [in/out] first */
2796 if((*pType
& 0xc000) == 0xc000)
2797 pElem
->u
.paramdesc
.wParamFlags
= PARAMFLAG_NONE
;
2798 else if(*pType
& 0x8000)
2799 pElem
->u
.paramdesc
.wParamFlags
= PARAMFLAG_FIN
| PARAMFLAG_FOUT
;
2800 else if(*pType
& 0x4000)
2801 pElem
->u
.paramdesc
.wParamFlags
= PARAMFLAG_FOUT
;
2803 pElem
->u
.paramdesc
.wParamFlags
= PARAMFLAG_FIN
;
2806 pElem
->u
.paramdesc
.wParamFlags
|= PARAMFLAG_FLCID
;
2809 pElem
->u
.paramdesc
.wParamFlags
|= PARAMFLAG_FRETVAL
;
2811 return SLTG_DoType(pType
, pBlk
, &pElem
->tdesc
, ref_lookup
);
2815 static sltg_ref_lookup_t
*SLTG_DoRefs(SLTG_RefInfo
*pRef
, ITypeLibImpl
*pTL
,
2820 TLBRefType
*ref_type
;
2821 sltg_ref_lookup_t
*table
;
2822 HREFTYPE typelib_ref
;
2824 if(pRef
->magic
!= SLTG_REF_MAGIC
) {
2825 FIXME("Ref magic = %x\n", pRef
->magic
);
2828 name
= ( (char*)(&pRef
->names
) + pRef
->number
);
2830 table
= HeapAlloc(GetProcessHeap(), 0, sizeof(*table
) + ((pRef
->number
>> 3) - 1) * sizeof(table
->refs
[0]));
2831 table
->num
= pRef
->number
>> 3;
2833 /* FIXME should scan the existing list and reuse matching refs added by previous typeinfos */
2835 /* We don't want the first href to be 0 */
2836 typelib_ref
= (list_count(&pTL
->ref_list
) + 1) << 2;
2838 for(ref
= 0; ref
< pRef
->number
>> 3; ref
++) {
2840 unsigned int lib_offs
, type_num
;
2842 ref_type
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*ref_type
));
2844 name
+= SLTG_ReadStringA(name
, &refname
);
2845 if(sscanf(refname
, "*\\R%x*#%x", &lib_offs
, &type_num
) != 2)
2846 FIXME("Can't sscanf ref\n");
2847 if(lib_offs
!= 0xffff) {
2848 TLBImpLib
**import
= &pTL
->pImpLibs
;
2851 if((*import
)->offset
== lib_offs
)
2853 import
= &(*import
)->next
;
2856 char fname
[MAX_PATH
+1];
2859 *import
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2861 (*import
)->offset
= lib_offs
;
2862 TLB_GUIDFromString( pNameTable
+ lib_offs
+ 4,
2864 if(sscanf(pNameTable
+ lib_offs
+ 40, "}#%hd.%hd#%x#%s",
2865 &(*import
)->wVersionMajor
,
2866 &(*import
)->wVersionMinor
,
2867 &(*import
)->lcid
, fname
) != 4) {
2868 FIXME("can't sscanf ref %s\n",
2869 pNameTable
+ lib_offs
+ 40);
2871 len
= strlen(fname
);
2872 if(fname
[len
-1] != '#')
2873 FIXME("fname = %s\n", fname
);
2874 fname
[len
-1] = '\0';
2875 (*import
)->name
= TLB_MultiByteToBSTR(fname
);
2877 ref_type
->pImpTLInfo
= *import
;
2879 /* Store a reference to IDispatch */
2880 if(pTL
->dispatch_href
== -1 && IsEqualGUID(&(*import
)->guid
, &IID_StdOle
) && type_num
== 4)
2881 pTL
->dispatch_href
= typelib_ref
;
2883 } else { /* internal ref */
2884 ref_type
->pImpTLInfo
= TLB_REF_INTERNAL
;
2886 ref_type
->reference
= typelib_ref
;
2887 ref_type
->index
= type_num
;
2889 HeapFree(GetProcessHeap(), 0, refname
);
2890 list_add_tail(&pTL
->ref_list
, &ref_type
->entry
);
2892 table
->refs
[ref
] = typelib_ref
;
2895 if((BYTE
)*name
!= SLTG_REF_MAGIC
)
2896 FIXME("End of ref block magic = %x\n", *name
);
2897 dump_TLBRefType(pTL
);
2901 static char *SLTG_DoImpls(char *pBlk
, ITypeInfoImpl
*pTI
,
2902 BOOL OneOnly
, sltg_ref_lookup_t
*ref_lookup
)
2904 SLTG_ImplInfo
*info
;
2905 TLBImplType
**ppImplType
= &pTI
->impltypelist
;
2906 /* I don't really get this structure, usually it's 0x16 bytes
2907 long, but iuser.tlb contains some that are 0x18 bytes long.
2908 That's ok because we can use the next ptr to jump to the next
2909 one. But how do we know the length of the last one? The WORD
2910 at offs 0x8 might be the clue. For now I'm just assuming that
2911 the last one is the regular 0x16 bytes. */
2913 info
= (SLTG_ImplInfo
*)pBlk
;
2915 *ppImplType
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2916 sizeof(**ppImplType
));
2917 sltg_get_typelib_ref(ref_lookup
, info
->ref
, &(*ppImplType
)->hRef
);
2918 (*ppImplType
)->implflags
= info
->impltypeflags
;
2919 pTI
->TypeAttr
.cImplTypes
++;
2920 ppImplType
= &(*ppImplType
)->next
;
2922 if(info
->next
== 0xffff)
2925 FIXME("Interface inheriting more than one interface\n");
2926 info
= (SLTG_ImplInfo
*)(pBlk
+ info
->next
);
2928 info
++; /* see comment at top of function */
2932 static void SLTG_DoVars(char *pBlk
, char *pFirstItem
, ITypeInfoImpl
*pTI
, unsigned short cVars
, char *pNameTable
, sltg_ref_lookup_t
*ref_lookup
)
2934 TLBVarDesc
**ppVarDesc
= &pTI
->varlist
;
2935 BSTR bstrPrevName
= NULL
;
2936 SLTG_Variable
*pItem
;
2941 for(pItem
= (SLTG_Variable
*)pFirstItem
, i
= 0; i
< cVars
;
2942 pItem
= (SLTG_Variable
*)(pBlk
+ pItem
->next
), i
++) {
2944 *ppVarDesc
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2945 sizeof(**ppVarDesc
));
2946 (*ppVarDesc
)->vardesc
.memid
= pItem
->memid
;
2948 if (pItem
->magic
!= SLTG_VAR_MAGIC
&&
2949 pItem
->magic
!= SLTG_VAR_WITH_FLAGS_MAGIC
) {
2950 FIXME_(typelib
)("var magic = %02x\n", pItem
->magic
);
2954 if (pItem
->name
== 0xfffe)
2955 (*ppVarDesc
)->Name
= SysAllocString(bstrPrevName
);
2957 (*ppVarDesc
)->Name
= TLB_MultiByteToBSTR(pItem
->name
+ pNameTable
);
2959 TRACE_(typelib
)("byte_offs = 0x%x\n", pItem
->byte_offs
);
2960 TRACE_(typelib
)("memid = 0x%x\n", pItem
->memid
);
2962 if (pItem
->flags
& 0x40) {
2963 TRACE_(typelib
)("VAR_DISPATCH\n");
2964 (*ppVarDesc
)->vardesc
.varkind
= VAR_DISPATCH
;
2966 else if (pItem
->flags
& 0x10) {
2967 TRACE_(typelib
)("VAR_CONST\n");
2968 (*ppVarDesc
)->vardesc
.varkind
= VAR_CONST
;
2969 (*ppVarDesc
)->vardesc
.u
.lpvarValue
= HeapAlloc(GetProcessHeap(), 0,
2971 V_VT((*ppVarDesc
)->vardesc
.u
.lpvarValue
) = VT_INT
;
2972 V_UNION((*ppVarDesc
)->vardesc
.u
.lpvarValue
, intVal
) =
2973 *(INT
*)(pBlk
+ pItem
->byte_offs
);
2976 TRACE_(typelib
)("VAR_PERINSTANCE\n");
2977 (*ppVarDesc
)->vardesc
.u
.oInst
= pItem
->byte_offs
;
2978 (*ppVarDesc
)->vardesc
.varkind
= VAR_PERINSTANCE
;
2981 if (pItem
->magic
== SLTG_VAR_WITH_FLAGS_MAGIC
)
2982 (*ppVarDesc
)->vardesc
.wVarFlags
= pItem
->varflags
;
2984 if (pItem
->flags
& 0x80)
2985 (*ppVarDesc
)->vardesc
.wVarFlags
|= VARFLAG_FREADONLY
;
2987 if(pItem
->flags
& 0x02)
2988 pType
= &pItem
->type
;
2990 pType
= (WORD
*)(pBlk
+ pItem
->type
);
2992 if (pItem
->flags
& ~0xd2)
2993 FIXME_(typelib
)("unhandled flags = %02x\n", pItem
->flags
& ~0xd2);
2995 SLTG_DoElem(pType
, pBlk
,
2996 &(*ppVarDesc
)->vardesc
.elemdescVar
, ref_lookup
);
2998 dump_TypeDesc(&(*ppVarDesc
)->vardesc
.elemdescVar
.tdesc
, buf
);
3000 bstrPrevName
= (*ppVarDesc
)->Name
;
3001 ppVarDesc
= &((*ppVarDesc
)->next
);
3003 pTI
->TypeAttr
.cVars
= cVars
;
3006 static void SLTG_DoFuncs(char *pBlk
, char *pFirstItem
, ITypeInfoImpl
*pTI
, unsigned short cFuncs
, char *pNameTable
, sltg_ref_lookup_t
*ref_lookup
)
3008 SLTG_Function
*pFunc
;
3010 TLBFuncDesc
**ppFuncDesc
= &pTI
->funclist
;
3012 for(pFunc
= (SLTG_Function
*)pFirstItem
, i
= 0; i
< cFuncs
;
3013 pFunc
= (SLTG_Function
*)(pBlk
+ pFunc
->next
), i
++) {
3018 *ppFuncDesc
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
3019 sizeof(**ppFuncDesc
));
3021 switch (pFunc
->magic
& ~SLTG_FUNCTION_FLAGS_PRESENT
) {
3022 case SLTG_FUNCTION_MAGIC
:
3023 (*ppFuncDesc
)->funcdesc
.funckind
= FUNC_PUREVIRTUAL
;
3025 case SLTG_DISPATCH_FUNCTION_MAGIC
:
3026 (*ppFuncDesc
)->funcdesc
.funckind
= FUNC_DISPATCH
;
3028 case SLTG_STATIC_FUNCTION_MAGIC
:
3029 (*ppFuncDesc
)->funcdesc
.funckind
= FUNC_STATIC
;
3032 FIXME("unimplemented func magic = %02x\n", pFunc
->magic
& ~SLTG_FUNCTION_FLAGS_PRESENT
);
3033 HeapFree(GetProcessHeap(), 0, *ppFuncDesc
);
3037 (*ppFuncDesc
)->Name
= TLB_MultiByteToBSTR(pFunc
->name
+ pNameTable
);
3039 (*ppFuncDesc
)->funcdesc
.memid
= pFunc
->dispid
;
3040 (*ppFuncDesc
)->funcdesc
.invkind
= pFunc
->inv
>> 4;
3041 (*ppFuncDesc
)->funcdesc
.callconv
= pFunc
->nacc
& 0x7;
3042 (*ppFuncDesc
)->funcdesc
.cParams
= pFunc
->nacc
>> 3;
3043 (*ppFuncDesc
)->funcdesc
.cParamsOpt
= (pFunc
->retnextopt
& 0x7e) >> 1;
3044 (*ppFuncDesc
)->funcdesc
.oVft
= pFunc
->vtblpos
;
3046 if(pFunc
->magic
& SLTG_FUNCTION_FLAGS_PRESENT
)
3047 (*ppFuncDesc
)->funcdesc
.wFuncFlags
= pFunc
->funcflags
;
3049 if(pFunc
->retnextopt
& 0x80)
3050 pType
= &pFunc
->rettype
;
3052 pType
= (WORD
*)(pBlk
+ pFunc
->rettype
);
3054 SLTG_DoElem(pType
, pBlk
, &(*ppFuncDesc
)->funcdesc
.elemdescFunc
, ref_lookup
);
3056 (*ppFuncDesc
)->funcdesc
.lprgelemdescParam
=
3057 HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
3058 (*ppFuncDesc
)->funcdesc
.cParams
* sizeof(ELEMDESC
));
3059 (*ppFuncDesc
)->pParamDesc
=
3060 HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
3061 (*ppFuncDesc
)->funcdesc
.cParams
* sizeof(TLBParDesc
));
3063 pArg
= (WORD
*)(pBlk
+ pFunc
->arg_off
);
3065 for(param
= 0; param
< (*ppFuncDesc
)->funcdesc
.cParams
; param
++) {
3066 char *paramName
= pNameTable
+ *pArg
;
3068 /* If arg type follows then paramName points to the 2nd
3069 letter of the name, else the next WORD is an offset to
3070 the arg type and paramName points to the first letter.
3071 So let's take one char off paramName and see if we're
3072 pointing at an alpha-numeric char. However if *pArg is
3073 0xffff or 0xfffe then the param has no name, the former
3074 meaning that the next WORD is the type, the latter
3075 meaning the the next WORD is an offset to the type. */
3080 else if(*pArg
== 0xfffe) {
3084 else if(paramName
[-1] && !isalnum(paramName
[-1]))
3089 if(HaveOffs
) { /* the next word is an offset to type */
3090 pType
= (WORD
*)(pBlk
+ *pArg
);
3091 SLTG_DoElem(pType
, pBlk
,
3092 &(*ppFuncDesc
)->funcdesc
.lprgelemdescParam
[param
], ref_lookup
);
3097 pArg
= SLTG_DoElem(pArg
, pBlk
,
3098 &(*ppFuncDesc
)->funcdesc
.lprgelemdescParam
[param
], ref_lookup
);
3101 /* Are we an optional param ? */
3102 if((*ppFuncDesc
)->funcdesc
.cParams
- param
<=
3103 (*ppFuncDesc
)->funcdesc
.cParamsOpt
)
3104 (*ppFuncDesc
)->funcdesc
.lprgelemdescParam
[param
].u
.paramdesc
.wParamFlags
|= PARAMFLAG_FOPT
;
3107 (*ppFuncDesc
)->pParamDesc
[param
].Name
=
3108 TLB_MultiByteToBSTR(paramName
);
3112 ppFuncDesc
= &((*ppFuncDesc
)->next
);
3113 if(pFunc
->next
== 0xffff) break;
3115 pTI
->TypeAttr
.cFuncs
= cFuncs
;
3118 static void SLTG_ProcessCoClass(char *pBlk
, ITypeInfoImpl
*pTI
,
3119 char *pNameTable
, SLTG_TypeInfoHeader
*pTIHeader
,
3120 SLTG_TypeInfoTail
*pTITail
)
3122 char *pFirstItem
, *pNextItem
;
3123 sltg_ref_lookup_t
*ref_lookup
= NULL
;
3125 if(pTIHeader
->href_table
!= 0xffffffff) {
3126 ref_lookup
= SLTG_DoRefs((SLTG_RefInfo
*)((char *)pTIHeader
+ pTIHeader
->href_table
), pTI
->pTypeLib
,
3130 pFirstItem
= pNextItem
= pBlk
;
3132 if(*(WORD
*)pFirstItem
== SLTG_IMPL_MAGIC
) {
3133 pNextItem
= SLTG_DoImpls(pFirstItem
, pTI
, FALSE
, ref_lookup
);
3135 HeapFree(GetProcessHeap(), 0, ref_lookup
);
3139 static void SLTG_ProcessInterface(char *pBlk
, ITypeInfoImpl
*pTI
,
3140 char *pNameTable
, SLTG_TypeInfoHeader
*pTIHeader
,
3141 SLTG_TypeInfoTail
*pTITail
)
3143 char *pFirstItem
, *pNextItem
;
3144 sltg_ref_lookup_t
*ref_lookup
= NULL
;
3146 if(pTIHeader
->href_table
!= 0xffffffff) {
3147 ref_lookup
= SLTG_DoRefs((SLTG_RefInfo
*)((char *)pTIHeader
+ pTIHeader
->href_table
), pTI
->pTypeLib
,
3151 pFirstItem
= pNextItem
= pBlk
;
3153 if(*(WORD
*)pFirstItem
== SLTG_IMPL_MAGIC
) {
3154 pNextItem
= SLTG_DoImpls(pFirstItem
, pTI
, TRUE
, ref_lookup
);
3157 if (pTITail
->funcs_off
!= 0xffff)
3158 SLTG_DoFuncs(pBlk
, pBlk
+ pTITail
->funcs_off
, pTI
, pTITail
->cFuncs
, pNameTable
, ref_lookup
);
3160 HeapFree(GetProcessHeap(), 0, ref_lookup
);
3162 if (TRACE_ON(typelib
))
3163 dump_TLBFuncDesc(pTI
->funclist
);
3166 static void SLTG_ProcessRecord(char *pBlk
, ITypeInfoImpl
*pTI
,
3167 char *pNameTable
, SLTG_TypeInfoHeader
*pTIHeader
,
3168 SLTG_TypeInfoTail
*pTITail
)
3170 SLTG_DoVars(pBlk
, pBlk
+ pTITail
->vars_off
, pTI
, pTITail
->cVars
, pNameTable
, NULL
);
3173 static void SLTG_ProcessAlias(char *pBlk
, ITypeInfoImpl
*pTI
,
3174 char *pNameTable
, SLTG_TypeInfoHeader
*pTIHeader
,
3175 SLTG_TypeInfoTail
*pTITail
)
3178 sltg_ref_lookup_t
*ref_lookup
= NULL
;
3180 if (pTITail
->simple_alias
) {
3181 /* if simple alias, no more processing required */
3182 pTI
->TypeAttr
.tdescAlias
.vt
= pTITail
->tdescalias_vt
;
3186 if(pTIHeader
->href_table
!= 0xffffffff) {
3187 ref_lookup
= SLTG_DoRefs((SLTG_RefInfo
*)((char *)pTIHeader
+ pTIHeader
->href_table
), pTI
->pTypeLib
,
3191 /* otherwise it is an offset to a type */
3192 pType
= (WORD
*)(pBlk
+ pTITail
->tdescalias_vt
);
3194 SLTG_DoType(pType
, pBlk
, &pTI
->TypeAttr
.tdescAlias
, ref_lookup
);
3196 HeapFree(GetProcessHeap(), 0, ref_lookup
);
3199 static void SLTG_ProcessDispatch(char *pBlk
, ITypeInfoImpl
*pTI
,
3200 char *pNameTable
, SLTG_TypeInfoHeader
*pTIHeader
,
3201 SLTG_TypeInfoTail
*pTITail
)
3203 sltg_ref_lookup_t
*ref_lookup
= NULL
;
3204 if (pTIHeader
->href_table
!= 0xffffffff)
3205 ref_lookup
= SLTG_DoRefs((SLTG_RefInfo
*)((char *)pTIHeader
+ pTIHeader
->href_table
), pTI
->pTypeLib
,
3208 if (pTITail
->vars_off
!= 0xffff)
3209 SLTG_DoVars(pBlk
, pBlk
+ pTITail
->vars_off
, pTI
, pTITail
->cVars
, pNameTable
, ref_lookup
);
3211 if (pTITail
->funcs_off
!= 0xffff)
3212 SLTG_DoFuncs(pBlk
, pBlk
+ pTITail
->funcs_off
, pTI
, pTITail
->cFuncs
, pNameTable
, ref_lookup
);
3214 /* this is necessary to cope with MSFT typelibs that set cFuncs to the number
3215 * of dispinterface functons including the IDispatch ones, so
3216 * ITypeInfo::GetFuncDesc takes the real value for cFuncs from cbSizeVft */
3217 pTI
->TypeAttr
.cbSizeVft
= pTI
->TypeAttr
.cFuncs
* sizeof(void *);
3219 HeapFree(GetProcessHeap(), 0, ref_lookup
);
3220 if (TRACE_ON(typelib
))
3221 dump_TLBFuncDesc(pTI
->funclist
);
3224 static void SLTG_ProcessEnum(char *pBlk
, ITypeInfoImpl
*pTI
,
3225 char *pNameTable
, SLTG_TypeInfoHeader
*pTIHeader
,
3226 SLTG_TypeInfoTail
*pTITail
)
3228 SLTG_DoVars(pBlk
, pBlk
+ pTITail
->vars_off
, pTI
, pTITail
->cVars
, pNameTable
, NULL
);
3231 static void SLTG_ProcessModule(char *pBlk
, ITypeInfoImpl
*pTI
,
3232 char *pNameTable
, SLTG_TypeInfoHeader
*pTIHeader
,
3233 SLTG_TypeInfoTail
*pTITail
)
3235 sltg_ref_lookup_t
*ref_lookup
= NULL
;
3236 if (pTIHeader
->href_table
!= 0xffffffff)
3237 ref_lookup
= SLTG_DoRefs((SLTG_RefInfo
*)((char *)pTIHeader
+ pTIHeader
->href_table
), pTI
->pTypeLib
,
3240 if (pTITail
->vars_off
!= 0xffff)
3241 SLTG_DoVars(pBlk
, pBlk
+ pTITail
->vars_off
, pTI
, pTITail
->cVars
, pNameTable
, ref_lookup
);
3243 if (pTITail
->funcs_off
!= 0xffff)
3244 SLTG_DoFuncs(pBlk
, pBlk
+ pTITail
->funcs_off
, pTI
, pTITail
->cFuncs
, pNameTable
, ref_lookup
);
3245 HeapFree(GetProcessHeap(), 0, ref_lookup
);
3248 /* Because SLTG_OtherTypeInfo is such a painful struct, we make a more
3249 managable copy of it into this */
3262 } SLTG_InternalOtherTypeInfo
;
3264 /****************************************************************************
3265 * ITypeLib2_Constructor_SLTG
3267 * loading a SLTG typelib from an in-memory image
3269 static ITypeLib2
* ITypeLib2_Constructor_SLTG(LPVOID pLib
, DWORD dwTLBLength
)
3271 ITypeLibImpl
*pTypeLibImpl
;
3272 SLTG_Header
*pHeader
;
3273 SLTG_BlkEntry
*pBlkEntry
;
3277 LPVOID pBlk
, pFirstBlk
;
3278 SLTG_LibBlk
*pLibBlk
;
3279 SLTG_InternalOtherTypeInfo
*pOtherTypeInfoBlks
;
3280 char *pAfterOTIBlks
= NULL
;
3281 char *pNameTable
, *ptr
;
3284 ITypeInfoImpl
**ppTypeInfoImpl
;
3286 TRACE_(typelib
)("%p, TLB length = %d\n", pLib
, dwTLBLength
);
3289 pTypeLibImpl
= TypeLibImpl_Constructor();
3290 if (!pTypeLibImpl
) return NULL
;
3294 TRACE_(typelib
)("header:\n");
3295 TRACE_(typelib
)("\tmagic=0x%08x, file blocks = %d\n", pHeader
->SLTG_magic
,
3296 pHeader
->nrOfFileBlks
);
3297 if (pHeader
->SLTG_magic
!= SLTG_SIGNATURE
) {
3298 FIXME("Header type magic 0x%08x not supported.\n",
3299 pHeader
->SLTG_magic
);
3303 /* There are pHeader->nrOfFileBlks - 2 TypeInfo records in this typelib */
3304 pTypeLibImpl
->TypeInfoCount
= pHeader
->nrOfFileBlks
- 2;
3306 /* This points to pHeader->nrOfFileBlks - 1 of SLTG_BlkEntry */
3307 pBlkEntry
= (SLTG_BlkEntry
*)(pHeader
+ 1);
3309 /* Next we have a magic block */
3310 pMagic
= (SLTG_Magic
*)(pBlkEntry
+ pHeader
->nrOfFileBlks
- 1);
3312 /* Let's see if we're still in sync */
3313 if(memcmp(pMagic
->CompObj_magic
, SLTG_COMPOBJ_MAGIC
,
3314 sizeof(SLTG_COMPOBJ_MAGIC
))) {
3315 FIXME("CompObj magic = %s\n", pMagic
->CompObj_magic
);
3318 if(memcmp(pMagic
->dir_magic
, SLTG_DIR_MAGIC
,
3319 sizeof(SLTG_DIR_MAGIC
))) {
3320 FIXME("dir magic = %s\n", pMagic
->dir_magic
);
3324 pIndex
= (SLTG_Index
*)(pMagic
+1);
3326 pPad9
= (SLTG_Pad9
*)(pIndex
+ pTypeLibImpl
->TypeInfoCount
);
3328 pFirstBlk
= (LPVOID
)(pPad9
+ 1);
3330 /* We'll set up a ptr to the main library block, which is the last one. */
3332 for(pBlk
= pFirstBlk
, order
= pHeader
->first_blk
- 1, i
= 0;
3333 pBlkEntry
[order
].next
!= 0;
3334 order
= pBlkEntry
[order
].next
- 1, i
++) {
3335 pBlk
= (char*)pBlk
+ pBlkEntry
[order
].len
;
3339 len
= SLTG_ReadLibBlk(pLibBlk
, pTypeLibImpl
);
3341 /* Now there's 0x40 bytes of 0xffff with the numbers 0 to TypeInfoCount
3346 /* And now TypeInfoCount of SLTG_OtherTypeInfo */
3348 pOtherTypeInfoBlks
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
3349 sizeof(*pOtherTypeInfoBlks
) *
3350 pTypeLibImpl
->TypeInfoCount
);
3353 ptr
= (char*)pLibBlk
+ len
;
3355 for(i
= 0; i
< pTypeLibImpl
->TypeInfoCount
; i
++) {
3359 pOtherTypeInfoBlks
[i
].small_no
= *(WORD
*)ptr
;
3361 w
= *(WORD
*)(ptr
+ 2);
3364 pOtherTypeInfoBlks
[i
].index_name
= HeapAlloc(GetProcessHeap(),0,
3366 memcpy(pOtherTypeInfoBlks
[i
].index_name
, ptr
+ 4, w
);
3367 pOtherTypeInfoBlks
[i
].index_name
[w
] = '\0';
3369 w
= *(WORD
*)(ptr
+ 4 + len
);
3371 TRACE_(typelib
)("\twith %s\n", debugstr_an(ptr
+ 6 + len
, w
));
3373 pOtherTypeInfoBlks
[i
].other_name
= HeapAlloc(GetProcessHeap(),0,
3375 memcpy(pOtherTypeInfoBlks
[i
].other_name
, ptr
+ 6 + len
, w
);
3376 pOtherTypeInfoBlks
[i
].other_name
[w
] = '\0';
3378 pOtherTypeInfoBlks
[i
].res1a
= *(WORD
*)(ptr
+ len
+ 6);
3379 pOtherTypeInfoBlks
[i
].name_offs
= *(WORD
*)(ptr
+ len
+ 8);
3380 extra
= pOtherTypeInfoBlks
[i
].more_bytes
= *(WORD
*)(ptr
+ 10 + len
);
3382 pOtherTypeInfoBlks
[i
].extra
= HeapAlloc(GetProcessHeap(),0,
3384 memcpy(pOtherTypeInfoBlks
[i
].extra
, ptr
+ 12, extra
);
3387 pOtherTypeInfoBlks
[i
].res20
= *(WORD
*)(ptr
+ 12 + len
);
3388 pOtherTypeInfoBlks
[i
].helpcontext
= *(DWORD
*)(ptr
+ 14 + len
);
3389 pOtherTypeInfoBlks
[i
].res26
= *(WORD
*)(ptr
+ 18 + len
);
3390 memcpy(&pOtherTypeInfoBlks
[i
].uuid
, ptr
+ 20 + len
, sizeof(GUID
));
3391 len
+= sizeof(SLTG_OtherTypeInfo
);
3395 pAfterOTIBlks
= ptr
;
3397 /* Skip this WORD and get the next DWORD */
3398 len
= *(DWORD
*)(pAfterOTIBlks
+ 2);
3400 /* Now add this to pLibBLk look at what we're pointing at and
3401 possibly add 0x20, then add 0x216, sprinkle a bit a magic
3402 dust and we should be pointing at the beginning of the name
3405 pNameTable
= (char*)pLibBlk
+ len
;
3407 switch(*(WORD
*)pNameTable
) {
3414 FIXME("pNameTable jump = %x\n", *(WORD
*)pNameTable
);
3418 pNameTable
+= 0x216;
3422 TRACE("Library name is %s\n", pNameTable
+ pLibBlk
->name
);
3424 pTypeLibImpl
->Name
= TLB_MultiByteToBSTR(pNameTable
+ pLibBlk
->name
);
3427 /* Hopefully we now have enough ptrs set up to actually read in
3428 some TypeInfos. It's not clear which order to do them in, so
3429 I'll just follow the links along the BlkEntry chain and read
3430 them in the order in which they are in the file */
3432 ppTypeInfoImpl
= &(pTypeLibImpl
->pTypeInfo
);
3434 for(pBlk
= pFirstBlk
, order
= pHeader
->first_blk
- 1, i
= 0;
3435 pBlkEntry
[order
].next
!= 0;
3436 order
= pBlkEntry
[order
].next
- 1, i
++) {
3438 SLTG_TypeInfoHeader
*pTIHeader
;
3439 SLTG_TypeInfoTail
*pTITail
;
3440 SLTG_MemberHeader
*pMemHeader
;
3442 if(strcmp(pBlkEntry
[order
].index_string
+ (char*)pMagic
,
3443 pOtherTypeInfoBlks
[i
].index_name
)) {
3444 FIXME("Index strings don't match\n");
3449 if(pTIHeader
->magic
!= SLTG_TIHEADER_MAGIC
) {
3450 FIXME("TypeInfoHeader magic = %04x\n", pTIHeader
->magic
);
3453 TRACE("pTIHeader->res06 = %x, pTIHeader->res0e = %x, pTIHeader->res16 = %x, pTIHeader->res1e = %x\n",
3454 pTIHeader
->res06
, pTIHeader
->res0e
, pTIHeader
->res16
, pTIHeader
->res1e
);
3456 *ppTypeInfoImpl
= (ITypeInfoImpl
*)ITypeInfo_Constructor();
3457 (*ppTypeInfoImpl
)->pTypeLib
= pTypeLibImpl
;
3458 (*ppTypeInfoImpl
)->index
= i
;
3459 (*ppTypeInfoImpl
)->Name
= TLB_MultiByteToBSTR(
3460 pOtherTypeInfoBlks
[i
].name_offs
+
3462 (*ppTypeInfoImpl
)->dwHelpContext
= pOtherTypeInfoBlks
[i
].helpcontext
;
3463 memcpy(&((*ppTypeInfoImpl
)->TypeAttr
.guid
), &pOtherTypeInfoBlks
[i
].uuid
,
3465 (*ppTypeInfoImpl
)->TypeAttr
.typekind
= pTIHeader
->typekind
;
3466 (*ppTypeInfoImpl
)->TypeAttr
.wMajorVerNum
= pTIHeader
->major_version
;
3467 (*ppTypeInfoImpl
)->TypeAttr
.wMinorVerNum
= pTIHeader
->minor_version
;
3468 (*ppTypeInfoImpl
)->TypeAttr
.wTypeFlags
=
3469 (pTIHeader
->typeflags1
>> 3) | (pTIHeader
->typeflags2
<< 5);
3471 if((pTIHeader
->typeflags1
& 7) != 2)
3472 FIXME("typeflags1 = %02x\n", pTIHeader
->typeflags1
);
3473 if(pTIHeader
->typeflags3
!= 2)
3474 FIXME("typeflags3 = %02x\n", pTIHeader
->typeflags3
);
3476 TRACE("TypeInfo %s of kind %s guid %s typeflags %04x\n",
3477 debugstr_w((*ppTypeInfoImpl
)->Name
),
3478 typekind_desc
[pTIHeader
->typekind
],
3479 debugstr_guid(&(*ppTypeInfoImpl
)->TypeAttr
.guid
),
3480 (*ppTypeInfoImpl
)->TypeAttr
.wTypeFlags
);
3482 pMemHeader
= (SLTG_MemberHeader
*)((char *)pBlk
+ pTIHeader
->elem_table
);
3484 pTITail
= (SLTG_TypeInfoTail
*)((char *)(pMemHeader
+ 1) + pMemHeader
->cbExtra
);
3486 (*ppTypeInfoImpl
)->TypeAttr
.cbAlignment
= pTITail
->cbAlignment
;
3487 (*ppTypeInfoImpl
)->TypeAttr
.cbSizeInstance
= pTITail
->cbSizeInstance
;
3488 (*ppTypeInfoImpl
)->TypeAttr
.cbSizeVft
= pTITail
->cbSizeVft
;
3490 switch(pTIHeader
->typekind
) {
3492 SLTG_ProcessEnum((char *)(pMemHeader
+ 1), *ppTypeInfoImpl
, pNameTable
,
3493 pTIHeader
, pTITail
);
3497 SLTG_ProcessRecord((char *)(pMemHeader
+ 1), *ppTypeInfoImpl
, pNameTable
,
3498 pTIHeader
, pTITail
);
3501 case TKIND_INTERFACE
:
3502 SLTG_ProcessInterface((char *)(pMemHeader
+ 1), *ppTypeInfoImpl
, pNameTable
,
3503 pTIHeader
, pTITail
);
3507 SLTG_ProcessCoClass((char *)(pMemHeader
+ 1), *ppTypeInfoImpl
, pNameTable
,
3508 pTIHeader
, pTITail
);
3512 SLTG_ProcessAlias((char *)(pMemHeader
+ 1), *ppTypeInfoImpl
, pNameTable
,
3513 pTIHeader
, pTITail
);
3516 case TKIND_DISPATCH
:
3517 SLTG_ProcessDispatch((char *)(pMemHeader
+ 1), *ppTypeInfoImpl
, pNameTable
,
3518 pTIHeader
, pTITail
);
3522 SLTG_ProcessModule((char *)(pMemHeader
+ 1), *ppTypeInfoImpl
, pNameTable
,
3523 pTIHeader
, pTITail
);
3527 FIXME("Not processing typekind %d\n", pTIHeader
->typekind
);
3532 if(pTITail
) { /* could get cFuncs, cVars and cImplTypes from here
3533 but we've already set those */
3534 #define X(x) TRACE_(typelib)("tt "#x": %x\n",pTITail->res##x);
3549 ppTypeInfoImpl
= &((*ppTypeInfoImpl
)->next
);
3550 pBlk
= (char*)pBlk
+ pBlkEntry
[order
].len
;
3553 if(i
!= pTypeLibImpl
->TypeInfoCount
) {
3554 FIXME("Somehow processed %d TypeInfos\n", i
);
3558 HeapFree(GetProcessHeap(), 0, pOtherTypeInfoBlks
);
3559 return (ITypeLib2
*)pTypeLibImpl
;
3562 /* ITypeLib::QueryInterface
3564 static HRESULT WINAPI
ITypeLib2_fnQueryInterface(
3569 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
3571 TRACE("(%p)->(IID: %s)\n",This
,debugstr_guid(riid
));
3574 if(IsEqualIID(riid
, &IID_IUnknown
) ||
3575 IsEqualIID(riid
,&IID_ITypeLib
)||
3576 IsEqualIID(riid
,&IID_ITypeLib2
))
3583 ITypeLib2_AddRef(iface
);
3584 TRACE("-- Interface: (%p)->(%p)\n",ppvObject
,*ppvObject
);
3587 TRACE("-- Interface: E_NOINTERFACE\n");
3588 return E_NOINTERFACE
;
3593 static ULONG WINAPI
ITypeLib2_fnAddRef( ITypeLib2
*iface
)
3595 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
3596 ULONG ref
= InterlockedIncrement(&This
->ref
);
3598 TRACE("(%p)->ref was %u\n",This
, ref
- 1);
3603 /* ITypeLib::Release
3605 static ULONG WINAPI
ITypeLib2_fnRelease( ITypeLib2
*iface
)
3607 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
3608 ULONG ref
= InterlockedDecrement(&This
->ref
);
3610 TRACE("(%p)->(%u)\n",This
, ref
);
3614 TLBImpLib
*pImpLib
, *pImpLibNext
;
3615 TLBCustData
*pCustData
, *pCustDataNext
;
3616 TLBRefType
*ref_type
;
3620 /* remove cache entry */
3623 TRACE("removing from cache list\n");
3624 EnterCriticalSection(&cache_section
);
3625 if (This
->next
) This
->next
->prev
= This
->prev
;
3626 if (This
->prev
) This
->prev
->next
= This
->next
;
3627 else tlb_cache_first
= This
->next
;
3628 LeaveCriticalSection(&cache_section
);
3629 HeapFree(GetProcessHeap(), 0, This
->path
);
3631 TRACE(" destroying ITypeLib(%p)\n",This
);
3635 SysFreeString(This
->Name
);
3639 if (This
->DocString
)
3641 SysFreeString(This
->DocString
);
3642 This
->DocString
= NULL
;
3647 SysFreeString(This
->HelpFile
);
3648 This
->HelpFile
= NULL
;
3651 if (This
->HelpStringDll
)
3653 SysFreeString(This
->HelpStringDll
);
3654 This
->HelpStringDll
= NULL
;
3657 for (pCustData
= This
->pCustData
; pCustData
; pCustData
= pCustDataNext
)
3659 VariantClear(&pCustData
->data
);
3661 pCustDataNext
= pCustData
->next
;
3662 TLB_Free(pCustData
);
3665 for (i
= 0; i
< This
->ctTypeDesc
; i
++)
3666 if (This
->pTypeDesc
[i
].vt
== VT_CARRAY
)
3667 TLB_Free(This
->pTypeDesc
[i
].u
.lpadesc
);
3669 TLB_Free(This
->pTypeDesc
);
3671 for (pImpLib
= This
->pImpLibs
; pImpLib
; pImpLib
= pImpLibNext
)
3673 if (pImpLib
->pImpTypeLib
)
3674 ITypeLib_Release((ITypeLib
*)pImpLib
->pImpTypeLib
);
3675 TLB_Free(pImpLib
->name
);
3677 pImpLibNext
= pImpLib
->next
;
3681 LIST_FOR_EACH_ENTRY_SAFE(ref_type
, cursor2
, &This
->ref_list
, TLBRefType
, entry
)
3683 list_remove(&ref_type
->entry
);
3687 if (This
->pTypeInfo
) /* can be NULL */
3688 ITypeInfo_Release((ITypeInfo
*) This
->pTypeInfo
);
3689 HeapFree(GetProcessHeap(),0,This
);
3696 /* ITypeLib::GetTypeInfoCount
3698 * Returns the number of type descriptions in the type library
3700 static UINT WINAPI
ITypeLib2_fnGetTypeInfoCount( ITypeLib2
*iface
)
3702 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
3703 TRACE("(%p)->count is %d\n",This
, This
->TypeInfoCount
);
3704 return This
->TypeInfoCount
;
3707 /* ITypeLib::GetTypeInfo
3709 * retrieves the specified type description in the library.
3711 static HRESULT WINAPI
ITypeLib2_fnGetTypeInfo(
3714 ITypeInfo
**ppTInfo
)
3718 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
3719 ITypeInfoImpl
*pTypeInfo
= This
->pTypeInfo
;
3721 TRACE("(%p)->(index=%d)\n", This
, index
);
3723 if (!ppTInfo
) return E_INVALIDARG
;
3725 /* search element n in list */
3726 for(i
=0; i
< index
; i
++)
3728 pTypeInfo
= pTypeInfo
->next
;
3731 TRACE("-- element not found\n");
3732 return TYPE_E_ELEMENTNOTFOUND
;
3736 *ppTInfo
= (ITypeInfo
*) pTypeInfo
;
3738 ITypeInfo_AddRef(*ppTInfo
);
3739 TRACE("-- found (%p)\n",*ppTInfo
);
3744 /* ITypeLibs::GetTypeInfoType
3746 * Retrieves the type of a type description.
3748 static HRESULT WINAPI
ITypeLib2_fnGetTypeInfoType(
3753 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
3755 ITypeInfoImpl
*pTInfo
= This
->pTypeInfo
;
3757 if ((ITypeLib2_fnGetTypeInfoCount(iface
) < index
+ 1) || (index
< 0))
3758 return TYPE_E_ELEMENTNOTFOUND
;
3760 TRACE("(%p) index %d\n", This
, index
);
3762 if(!pTKind
) return E_INVALIDARG
;
3764 /* search element n in list */
3765 for(i
=0; i
< index
; i
++)
3769 TRACE("-- element not found\n");
3770 return TYPE_E_ELEMENTNOTFOUND
;
3772 pTInfo
= pTInfo
->next
;
3775 *pTKind
= pTInfo
->TypeAttr
.typekind
;
3776 TRACE("-- found Type (%d)\n", *pTKind
);
3780 /* ITypeLib::GetTypeInfoOfGuid
3782 * Retrieves the type description that corresponds to the specified GUID.
3785 static HRESULT WINAPI
ITypeLib2_fnGetTypeInfoOfGuid(
3788 ITypeInfo
**ppTInfo
)
3790 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
3791 ITypeInfoImpl
*pTypeInfo
= This
->pTypeInfo
; /* head of list */
3793 TRACE("(%p)\n\tguid:\t%s)\n",This
,debugstr_guid(guid
));
3797 WARN("-- element not found\n");
3798 return TYPE_E_ELEMENTNOTFOUND
;
3801 /* search linked list for guid */
3802 while( !IsEqualIID(guid
,&pTypeInfo
->TypeAttr
.guid
) )
3804 pTypeInfo
= pTypeInfo
->next
;
3808 /* end of list reached */
3809 WARN("-- element not found\n");
3810 return TYPE_E_ELEMENTNOTFOUND
;
3814 TRACE("-- found (%p, %s)\n",
3816 debugstr_w(pTypeInfo
->Name
));
3818 *ppTInfo
= (ITypeInfo
*)pTypeInfo
;
3819 ITypeInfo_AddRef(*ppTInfo
);
3823 /* ITypeLib::GetLibAttr
3825 * Retrieves the structure that contains the library's attributes.
3828 static HRESULT WINAPI
ITypeLib2_fnGetLibAttr(
3830 LPTLIBATTR
*ppTLibAttr
)
3832 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
3833 TRACE("(%p)\n",This
);
3834 *ppTLibAttr
= HeapAlloc(GetProcessHeap(), 0, sizeof(**ppTLibAttr
));
3835 memcpy(*ppTLibAttr
, &This
->LibAttr
, sizeof(**ppTLibAttr
));
3839 /* ITypeLib::GetTypeComp
3841 * Enables a client compiler to bind to a library's types, variables,
3842 * constants, and global functions.
3845 static HRESULT WINAPI
ITypeLib2_fnGetTypeComp(
3847 ITypeComp
**ppTComp
)
3849 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
3851 TRACE("(%p)->(%p)\n",This
,ppTComp
);
3852 *ppTComp
= (ITypeComp
*)&This
->lpVtblTypeComp
;
3853 ITypeComp_AddRef(*ppTComp
);
3858 /* ITypeLib::GetDocumentation
3860 * Retrieves the library's documentation string, the complete Help file name
3861 * and path, and the context identifier for the library Help topic in the Help
3864 * On a successful return all non-null BSTR pointers will have been set,
3867 static HRESULT WINAPI
ITypeLib2_fnGetDocumentation(
3871 BSTR
*pBstrDocString
,
3872 DWORD
*pdwHelpContext
,
3873 BSTR
*pBstrHelpFile
)
3875 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
3877 HRESULT result
= E_INVALIDARG
;
3882 TRACE("(%p) index %d Name(%p) DocString(%p) HelpContext(%p) HelpFile(%p)\n",
3884 pBstrName
, pBstrDocString
,
3885 pdwHelpContext
, pBstrHelpFile
);
3889 /* documentation for the typelib */
3894 if(!(*pBstrName
= SysAllocString(This
->Name
)))
3902 if (This
->DocString
)
3904 if(!(*pBstrDocString
= SysAllocString(This
->DocString
)))
3907 else if (This
->Name
)
3909 if(!(*pBstrDocString
= SysAllocString(This
->Name
)))
3913 *pBstrDocString
= NULL
;
3917 *pdwHelpContext
= This
->dwHelpContext
;
3923 if(!(*pBstrHelpFile
= SysAllocString(This
->HelpFile
)))
3927 *pBstrHelpFile
= NULL
;
3934 /* for a typeinfo */
3935 result
= ITypeLib2_fnGetTypeInfo(iface
, index
, &pTInfo
);
3937 if(SUCCEEDED(result
))
3939 result
= ITypeInfo_GetDocumentation(pTInfo
,
3943 pdwHelpContext
, pBstrHelpFile
);
3945 ITypeInfo_Release(pTInfo
);
3950 if (pBstrDocString
) SysFreeString (*pBstrDocString
);
3952 if (pBstrName
) SysFreeString (*pBstrName
);
3954 return STG_E_INSUFFICIENTMEMORY
;
3959 * Indicates whether a passed-in string contains the name of a type or member
3960 * described in the library.
3963 static HRESULT WINAPI
ITypeLib2_fnIsName(
3969 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
3970 ITypeInfoImpl
*pTInfo
;
3971 TLBFuncDesc
*pFInfo
;
3974 UINT nNameBufLen
= (lstrlenW(szNameBuf
)+1)*sizeof(WCHAR
);
3976 TRACE("(%p)->(%s,%08x,%p)\n", This
, debugstr_w(szNameBuf
), lHashVal
,
3980 for(pTInfo
=This
->pTypeInfo
;pTInfo
;pTInfo
=pTInfo
->next
){
3981 if(!memcmp(szNameBuf
,pTInfo
->Name
, nNameBufLen
)) goto ITypeLib2_fnIsName_exit
;
3982 for(pFInfo
=pTInfo
->funclist
;pFInfo
;pFInfo
=pFInfo
->next
) {
3983 if(!memcmp(szNameBuf
,pFInfo
->Name
, nNameBufLen
)) goto ITypeLib2_fnIsName_exit
;
3984 for(i
=0;i
<pFInfo
->funcdesc
.cParams
;i
++)
3985 if(!memcmp(szNameBuf
,pFInfo
->pParamDesc
[i
].Name
, nNameBufLen
))
3986 goto ITypeLib2_fnIsName_exit
;
3988 for(pVInfo
=pTInfo
->varlist
;pVInfo
;pVInfo
=pVInfo
->next
)
3989 if(!memcmp(szNameBuf
,pVInfo
->Name
, nNameBufLen
)) goto ITypeLib2_fnIsName_exit
;
3994 ITypeLib2_fnIsName_exit
:
3995 TRACE("(%p)slow! search for %s: %s found!\n", This
,
3996 debugstr_w(szNameBuf
), *pfName
?"NOT":"");
4001 /* ITypeLib::FindName
4003 * Finds occurrences of a type description in a type library. This may be used
4004 * to quickly verify that a name exists in a type library.
4007 static HRESULT WINAPI
ITypeLib2_fnFindName(
4011 ITypeInfo
**ppTInfo
,
4015 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
4016 ITypeInfoImpl
*pTInfo
;
4017 TLBFuncDesc
*pFInfo
;
4020 UINT nNameBufLen
= (lstrlenW(szNameBuf
)+1)*sizeof(WCHAR
);
4022 for(pTInfo
=This
->pTypeInfo
;pTInfo
&& j
<*pcFound
; pTInfo
=pTInfo
->next
){
4023 if(!memcmp(szNameBuf
,pTInfo
->Name
, nNameBufLen
)) goto ITypeLib2_fnFindName_exit
;
4024 for(pFInfo
=pTInfo
->funclist
;pFInfo
;pFInfo
=pFInfo
->next
) {
4025 if(!memcmp(szNameBuf
,pFInfo
->Name
,nNameBufLen
)) goto ITypeLib2_fnFindName_exit
;
4026 for(i
=0;i
<pFInfo
->funcdesc
.cParams
;i
++) {
4027 if(!memcmp(szNameBuf
,pFInfo
->pParamDesc
[i
].Name
,nNameBufLen
))
4028 goto ITypeLib2_fnFindName_exit
;
4031 for(pVInfo
=pTInfo
->varlist
;pVInfo
;pVInfo
=pVInfo
->next
)
4032 if(!memcmp(szNameBuf
,pVInfo
->Name
, nNameBufLen
)) goto ITypeLib2_fnFindName_exit
;
4034 ITypeLib2_fnFindName_exit
:
4035 ITypeInfo_AddRef((ITypeInfo
*)pTInfo
);
4036 ppTInfo
[j
]=(LPTYPEINFO
)pTInfo
;
4039 TRACE("(%p)slow! search for %d with %s: found %d TypeInfo's!\n",
4040 This
, *pcFound
, debugstr_w(szNameBuf
), j
);
4047 /* ITypeLib::ReleaseTLibAttr
4049 * Releases the TLIBATTR originally obtained from ITypeLib::GetLibAttr.
4052 static VOID WINAPI
ITypeLib2_fnReleaseTLibAttr(
4054 TLIBATTR
*pTLibAttr
)
4056 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
4057 TRACE("freeing (%p)\n",This
);
4058 HeapFree(GetProcessHeap(),0,pTLibAttr
);
4062 /* ITypeLib2::GetCustData
4064 * gets the custom data
4066 static HRESULT WINAPI
ITypeLib2_fnGetCustData(
4071 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
4072 TLBCustData
*pCData
;
4074 for(pCData
=This
->pCustData
; pCData
; pCData
= pCData
->next
)
4076 if( IsEqualIID(guid
, &pCData
->guid
)) break;
4079 TRACE("(%p) guid %s %s found!x)\n", This
, debugstr_guid(guid
), pCData
? "" : "NOT");
4083 VariantInit( pVarVal
);
4084 VariantCopy( pVarVal
, &pCData
->data
);
4087 return E_INVALIDARG
; /* FIXME: correct? */
4090 /* ITypeLib2::GetLibStatistics
4092 * Returns statistics about a type library that are required for efficient
4093 * sizing of hash tables.
4096 static HRESULT WINAPI
ITypeLib2_fnGetLibStatistics(
4098 ULONG
*pcUniqueNames
,
4099 ULONG
*pcchUniqueNames
)
4101 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
4103 FIXME("(%p): stub!\n", This
);
4105 if(pcUniqueNames
) *pcUniqueNames
=1;
4106 if(pcchUniqueNames
) *pcchUniqueNames
=1;
4110 /* ITypeLib2::GetDocumentation2
4112 * Retrieves the library's documentation string, the complete Help file name
4113 * and path, the localization context to use, and the context ID for the
4114 * library Help topic in the Help file.
4117 static HRESULT WINAPI
ITypeLib2_fnGetDocumentation2(
4121 BSTR
*pbstrHelpString
,
4122 DWORD
*pdwHelpStringContext
,
4123 BSTR
*pbstrHelpStringDll
)
4125 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
4129 FIXME("(%p) index %d lcid %d half implemented stub!\n", This
, index
, lcid
);
4131 /* the help string should be obtained from the helpstringdll,
4132 * using the _DLLGetDocumentation function, based on the supplied
4133 * lcid. Nice to do sometime...
4137 /* documentation for the typelib */
4139 *pbstrHelpString
=SysAllocString(This
->DocString
);
4140 if(pdwHelpStringContext
)
4141 *pdwHelpStringContext
=This
->dwHelpContext
;
4142 if(pbstrHelpStringDll
)
4143 *pbstrHelpStringDll
=SysAllocString(This
->HelpStringDll
);
4149 /* for a typeinfo */
4150 result
=ITypeLib2_GetTypeInfo(iface
, index
, &pTInfo
);
4152 if(SUCCEEDED(result
))
4154 ITypeInfo2
* pTInfo2
;
4155 result
= ITypeInfo_QueryInterface(pTInfo
,
4157 (LPVOID
*) &pTInfo2
);
4159 if(SUCCEEDED(result
))
4161 result
= ITypeInfo2_GetDocumentation2(pTInfo2
,
4165 pdwHelpStringContext
,
4166 pbstrHelpStringDll
);
4168 ITypeInfo2_Release(pTInfo2
);
4171 ITypeInfo_Release(pTInfo
);
4177 /* ITypeLib2::GetAllCustData
4179 * Gets all custom data items for the library.
4182 static HRESULT WINAPI
ITypeLib2_fnGetAllCustData(
4184 CUSTDATA
*pCustData
)
4186 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
4187 TLBCustData
*pCData
;
4189 TRACE("(%p) returning %d items\n", This
, This
->ctCustData
);
4190 pCustData
->prgCustData
= TLB_Alloc(This
->ctCustData
* sizeof(CUSTDATAITEM
));
4191 if(pCustData
->prgCustData
){
4192 pCustData
->cCustData
=This
->ctCustData
;
4193 for(i
=0, pCData
=This
->pCustData
; pCData
; i
++, pCData
= pCData
->next
){
4194 pCustData
->prgCustData
[i
].guid
=pCData
->guid
;
4195 VariantCopy(& pCustData
->prgCustData
[i
].varValue
, & pCData
->data
);
4198 ERR(" OUT OF MEMORY!\n");
4199 return E_OUTOFMEMORY
;
4204 static const ITypeLib2Vtbl tlbvt
= {
4205 ITypeLib2_fnQueryInterface
,
4207 ITypeLib2_fnRelease
,
4208 ITypeLib2_fnGetTypeInfoCount
,
4209 ITypeLib2_fnGetTypeInfo
,
4210 ITypeLib2_fnGetTypeInfoType
,
4211 ITypeLib2_fnGetTypeInfoOfGuid
,
4212 ITypeLib2_fnGetLibAttr
,
4213 ITypeLib2_fnGetTypeComp
,
4214 ITypeLib2_fnGetDocumentation
,
4216 ITypeLib2_fnFindName
,
4217 ITypeLib2_fnReleaseTLibAttr
,
4219 ITypeLib2_fnGetCustData
,
4220 ITypeLib2_fnGetLibStatistics
,
4221 ITypeLib2_fnGetDocumentation2
,
4222 ITypeLib2_fnGetAllCustData
4226 static HRESULT WINAPI
ITypeLibComp_fnQueryInterface(ITypeComp
* iface
, REFIID riid
, LPVOID
* ppv
)
4228 ITypeLibImpl
*This
= impl_from_ITypeComp(iface
);
4230 return ITypeLib2_QueryInterface((ITypeLib
*)This
, riid
, ppv
);
4233 static ULONG WINAPI
ITypeLibComp_fnAddRef(ITypeComp
* iface
)
4235 ITypeLibImpl
*This
= impl_from_ITypeComp(iface
);
4237 return ITypeLib2_AddRef((ITypeLib2
*)This
);
4240 static ULONG WINAPI
ITypeLibComp_fnRelease(ITypeComp
* iface
)
4242 ITypeLibImpl
*This
= impl_from_ITypeComp(iface
);
4244 return ITypeLib2_Release((ITypeLib2
*)This
);
4247 static HRESULT WINAPI
ITypeLibComp_fnBind(
4252 ITypeInfo
** ppTInfo
,
4253 DESCKIND
* pDescKind
,
4256 ITypeLibImpl
*This
= impl_from_ITypeComp(iface
);
4257 ITypeInfoImpl
*pTypeInfo
;
4259 TRACE("(%s, 0x%x, 0x%x, %p, %p, %p)\n", debugstr_w(szName
), lHash
, wFlags
, ppTInfo
, pDescKind
, pBindPtr
);
4261 *pDescKind
= DESCKIND_NONE
;
4262 pBindPtr
->lptcomp
= NULL
;
4265 for (pTypeInfo
= This
->pTypeInfo
; pTypeInfo
; pTypeInfo
= pTypeInfo
->next
)
4267 TRACE("testing %s\n", debugstr_w(pTypeInfo
->Name
));
4269 /* FIXME: check wFlags here? */
4270 /* FIXME: we should use a hash table to look this info up using lHash
4271 * instead of an O(n) search */
4272 if ((pTypeInfo
->TypeAttr
.typekind
== TKIND_ENUM
) ||
4273 (pTypeInfo
->TypeAttr
.typekind
== TKIND_MODULE
))
4275 if (pTypeInfo
->Name
&& !strcmpW(pTypeInfo
->Name
, szName
))
4277 *pDescKind
= DESCKIND_TYPECOMP
;
4278 pBindPtr
->lptcomp
= (ITypeComp
*)&pTypeInfo
->lpVtblTypeComp
;
4279 ITypeComp_AddRef(pBindPtr
->lptcomp
);
4280 TRACE("module or enum: %s\n", debugstr_w(szName
));
4285 if ((pTypeInfo
->TypeAttr
.typekind
== TKIND_MODULE
) ||
4286 (pTypeInfo
->TypeAttr
.typekind
== TKIND_ENUM
))
4288 ITypeComp
*pSubTypeComp
= (ITypeComp
*)&pTypeInfo
->lpVtblTypeComp
;
4291 hr
= ITypeComp_Bind(pSubTypeComp
, szName
, lHash
, wFlags
, ppTInfo
, pDescKind
, pBindPtr
);
4292 if (SUCCEEDED(hr
) && (*pDescKind
!= DESCKIND_NONE
))
4294 TRACE("found in module or in enum: %s\n", debugstr_w(szName
));
4299 if ((pTypeInfo
->TypeAttr
.typekind
== TKIND_COCLASS
) &&
4300 (pTypeInfo
->TypeAttr
.wTypeFlags
& TYPEFLAG_FAPPOBJECT
))
4302 ITypeComp
*pSubTypeComp
= (ITypeComp
*)&pTypeInfo
->lpVtblTypeComp
;
4304 ITypeInfo
*subtypeinfo
;
4306 DESCKIND subdesckind
;
4308 hr
= ITypeComp_Bind(pSubTypeComp
, szName
, lHash
, wFlags
,
4309 &subtypeinfo
, &subdesckind
, &subbindptr
);
4310 if (SUCCEEDED(hr
) && (subdesckind
!= DESCKIND_NONE
))
4312 TYPEDESC tdesc_appobject
=
4315 (TYPEDESC
*)pTypeInfo
->hreftype
4319 const VARDESC vardesc_appobject
=
4322 NULL
, /* lpstrSchema */
4337 VAR_STATIC
/* varkind */
4340 TRACE("found in implicit app object: %s\n", debugstr_w(szName
));
4342 /* cleanup things filled in by Bind call so we can put our
4343 * application object data in there instead */
4344 switch (subdesckind
)
4346 case DESCKIND_FUNCDESC
:
4347 ITypeInfo_ReleaseFuncDesc(subtypeinfo
, subbindptr
.lpfuncdesc
);
4349 case DESCKIND_VARDESC
:
4350 ITypeInfo_ReleaseVarDesc(subtypeinfo
, subbindptr
.lpvardesc
);
4355 if (subtypeinfo
) ITypeInfo_Release(subtypeinfo
);
4357 if (pTypeInfo
->hreftype
== -1)
4358 FIXME("no hreftype for interface %p\n", pTypeInfo
);
4360 hr
= TLB_AllocAndInitVarDesc(&vardesc_appobject
, &pBindPtr
->lpvardesc
);
4364 *pDescKind
= DESCKIND_IMPLICITAPPOBJ
;
4365 *ppTInfo
= (ITypeInfo
*)pTypeInfo
;
4366 ITypeInfo_AddRef(*ppTInfo
);
4372 TRACE("name not found %s\n", debugstr_w(szName
));
4376 static HRESULT WINAPI
ITypeLibComp_fnBindType(
4380 ITypeInfo
** ppTInfo
,
4381 ITypeComp
** ppTComp
)
4383 FIXME("(%s, %x, %p, %p): stub\n", debugstr_w(szName
), lHash
, ppTInfo
, ppTComp
);
4387 static const ITypeCompVtbl tlbtcvt
=
4390 ITypeLibComp_fnQueryInterface
,
4391 ITypeLibComp_fnAddRef
,
4392 ITypeLibComp_fnRelease
,
4394 ITypeLibComp_fnBind
,
4395 ITypeLibComp_fnBindType
4398 /*================== ITypeInfo(2) Methods ===================================*/
4399 static ITypeInfo2
* WINAPI
ITypeInfo_Constructor(void)
4401 ITypeInfoImpl
* pTypeInfoImpl
;
4403 pTypeInfoImpl
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(ITypeInfoImpl
));
4406 pTypeInfoImpl
->lpVtbl
= &tinfvt
;
4407 pTypeInfoImpl
->lpVtblTypeComp
= &tcompvt
;
4408 pTypeInfoImpl
->ref
=1;
4409 pTypeInfoImpl
->hreftype
= -1;
4410 pTypeInfoImpl
->TypeAttr
.memidConstructor
= MEMBERID_NIL
;
4411 pTypeInfoImpl
->TypeAttr
.memidDestructor
= MEMBERID_NIL
;
4413 TRACE("(%p)\n", pTypeInfoImpl
);
4414 return (ITypeInfo2
*) pTypeInfoImpl
;
4417 /* ITypeInfo::QueryInterface
4419 static HRESULT WINAPI
ITypeInfo_fnQueryInterface(
4424 ITypeLibImpl
*This
= (ITypeLibImpl
*)iface
;
4426 TRACE("(%p)->(IID: %s)\n",This
,debugstr_guid(riid
));
4429 if(IsEqualIID(riid
, &IID_IUnknown
) ||
4430 IsEqualIID(riid
,&IID_ITypeInfo
)||
4431 IsEqualIID(riid
,&IID_ITypeInfo2
))
4435 ITypeInfo_AddRef(iface
);
4436 TRACE("-- Interface: (%p)->(%p)\n",ppvObject
,*ppvObject
);
4439 TRACE("-- Interface: E_NOINTERFACE\n");
4440 return E_NOINTERFACE
;
4443 /* ITypeInfo::AddRef
4445 static ULONG WINAPI
ITypeInfo_fnAddRef( ITypeInfo2
*iface
)
4447 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
4448 ULONG ref
= InterlockedIncrement(&This
->ref
);
4450 ITypeLib2_AddRef((ITypeLib2
*)This
->pTypeLib
);
4452 TRACE("(%p)->ref is %u\n",This
, ref
);
4456 /* ITypeInfo::Release
4458 static ULONG WINAPI
ITypeInfo_fnRelease(ITypeInfo2
*iface
)
4460 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
4461 ULONG ref
= InterlockedDecrement(&This
->ref
);
4463 TRACE("(%p)->(%u)\n",This
, ref
);
4466 /* We don't release ITypeLib when ref=0 because
4467 it means that function is called by ITypeLib2_Release */
4468 ITypeLib2_Release((ITypeLib2
*)This
->pTypeLib
);
4470 TLBFuncDesc
*pFInfo
, *pFInfoNext
;
4471 TLBVarDesc
*pVInfo
, *pVInfoNext
;
4472 TLBImplType
*pImpl
, *pImplNext
;
4473 TLBCustData
*pCustData
, *pCustDataNext
;
4475 TRACE("destroying ITypeInfo(%p)\n",This
);
4477 if (This
->no_free_data
)
4482 SysFreeString(This
->Name
);
4486 if (This
->DocString
)
4488 SysFreeString(This
->DocString
);
4489 This
->DocString
= 0;
4494 SysFreeString(This
->DllName
);
4498 for (pFInfo
= This
->funclist
; pFInfo
; pFInfo
= pFInfoNext
)
4501 for(i
= 0;i
< pFInfo
->funcdesc
.cParams
; i
++)
4503 ELEMDESC
*elemdesc
= &pFInfo
->funcdesc
.lprgelemdescParam
[i
];
4504 if (elemdesc
->u
.paramdesc
.wParamFlags
& PARAMFLAG_FHASDEFAULT
)
4506 VariantClear(&elemdesc
->u
.paramdesc
.pparamdescex
->varDefaultValue
);
4507 TLB_Free(elemdesc
->u
.paramdesc
.pparamdescex
);
4509 SysFreeString(pFInfo
->pParamDesc
[i
].Name
);
4511 TLB_Free(pFInfo
->funcdesc
.lprgelemdescParam
);
4512 TLB_Free(pFInfo
->pParamDesc
);
4513 for (pCustData
= This
->pCustData
; pCustData
; pCustData
= pCustDataNext
)
4515 VariantClear(&pCustData
->data
);
4517 pCustDataNext
= pCustData
->next
;
4518 TLB_Free(pCustData
);
4520 if (HIWORD(pFInfo
->Entry
) != 0 && pFInfo
->Entry
!= (BSTR
)-1)
4521 SysFreeString(pFInfo
->Entry
);
4522 SysFreeString(pFInfo
->HelpString
);
4523 SysFreeString(pFInfo
->Name
);
4525 pFInfoNext
= pFInfo
->next
;
4528 for (pVInfo
= This
->varlist
; pVInfo
; pVInfo
= pVInfoNext
)
4530 if (pVInfo
->vardesc
.varkind
== VAR_CONST
)
4532 VariantClear(pVInfo
->vardesc
.u
.lpvarValue
);
4533 TLB_Free(pVInfo
->vardesc
.u
.lpvarValue
);
4535 SysFreeString(pVInfo
->Name
);
4536 pVInfoNext
= pVInfo
->next
;
4539 for(pImpl
= This
->impltypelist
; pImpl
; pImpl
= pImplNext
)
4541 for (pCustData
= pImpl
->pCustData
; pCustData
; pCustData
= pCustDataNext
)
4543 VariantClear(&pCustData
->data
);
4545 pCustDataNext
= pCustData
->next
;
4546 TLB_Free(pCustData
);
4548 pImplNext
= pImpl
->next
;
4551 TLB_Free(This
->pCustData
);
4556 ITypeInfo_Release((ITypeInfo
*)This
->next
);
4559 HeapFree(GetProcessHeap(),0,This
);
4565 /* ITypeInfo::GetTypeAttr
4567 * Retrieves a TYPEATTR structure that contains the attributes of the type
4571 static HRESULT WINAPI
ITypeInfo_fnGetTypeAttr( ITypeInfo2
*iface
,
4572 LPTYPEATTR
*ppTypeAttr
)
4574 const ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
4577 TRACE("(%p)\n",This
);
4579 size
= sizeof(**ppTypeAttr
);
4580 if (This
->TypeAttr
.typekind
== TKIND_ALIAS
)
4581 size
+= TLB_SizeTypeDesc(&This
->TypeAttr
.tdescAlias
, FALSE
);
4583 *ppTypeAttr
= HeapAlloc(GetProcessHeap(), 0, size
);
4585 return E_OUTOFMEMORY
;
4587 memcpy(*ppTypeAttr
, &This
->TypeAttr
, sizeof(**ppTypeAttr
));
4589 if (This
->TypeAttr
.typekind
== TKIND_ALIAS
)
4590 TLB_CopyTypeDesc(&(*ppTypeAttr
)->tdescAlias
,
4591 &This
->TypeAttr
.tdescAlias
, (void *)(*ppTypeAttr
+ 1));
4593 if((*ppTypeAttr
)->typekind
== TKIND_DISPATCH
) {
4594 (*ppTypeAttr
)->cFuncs
= (*ppTypeAttr
)->cbSizeVft
/ 4; /* This should include all the inherited
4596 (*ppTypeAttr
)->cbSizeVft
= 28; /* This is always the size of IDispatch's vtbl */
4597 (*ppTypeAttr
)->wTypeFlags
&= ~TYPEFLAG_FOLEAUTOMATION
;
4602 /* ITypeInfo::GetTypeComp
4604 * Retrieves the ITypeComp interface for the type description, which enables a
4605 * client compiler to bind to the type description's members.
4608 static HRESULT WINAPI
ITypeInfo_fnGetTypeComp( ITypeInfo2
*iface
,
4609 ITypeComp
* *ppTComp
)
4611 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
4613 TRACE("(%p)->(%p)\n", This
, ppTComp
);
4615 *ppTComp
= (ITypeComp
*)&This
->lpVtblTypeComp
;
4616 ITypeComp_AddRef(*ppTComp
);
4620 static SIZE_T
TLB_SizeElemDesc( const ELEMDESC
*elemdesc
)
4622 SIZE_T size
= TLB_SizeTypeDesc(&elemdesc
->tdesc
, FALSE
);
4623 if (elemdesc
->u
.paramdesc
.wParamFlags
& PARAMFLAG_FHASDEFAULT
)
4624 size
+= sizeof(*elemdesc
->u
.paramdesc
.pparamdescex
);
4628 static HRESULT
TLB_CopyElemDesc( const ELEMDESC
*src
, ELEMDESC
*dest
, char **buffer
)
4630 memcpy(dest
, src
, sizeof(ELEMDESC
));
4631 *buffer
= TLB_CopyTypeDesc(&dest
->tdesc
, &src
->tdesc
, *buffer
);
4632 if (src
->u
.paramdesc
.wParamFlags
& PARAMFLAG_FHASDEFAULT
)
4634 const PARAMDESCEX
*pparamdescex_src
= src
->u
.paramdesc
.pparamdescex
;
4635 PARAMDESCEX
*pparamdescex_dest
= dest
->u
.paramdesc
.pparamdescex
= (PARAMDESCEX
*)*buffer
;
4636 *buffer
+= sizeof(PARAMDESCEX
);
4637 memcpy(pparamdescex_dest
, pparamdescex_src
, sizeof(PARAMDESCEX
));
4638 VariantInit(&pparamdescex_dest
->varDefaultValue
);
4639 return VariantCopy(&pparamdescex_dest
->varDefaultValue
,
4640 (VARIANTARG
*)&pparamdescex_src
->varDefaultValue
);
4643 dest
->u
.paramdesc
.pparamdescex
= NULL
;
4647 static void TLB_FreeElemDesc( ELEMDESC
*elemdesc
)
4649 if (elemdesc
->u
.paramdesc
.wParamFlags
& PARAMFLAG_FHASDEFAULT
)
4650 VariantClear(&elemdesc
->u
.paramdesc
.pparamdescex
->varDefaultValue
);
4653 static HRESULT
TLB_AllocAndInitFuncDesc( const FUNCDESC
*src
, FUNCDESC
**dest_ptr
, BOOL dispinterface
)
4657 SIZE_T size
= sizeof(*src
);
4661 size
+= sizeof(*src
->lprgscode
) * src
->cScodes
;
4662 size
+= TLB_SizeElemDesc(&src
->elemdescFunc
);
4663 for (i
= 0; i
< src
->cParams
; i
++)
4665 size
+= sizeof(ELEMDESC
);
4666 size
+= TLB_SizeElemDesc(&src
->lprgelemdescParam
[i
]);
4669 dest
= (FUNCDESC
*)SysAllocStringByteLen(NULL
, size
);
4670 if (!dest
) return E_OUTOFMEMORY
;
4672 memcpy(dest
, src
, sizeof(FUNCDESC
));
4673 buffer
= (char *)(dest
+ 1);
4675 dest
->lprgscode
= (SCODE
*)buffer
;
4676 memcpy(dest
->lprgscode
, src
->lprgscode
, sizeof(*src
->lprgscode
) * src
->cScodes
);
4677 buffer
+= sizeof(*src
->lprgscode
) * src
->cScodes
;
4679 hr
= TLB_CopyElemDesc(&src
->elemdescFunc
, &dest
->elemdescFunc
, &buffer
);
4682 SysFreeString((BSTR
)dest
);
4686 dest
->lprgelemdescParam
= (ELEMDESC
*)buffer
;
4687 buffer
+= sizeof(ELEMDESC
) * src
->cParams
;
4688 for (i
= 0; i
< src
->cParams
; i
++)
4690 hr
= TLB_CopyElemDesc(&src
->lprgelemdescParam
[i
], &dest
->lprgelemdescParam
[i
], &buffer
);
4696 /* undo the above actions */
4697 for (i
= i
- 1; i
>= 0; i
--)
4698 TLB_FreeElemDesc(&dest
->lprgelemdescParam
[i
]);
4699 TLB_FreeElemDesc(&dest
->elemdescFunc
);
4700 SysFreeString((BSTR
)dest
);
4704 /* special treatment for dispinterfaces: this makes functions appear
4705 * to return their [retval] value when it is really returning an
4707 if (dispinterface
&& dest
->elemdescFunc
.tdesc
.vt
== VT_HRESULT
)
4709 if (dest
->cParams
&&
4710 (dest
->lprgelemdescParam
[dest
->cParams
- 1].u
.paramdesc
.wParamFlags
& PARAMFLAG_FRETVAL
))
4712 ELEMDESC
*elemdesc
= &dest
->lprgelemdescParam
[dest
->cParams
- 1];
4713 if (elemdesc
->tdesc
.vt
!= VT_PTR
)
4715 ERR("elemdesc should have started with VT_PTR instead of:\n");
4717 dump_ELEMDESC(elemdesc
);
4718 return E_UNEXPECTED
;
4721 /* copy last parameter to the return value. we are using a flat
4722 * buffer so there is no danger of leaking memory in
4724 dest
->elemdescFunc
.tdesc
= *elemdesc
->tdesc
.u
.lptdesc
;
4726 /* remove the last parameter */
4730 /* otherwise this function is made to appear to have no return
4732 dest
->elemdescFunc
.tdesc
.vt
= VT_VOID
;
4740 HRESULT
ITypeInfoImpl_GetInternalFuncDesc( ITypeInfo
*iface
, UINT index
, const FUNCDESC
**ppFuncDesc
)
4742 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
4743 const TLBFuncDesc
*pFDesc
;
4746 for(i
=0, pFDesc
=This
->funclist
; i
!=index
&& pFDesc
; i
++, pFDesc
=pFDesc
->next
)
4751 *ppFuncDesc
= &pFDesc
->funcdesc
;
4755 return TYPE_E_ELEMENTNOTFOUND
;
4758 /* internal function to make the inherited interfaces' methods appear
4759 * part of the interface */
4760 static HRESULT
ITypeInfoImpl_GetInternalDispatchFuncDesc( ITypeInfo
*iface
,
4761 UINT index
, const FUNCDESC
**ppFuncDesc
, UINT
*funcs
, UINT
*hrefoffset
)
4763 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
4765 UINT implemented_funcs
= 0;
4770 *hrefoffset
= DISPATCH_HREF_OFFSET
;
4772 if(This
->impltypelist
)
4774 ITypeInfo
*pSubTypeInfo
;
4777 hr
= ITypeInfo_GetRefTypeInfo(iface
, This
->impltypelist
->hRef
, &pSubTypeInfo
);
4781 hr
= ITypeInfoImpl_GetInternalDispatchFuncDesc(pSubTypeInfo
,
4784 &sub_funcs
, hrefoffset
);
4785 implemented_funcs
+= sub_funcs
;
4786 ITypeInfo_Release(pSubTypeInfo
);
4789 *hrefoffset
+= DISPATCH_HREF_OFFSET
;
4793 *funcs
= implemented_funcs
+ This
->TypeAttr
.cFuncs
;
4797 if (index
< implemented_funcs
)
4798 return E_INVALIDARG
;
4799 return ITypeInfoImpl_GetInternalFuncDesc(iface
, index
- implemented_funcs
,
4803 static inline void ITypeInfoImpl_ElemDescAddHrefOffset( LPELEMDESC pElemDesc
, UINT hrefoffset
)
4805 TYPEDESC
*pTypeDesc
= &pElemDesc
->tdesc
;
4808 switch (pTypeDesc
->vt
)
4810 case VT_USERDEFINED
:
4811 pTypeDesc
->u
.hreftype
+= hrefoffset
;
4815 pTypeDesc
= pTypeDesc
->u
.lptdesc
;
4818 pTypeDesc
= &pTypeDesc
->u
.lpadesc
->tdescElem
;
4826 static inline void ITypeInfoImpl_FuncDescAddHrefOffset( LPFUNCDESC pFuncDesc
, UINT hrefoffset
)
4829 for (i
= 0; i
< pFuncDesc
->cParams
; i
++)
4830 ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc
->lprgelemdescParam
[i
], hrefoffset
);
4831 ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc
->elemdescFunc
, hrefoffset
);
4834 /* ITypeInfo::GetFuncDesc
4836 * Retrieves the FUNCDESC structure that contains information about a
4837 * specified function.
4840 static HRESULT WINAPI
ITypeInfo_fnGetFuncDesc( ITypeInfo2
*iface
, UINT index
,
4841 LPFUNCDESC
*ppFuncDesc
)
4843 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
4844 const FUNCDESC
*internal_funcdesc
;
4846 UINT hrefoffset
= 0;
4848 TRACE("(%p) index %d\n", This
, index
);
4850 if (This
->TypeAttr
.typekind
== TKIND_DISPATCH
)
4851 hr
= ITypeInfoImpl_GetInternalDispatchFuncDesc((ITypeInfo
*)iface
, index
,
4852 &internal_funcdesc
, NULL
,
4855 hr
= ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo
*)iface
, index
,
4856 &internal_funcdesc
);
4859 WARN("description for function %d not found\n", index
);
4863 hr
= TLB_AllocAndInitFuncDesc(
4866 This
->TypeAttr
.typekind
== TKIND_DISPATCH
);
4868 if ((This
->TypeAttr
.typekind
== TKIND_DISPATCH
) && hrefoffset
)
4869 ITypeInfoImpl_FuncDescAddHrefOffset(*ppFuncDesc
, hrefoffset
);
4871 TRACE("-- 0x%08x\n", hr
);
4875 static HRESULT
TLB_AllocAndInitVarDesc( const VARDESC
*src
, VARDESC
**dest_ptr
)
4879 SIZE_T size
= sizeof(*src
);
4882 if (src
->lpstrSchema
) size
+= (strlenW(src
->lpstrSchema
) + 1) * sizeof(WCHAR
);
4883 if (src
->varkind
== VAR_CONST
)
4884 size
+= sizeof(VARIANT
);
4885 size
+= TLB_SizeElemDesc(&src
->elemdescVar
);
4887 dest
= (VARDESC
*)SysAllocStringByteLen(NULL
, size
);
4888 if (!dest
) return E_OUTOFMEMORY
;
4891 buffer
= (char *)(dest
+ 1);
4892 if (src
->lpstrSchema
)
4895 dest
->lpstrSchema
= (LPOLESTR
)buffer
;
4896 len
= strlenW(src
->lpstrSchema
);
4897 memcpy(dest
->lpstrSchema
, src
->lpstrSchema
, (len
+ 1) * sizeof(WCHAR
));
4898 buffer
+= (len
+ 1) * sizeof(WCHAR
);
4901 if (src
->varkind
== VAR_CONST
)
4905 dest
->u
.lpvarValue
= (VARIANT
*)buffer
;
4906 *dest
->u
.lpvarValue
= *src
->u
.lpvarValue
;
4907 buffer
+= sizeof(VARIANT
);
4908 VariantInit(dest
->u
.lpvarValue
);
4909 hr
= VariantCopy(dest
->u
.lpvarValue
, src
->u
.lpvarValue
);
4912 SysFreeString((BSTR
)dest_ptr
);
4916 hr
= TLB_CopyElemDesc(&src
->elemdescVar
, &dest
->elemdescVar
, &buffer
);
4919 if (src
->varkind
== VAR_CONST
)
4920 VariantClear(dest
->u
.lpvarValue
);
4921 SysFreeString((BSTR
)dest
);
4928 /* ITypeInfo::GetVarDesc
4930 * Retrieves a VARDESC structure that describes the specified variable.
4933 static HRESULT WINAPI
ITypeInfo_fnGetVarDesc( ITypeInfo2
*iface
, UINT index
,
4934 LPVARDESC
*ppVarDesc
)
4936 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
4938 const TLBVarDesc
*pVDesc
;
4940 TRACE("(%p) index %d\n", This
, index
);
4942 for(i
=0, pVDesc
=This
->varlist
; i
!=index
&& pVDesc
; i
++, pVDesc
=pVDesc
->next
)
4946 return TLB_AllocAndInitVarDesc(&pVDesc
->vardesc
, ppVarDesc
);
4948 return E_INVALIDARG
;
4951 /* ITypeInfo_GetNames
4953 * Retrieves the variable with the specified member ID (or the name of the
4954 * property or method and its parameters) that correspond to the specified
4957 static HRESULT WINAPI
ITypeInfo_fnGetNames( ITypeInfo2
*iface
, MEMBERID memid
,
4958 BSTR
*rgBstrNames
, UINT cMaxNames
, UINT
*pcNames
)
4960 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
4961 const TLBFuncDesc
*pFDesc
;
4962 const TLBVarDesc
*pVDesc
;
4964 TRACE("(%p) memid=0x%08x Maxname=%d\n", This
, memid
, cMaxNames
);
4965 for(pFDesc
=This
->funclist
; pFDesc
&& pFDesc
->funcdesc
.memid
!= memid
; pFDesc
=pFDesc
->next
);
4968 /* function found, now return function and parameter names */
4969 for(i
=0; i
<cMaxNames
&& i
<= pFDesc
->funcdesc
.cParams
; i
++)
4972 *rgBstrNames
=SysAllocString(pFDesc
->Name
);
4974 rgBstrNames
[i
]=SysAllocString(pFDesc
->pParamDesc
[i
-1].Name
);
4980 for(pVDesc
=This
->varlist
; pVDesc
&& pVDesc
->vardesc
.memid
!= memid
; pVDesc
=pVDesc
->next
);
4983 *rgBstrNames
=SysAllocString(pVDesc
->Name
);
4988 if(This
->impltypelist
&&
4989 (This
->TypeAttr
.typekind
==TKIND_INTERFACE
|| This
->TypeAttr
.typekind
==TKIND_DISPATCH
)) {
4990 /* recursive search */
4993 result
=ITypeInfo_GetRefTypeInfo(iface
, This
->impltypelist
->hRef
,
4995 if(SUCCEEDED(result
))
4997 result
=ITypeInfo_GetNames(pTInfo
, memid
, rgBstrNames
, cMaxNames
, pcNames
);
4998 ITypeInfo_Release(pTInfo
);
5001 WARN("Could not search inherited interface!\n");
5005 WARN("no names found\n");
5008 return TYPE_E_ELEMENTNOTFOUND
;
5015 /* ITypeInfo::GetRefTypeOfImplType
5017 * If a type description describes a COM class, it retrieves the type
5018 * description of the implemented interface types. For an interface,
5019 * GetRefTypeOfImplType returns the type information for inherited interfaces,
5023 static HRESULT WINAPI
ITypeInfo_fnGetRefTypeOfImplType(
5028 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
5031 const TLBImplType
*pImpl
= This
->impltypelist
;
5033 TRACE("(%p) index %d\n", This
, index
);
5034 if (TRACE_ON(ole
)) dump_TypeInfo(This
);
5038 /* only valid on dual interfaces;
5039 retrieve the associated TKIND_INTERFACE handle for the current TKIND_DISPATCH
5041 if( This
->TypeAttr
.typekind
!= TKIND_DISPATCH
) return E_INVALIDARG
;
5043 if (This
->TypeAttr
.wTypeFlags
& TYPEFLAG_FDISPATCHABLE
&&
5044 This
->TypeAttr
.wTypeFlags
& TYPEFLAG_FDUAL
)
5050 hr
= TYPE_E_ELEMENTNOTFOUND
;
5053 else if(index
== 0 && This
->TypeAttr
.typekind
== TKIND_DISPATCH
)
5055 /* All TKIND_DISPATCHs are made to look like they inherit from IDispatch */
5056 *pRefType
= This
->pTypeLib
->dispatch_href
;
5060 /* get element n from linked list */
5061 for(i
=0; pImpl
&& i
<index
; i
++)
5063 pImpl
= pImpl
->next
;
5067 *pRefType
= pImpl
->hRef
;
5069 hr
= TYPE_E_ELEMENTNOTFOUND
;
5075 TRACE("SUCCESS -- hRef = 0x%08x\n", *pRefType
);
5077 TRACE("FAILURE -- hresult = 0x%08x\n", hr
);
5083 /* ITypeInfo::GetImplTypeFlags
5085 * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface
5086 * or base interface in a type description.
5088 static HRESULT WINAPI
ITypeInfo_fnGetImplTypeFlags( ITypeInfo2
*iface
,
5089 UINT index
, INT
*pImplTypeFlags
)
5091 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
5095 TRACE("(%p) index %d\n", This
, index
);
5096 for(i
=0, pImpl
=This
->impltypelist
; i
<index
&& pImpl
;
5097 i
++, pImpl
=pImpl
->next
)
5099 if(i
==index
&& pImpl
){
5100 *pImplTypeFlags
=pImpl
->implflags
;
5104 return TYPE_E_ELEMENTNOTFOUND
;
5108 * Maps between member names and member IDs, and parameter names and
5111 static HRESULT WINAPI
ITypeInfo_fnGetIDsOfNames( ITypeInfo2
*iface
,
5112 LPOLESTR
*rgszNames
, UINT cNames
, MEMBERID
*pMemId
)
5114 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
5115 const TLBFuncDesc
*pFDesc
;
5116 const TLBVarDesc
*pVDesc
;
5120 TRACE("(%p) Name %s cNames %d\n", This
, debugstr_w(*rgszNames
),
5123 /* init out parameters in case of failure */
5124 for (i
= 0; i
< cNames
; i
++)
5125 pMemId
[i
] = MEMBERID_NIL
;
5127 for(pFDesc
=This
->funclist
; pFDesc
; pFDesc
=pFDesc
->next
) {
5129 if(!lstrcmpiW(*rgszNames
, pFDesc
->Name
)) {
5130 if(cNames
) *pMemId
=pFDesc
->funcdesc
.memid
;
5131 for(i
=1; i
< cNames
; i
++){
5132 for(j
=0; j
<pFDesc
->funcdesc
.cParams
; j
++)
5133 if(!lstrcmpiW(rgszNames
[i
],pFDesc
->pParamDesc
[j
].Name
))
5135 if( j
<pFDesc
->funcdesc
.cParams
)
5138 ret
=DISP_E_UNKNOWNNAME
;
5140 TRACE("-- 0x%08x\n", ret
);
5144 for(pVDesc
=This
->varlist
; pVDesc
; pVDesc
=pVDesc
->next
) {
5145 if(!lstrcmpiW(*rgszNames
, pVDesc
->Name
)) {
5146 if(cNames
) *pMemId
=pVDesc
->vardesc
.memid
;
5150 /* not found, see if it can be found in an inherited interface */
5151 if(This
->impltypelist
) {
5152 /* recursive search */
5154 ret
=ITypeInfo_GetRefTypeInfo(iface
,
5155 This
->impltypelist
->hRef
, &pTInfo
);
5157 ret
=ITypeInfo_GetIDsOfNames(pTInfo
, rgszNames
, cNames
, pMemId
);
5158 ITypeInfo_Release(pTInfo
);
5161 WARN("Could not search inherited interface!\n");
5163 WARN("no names found\n");
5164 return DISP_E_UNKNOWNNAME
;
5167 /* ITypeInfo::Invoke
5169 * Invokes a method, or accesses a property of an object, that implements the
5170 * interface described by the type description.
5173 _invoke(FARPROC func
,CALLCONV callconv
, int nrargs
, DWORD
*args
) {
5176 if (TRACE_ON(ole
)) {
5178 TRACE("Calling %p(",func
);
5179 for (i
=0;i
<nrargs
;i
++) TRACE("%08x,",args
[i
]);
5191 res
= func(args
[0]);
5194 res
= func(args
[0],args
[1]);
5197 res
= func(args
[0],args
[1],args
[2]);
5200 res
= func(args
[0],args
[1],args
[2],args
[3]);
5203 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4]);
5206 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5]);
5209 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6]);
5212 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7]);
5215 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8]);
5218 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9]);
5221 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10]);
5224 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10],args
[11]);
5227 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],args
[12]);
5230 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],args
[12],args
[13]);
5233 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],args
[12],args
[13],args
[14]);
5236 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],args
[12],args
[13],args
[14],args
[15]);
5239 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],args
[12],args
[13],args
[14],args
[15],args
[16]);
5242 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],args
[12],args
[13],args
[14],args
[15],args
[16],args
[17]);
5245 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],args
[12],args
[13],args
[14],args
[15],args
[16],args
[17],args
[18]);
5248 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],args
[12],args
[13],args
[14],args
[15],args
[16],args
[17],args
[18],args
[19]);
5251 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],args
[12],args
[13],args
[14],args
[15],args
[16],args
[17],args
[18],args
[19],args
[20]);
5254 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],args
[12],args
[13],args
[14],args
[15],args
[16],args
[17],args
[18],args
[19],args
[20],args
[21]);
5257 res
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],args
[12],args
[13],args
[14],args
[15],args
[16],args
[17],args
[18],args
[19],args
[20],args
[21],args
[22]);
5260 FIXME("unsupported number of arguments %d in stdcall\n",nrargs
);
5266 FIXME("unsupported calling convention %d\n",callconv
);
5270 TRACE("returns %08x\n",res
);
5274 extern int _argsize(DWORD vt
);
5276 static HRESULT
userdefined_to_variantvt(ITypeInfo
*tinfo
, const TYPEDESC
*tdesc
, VARTYPE
*vt
)
5279 ITypeInfo
*tinfo2
= NULL
;
5280 TYPEATTR
*tattr
= NULL
;
5282 hr
= ITypeInfo_GetRefTypeInfo(tinfo
, tdesc
->u
.hreftype
, &tinfo2
);
5285 ERR("Could not get typeinfo of hreftype %x for VT_USERDEFINED, "
5287 tdesc
->u
.hreftype
, hr
);
5290 hr
= ITypeInfo_GetTypeAttr(tinfo2
, &tattr
);
5293 ERR("ITypeInfo_GetTypeAttr failed, hr = 0x%08x\n", hr
);
5294 ITypeInfo_Release(tinfo2
);
5298 switch (tattr
->typekind
)
5305 tdesc
= &tattr
->tdescAlias
;
5306 hr
= typedescvt_to_variantvt(tinfo2
, &tattr
->tdescAlias
, vt
);
5309 case TKIND_INTERFACE
:
5310 if (IsEqualIID(&IID_IDispatch
, &tattr
->guid
))
5316 case TKIND_DISPATCH
:
5325 FIXME("TKIND_RECORD unhandled.\n");
5330 FIXME("TKIND_UNION unhandled.\n");
5335 FIXME("TKIND %d unhandled.\n",tattr
->typekind
);
5339 ITypeInfo_ReleaseTypeAttr(tinfo2
, tattr
);
5340 ITypeInfo_Release(tinfo2
);
5344 static HRESULT
typedescvt_to_variantvt(ITypeInfo
*tinfo
, const TYPEDESC
*tdesc
, VARTYPE
*vt
)
5348 /* enforce only one level of pointer indirection */
5349 if (!(*vt
& VT_BYREF
) && !(*vt
& VT_ARRAY
) && (tdesc
->vt
== VT_PTR
))
5351 tdesc
= tdesc
->u
.lptdesc
;
5353 /* munch VT_PTR -> VT_USERDEFINED(interface) into VT_UNKNOWN or
5354 * VT_DISPATCH and VT_PTR -> VT_PTR -> VT_USERDEFINED(interface) into
5355 * VT_BYREF|VT_DISPATCH or VT_BYREF|VT_UNKNOWN */
5356 if ((tdesc
->vt
== VT_USERDEFINED
) ||
5357 ((tdesc
->vt
== VT_PTR
) && (tdesc
->u
.lptdesc
->vt
== VT_USERDEFINED
)))
5359 VARTYPE vt_userdefined
= 0;
5360 const TYPEDESC
*tdesc_userdefined
= tdesc
;
5361 if (tdesc
->vt
== VT_PTR
)
5363 vt_userdefined
= VT_BYREF
;
5364 tdesc_userdefined
= tdesc
->u
.lptdesc
;
5366 hr
= userdefined_to_variantvt(tinfo
, tdesc_userdefined
, &vt_userdefined
);
5368 (((vt_userdefined
& VT_TYPEMASK
) == VT_UNKNOWN
) ||
5369 ((vt_userdefined
& VT_TYPEMASK
) == VT_DISPATCH
)))
5371 *vt
|= vt_userdefined
;
5383 case VT_USERDEFINED
:
5384 hr
= userdefined_to_variantvt(tinfo
, tdesc
, vt
);
5391 ERR("cannot convert type %d into variant VT\n", tdesc
->vt
);
5392 hr
= DISP_E_BADVARTYPE
;
5396 hr
= typedescvt_to_variantvt(tinfo
, tdesc
->u
.lptdesc
, vt
);
5405 /***********************************************************************
5406 * DispCallFunc (OLEAUT32.@)
5408 * Invokes a function of the specifed calling convention, passing the
5409 * specified arguments and returns the result.
5412 * pvInstance [I] Optional pointer to the instance whose function to invoke.
5413 * oVft [I] The offset in the vtable. See notes.
5414 * cc [I] Calling convention of the function to call.
5415 * vtReturn [I] The return type of the function.
5416 * cActuals [I] Number of parameters.
5417 * prgvt [I] The types of the parameters to pass. This is used for sizing only.
5418 * prgpvarg [I] The arguments to pass.
5419 * pvargResult [O] The return value of the function. Can be NULL.
5423 * Failure: HRESULT code.
5426 * The HRESULT return value of this function is not affected by the return
5427 * value of the user supplied function, which is returned in pvargResult.
5429 * If pvInstance is NULL then a non-object function is to be called and oVft
5430 * is the address of the function to call.
5432 * The cc parameter can be one of the following values:
5445 void* pvInstance
, ULONG_PTR oVft
, CALLCONV cc
, VARTYPE vtReturn
, UINT cActuals
,
5446 VARTYPE
* prgvt
, VARIANTARG
** prgpvarg
, VARIANT
* pvargResult
)
5448 int i
, argsize
, argspos
;
5452 TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
5453 pvInstance
, oVft
, cc
, vtReturn
, cActuals
, prgvt
, prgpvarg
,
5454 pvargResult
, V_VT(pvargResult
));
5458 argsize
++; /* for This pointer */
5460 for (i
=0;i
<cActuals
;i
++)
5462 TRACE("arg %d: type %d, size %d\n",i
,prgvt
[i
],_argsize(prgvt
[i
]));
5463 dump_Variant(prgpvarg
[i
]);
5464 argsize
+= _argsize(prgvt
[i
]);
5466 args
= HeapAlloc(GetProcessHeap(),0,sizeof(DWORD
)*argsize
);
5471 args
[0] = (DWORD
)pvInstance
; /* the This pointer is always the first parameter */
5475 for (i
=0;i
<cActuals
;i
++)
5477 VARIANT
*arg
= prgpvarg
[i
];
5478 TRACE("Storing arg %d (%d as %d)\n",i
,V_VT(arg
),prgvt
[i
]);
5479 if (prgvt
[i
] == VT_VARIANT
)
5480 memcpy(&args
[argspos
], arg
, _argsize(prgvt
[i
]) * sizeof(DWORD
));
5482 memcpy(&args
[argspos
], &V_NONE(arg
), _argsize(prgvt
[i
]) * sizeof(DWORD
));
5483 argspos
+= _argsize(prgvt
[i
]);
5488 FARPROC
*vtable
= *(FARPROC
**)pvInstance
;
5489 hres
= _invoke(vtable
[oVft
/sizeof(void *)], cc
, argsize
, args
);
5492 /* if we aren't invoking an object then the function pointer is stored
5494 hres
= _invoke((FARPROC
)oVft
, cc
, argsize
, args
);
5496 if (pvargResult
&& (vtReturn
!= VT_EMPTY
))
5498 TRACE("Method returned 0x%08x\n",hres
);
5499 V_VT(pvargResult
) = vtReturn
;
5500 V_UI4(pvargResult
) = hres
;
5503 HeapFree(GetProcessHeap(),0,args
);
5507 #define INVBUF_ELEMENT_SIZE \
5508 (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *) + sizeof(VARTYPE))
5509 #define INVBUF_GET_ARG_ARRAY(buffer, params) \
5510 ((VARIANTARG *)(buffer))
5511 #define INVBUF_GET_MISSING_ARG_ARRAY(buffer, params) \
5512 ((VARIANTARG *)((char *)(buffer) + sizeof(VARIANTARG) * (params)))
5513 #define INVBUF_GET_ARG_PTR_ARRAY(buffer, params) \
5514 ((VARIANTARG **)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG)) * (params)))
5515 #define INVBUF_GET_ARG_TYPE_ARRAY(buffer, params) \
5516 ((VARTYPE *)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *)) * (params)))
5518 static HRESULT WINAPI
ITypeInfo_fnInvoke(
5523 DISPPARAMS
*pDispParams
,
5524 VARIANT
*pVarResult
,
5525 EXCEPINFO
*pExcepInfo
,
5528 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
5530 unsigned int var_index
;
5533 const TLBFuncDesc
*pFuncInfo
;
5535 TRACE("(%p)(%p,id=%d,flags=0x%08x,%p,%p,%p,%p)\n",
5536 This
,pIUnk
,memid
,wFlags
,pDispParams
,pVarResult
,pExcepInfo
,pArgErr
5541 ERR("NULL pDispParams not allowed\n");
5542 return E_INVALIDARG
;
5545 dump_DispParms(pDispParams
);
5547 if (pDispParams
->cNamedArgs
> pDispParams
->cArgs
)
5549 ERR("named argument array cannot be bigger than argument array (%d/%d)\n",
5550 pDispParams
->cNamedArgs
, pDispParams
->cArgs
);
5551 return E_INVALIDARG
;
5554 /* we do this instead of using GetFuncDesc since it will return a fake
5555 * FUNCDESC for dispinterfaces and we want the real function description */
5556 for (pFuncInfo
= This
->funclist
; pFuncInfo
; pFuncInfo
=pFuncInfo
->next
)
5557 if ((memid
== pFuncInfo
->funcdesc
.memid
) &&
5558 (wFlags
& pFuncInfo
->funcdesc
.invkind
))
5562 const FUNCDESC
*func_desc
= &pFuncInfo
->funcdesc
;
5566 TRACE("invoking:\n");
5567 dump_TLBFuncDescOne(pFuncInfo
);
5570 switch (func_desc
->funckind
) {
5571 case FUNC_PUREVIRTUAL
:
5572 case FUNC_VIRTUAL
: {
5573 void *buffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, INVBUF_ELEMENT_SIZE
* func_desc
->cParams
);
5575 VARIANT retval
; /* pointer for storing byref retvals in */
5576 VARIANTARG
**prgpvarg
= INVBUF_GET_ARG_PTR_ARRAY(buffer
, func_desc
->cParams
);
5577 VARIANTARG
*rgvarg
= INVBUF_GET_ARG_ARRAY(buffer
, func_desc
->cParams
);
5578 VARTYPE
*rgvt
= INVBUF_GET_ARG_TYPE_ARRAY(buffer
, func_desc
->cParams
);
5579 UINT cNamedArgs
= pDispParams
->cNamedArgs
;
5580 DISPID
*rgdispidNamedArgs
= pDispParams
->rgdispidNamedArgs
;
5584 if (func_desc
->invkind
& (INVOKE_PROPERTYPUT
|INVOKE_PROPERTYPUTREF
))
5586 if (!cNamedArgs
|| (rgdispidNamedArgs
[0] != DISPID_PROPERTYPUT
))
5588 ERR("first named arg for property put invocation must be DISPID_PROPERTYPUT\n");
5589 hres
= DISP_E_PARAMNOTFOUND
;
5592 /* ignore the DISPID_PROPERTYPUT named argument from now on */
5594 rgdispidNamedArgs
++;
5597 if (func_desc
->cParamsOpt
< 0 && cNamedArgs
)
5599 ERR("functions with the vararg attribute do not support named arguments\n");
5600 hres
= DISP_E_NONAMEDARGS
;
5604 for (i
= 0; i
< func_desc
->cParams
; i
++)
5606 TYPEDESC
*tdesc
= &func_desc
->lprgelemdescParam
[i
].tdesc
;
5607 hres
= typedescvt_to_variantvt((ITypeInfo
*)iface
, tdesc
, &rgvt
[i
]);
5612 TRACE("changing args\n");
5613 for (i
= 0; i
< func_desc
->cParams
; i
++)
5615 USHORT wParamFlags
= func_desc
->lprgelemdescParam
[i
].u
.paramdesc
.wParamFlags
;
5616 VARIANTARG
*src_arg
;
5622 for (j
= 0; j
< cNamedArgs
; j
++)
5623 if (rgdispidNamedArgs
[j
] == i
)
5625 src_arg
= &pDispParams
->rgvarg
[j
];
5630 src_arg
= i
< pDispParams
->cArgs
? &pDispParams
->rgvarg
[pDispParams
->cArgs
- 1 - i
] : NULL
;
5632 if (wParamFlags
& PARAMFLAG_FRETVAL
)
5634 /* under most conditions the caller is not allowed to
5635 * pass in a dispparam arg in the index of what would be
5636 * the retval parameter. however, there is an exception
5637 * where the extra parameter is used in an extra
5638 * IDispatch::Invoke below */
5639 if ((i
< pDispParams
->cArgs
) &&
5640 ((func_desc
->cParams
!= 1) || !pVarResult
||
5641 !(func_desc
->invkind
& INVOKE_PROPERTYGET
)))
5643 hres
= DISP_E_BADPARAMCOUNT
;
5647 /* note: this check is placed so that if the caller passes
5648 * in a VARIANTARG for the retval we just ignore it, like
5650 if (i
== func_desc
->cParams
- 1)
5653 arg
= prgpvarg
[i
] = &rgvarg
[i
];
5654 memset(arg
, 0, sizeof(*arg
));
5655 V_VT(arg
) = rgvt
[i
];
5656 memset(&retval
, 0, sizeof(retval
));
5657 V_BYREF(arg
) = &retval
;
5661 ERR("[retval] parameter must be the last parameter of the method (%d/%d)\n", i
, func_desc
->cParams
);
5662 hres
= E_UNEXPECTED
;
5668 dump_Variant(src_arg
);
5670 if (rgvt
[i
] == VT_VARIANT
)
5671 hres
= VariantCopy(&rgvarg
[i
], src_arg
);
5672 else if (rgvt
[i
] == (VT_VARIANT
| VT_BYREF
))
5674 if (rgvt
[i
] == V_VT(src_arg
))
5675 V_VARIANTREF(&rgvarg
[i
]) = V_VARIANTREF(src_arg
);
5678 VARIANTARG
*missing_arg
= INVBUF_GET_MISSING_ARG_ARRAY(buffer
, func_desc
->cParams
);
5679 hres
= VariantCopy(&missing_arg
[i
], src_arg
);
5680 V_VARIANTREF(&rgvarg
[i
]) = &missing_arg
[i
];
5682 V_VT(&rgvarg
[i
]) = rgvt
[i
];
5684 else if (rgvt
[i
] == (VT_VARIANT
| VT_ARRAY
) && func_desc
->cParamsOpt
< 0 && i
== func_desc
->cParams
-1)
5687 SAFEARRAYBOUND bound
;
5691 bound
.cElements
= pDispParams
->cArgs
-i
;
5692 if (!(a
= SafeArrayCreate(VT_VARIANT
, 1, &bound
)))
5694 ERR("SafeArrayCreate failed\n");
5697 hres
= SafeArrayAccessData(a
, (LPVOID
)&v
);
5700 ERR("SafeArrayAccessData failed with %x\n", hres
);
5703 for (j
= 0; j
< bound
.cElements
; j
++)
5704 VariantCopy(&v
[j
], &pDispParams
->rgvarg
[pDispParams
->cArgs
- 1 - i
- j
]);
5705 hres
= SafeArrayUnaccessData(a
);
5708 ERR("SafeArrayUnaccessData failed with %x\n", hres
);
5711 V_ARRAY(&rgvarg
[i
]) = a
;
5712 V_VT(&rgvarg
[i
]) = rgvt
[i
];
5714 else if ((rgvt
[i
] & VT_BYREF
) && !V_ISBYREF(src_arg
))
5716 VARIANTARG
*missing_arg
= INVBUF_GET_MISSING_ARG_ARRAY(buffer
, func_desc
->cParams
);
5717 V_VT(&missing_arg
[i
]) = V_VT(src_arg
);
5718 hres
= VariantChangeType(&missing_arg
[i
], src_arg
, 0, rgvt
[i
] & ~VT_BYREF
);
5719 V_BYREF(&rgvarg
[i
]) = &V_NONE(&missing_arg
[i
]);
5720 V_VT(&rgvarg
[i
]) = rgvt
[i
];
5722 else if ((rgvt
[i
] & VT_BYREF
) && (rgvt
[i
] == V_VT(src_arg
)))
5724 V_BYREF(&rgvarg
[i
]) = V_BYREF(src_arg
);
5725 V_VT(&rgvarg
[i
]) = rgvt
[i
];
5729 /* FIXME: this doesn't work for VT_BYREF arguments if
5730 * they are not the same type as in the paramdesc */
5731 V_VT(&rgvarg
[i
]) = V_VT(src_arg
);
5732 hres
= VariantChangeType(&rgvarg
[i
], src_arg
, 0, rgvt
[i
]);
5733 V_VT(&rgvarg
[i
]) = rgvt
[i
];
5738 ERR("failed to convert param %d to %s%s from %s%s\n", i
,
5739 debugstr_vt(rgvt
[i
]), debugstr_vf(rgvt
[i
]),
5740 debugstr_VT(src_arg
), debugstr_VF(src_arg
));
5743 prgpvarg
[i
] = &rgvarg
[i
];
5745 else if (wParamFlags
& PARAMFLAG_FOPT
)
5748 arg
= prgpvarg
[i
] = &rgvarg
[i
];
5749 if (wParamFlags
& PARAMFLAG_FHASDEFAULT
)
5751 hres
= VariantCopy(arg
, &func_desc
->lprgelemdescParam
[i
].u
.paramdesc
.pparamdescex
->varDefaultValue
);
5757 VARIANTARG
*missing_arg
;
5758 /* if the function wants a pointer to a variant then
5759 * set that up, otherwise just pass the VT_ERROR in
5760 * the argument by value */
5761 if (rgvt
[i
] & VT_BYREF
)
5763 missing_arg
= INVBUF_GET_MISSING_ARG_ARRAY(buffer
, func_desc
->cParams
) + i
;
5764 V_VT(arg
) = VT_VARIANT
| VT_BYREF
;
5765 V_VARIANTREF(arg
) = missing_arg
;
5769 V_VT(missing_arg
) = VT_ERROR
;
5770 V_ERROR(missing_arg
) = DISP_E_PARAMNOTFOUND
;
5775 hres
= DISP_E_BADPARAMCOUNT
;
5779 if (FAILED(hres
)) goto func_fail
; /* FIXME: we don't free changed types here */
5781 /* VT_VOID is a special case for return types, so it is not
5782 * handled in the general function */
5783 if (func_desc
->elemdescFunc
.tdesc
.vt
== VT_VOID
)
5784 V_VT(&varresult
) = VT_EMPTY
;
5787 V_VT(&varresult
) = 0;
5788 hres
= typedescvt_to_variantvt((ITypeInfo
*)iface
, &func_desc
->elemdescFunc
.tdesc
, &V_VT(&varresult
));
5789 if (FAILED(hres
)) goto func_fail
; /* FIXME: we don't free changed types here */
5792 hres
= DispCallFunc(pIUnk
, func_desc
->oVft
, func_desc
->callconv
,
5793 V_VT(&varresult
), func_desc
->cParams
, rgvt
,
5794 prgpvarg
, &varresult
);
5796 for (i
= 0; i
< func_desc
->cParams
; i
++)
5798 USHORT wParamFlags
= func_desc
->lprgelemdescParam
[i
].u
.paramdesc
.wParamFlags
;
5799 if (wParamFlags
& PARAMFLAG_FRETVAL
)
5803 TRACE("[retval] value: ");
5804 dump_Variant(prgpvarg
[i
]);
5809 VariantInit(pVarResult
);
5810 /* deref return value */
5811 hres
= VariantCopyInd(pVarResult
, prgpvarg
[i
]);
5814 /* free data stored in varresult. Note that
5815 * VariantClear doesn't do what we want because we are
5816 * working with byref types. */
5817 /* FIXME: clear safearrays, bstrs, records and
5818 * variants here too */
5819 if ((V_VT(prgpvarg
[i
]) == (VT_UNKNOWN
| VT_BYREF
)) ||
5820 (V_VT(prgpvarg
[i
]) == (VT_DISPATCH
| VT_BYREF
)))
5822 if(*V_UNKNOWNREF(prgpvarg
[i
]))
5823 IUnknown_Release(*V_UNKNOWNREF(prgpvarg
[i
]));
5827 else if (i
< pDispParams
->cArgs
)
5829 if (wParamFlags
& PARAMFLAG_FOUT
)
5831 VARIANTARG
*arg
= &pDispParams
->rgvarg
[pDispParams
->cArgs
- 1 - i
];
5833 if ((rgvt
[i
] == VT_BYREF
) && (V_VT(arg
) != VT_BYREF
))
5834 hres
= VariantChangeType(arg
, &rgvarg
[i
], 0, V_VT(arg
));
5838 ERR("failed to convert param %d to vt %d\n", i
,
5839 V_VT(&pDispParams
->rgvarg
[pDispParams
->cArgs
- 1 - i
]));
5843 else if (V_VT(prgpvarg
[i
]) == (VT_VARIANT
| VT_ARRAY
) &&
5844 func_desc
->cParamsOpt
< 0 &&
5845 i
== func_desc
->cParams
-1)
5847 SAFEARRAY
*a
= V_ARRAY(prgpvarg
[i
]);
5850 hres
= SafeArrayGetUBound(a
, 1, &ubound
);
5853 ERR("SafeArrayGetUBound failed with %x\n", hres
);
5856 hres
= SafeArrayAccessData(a
, (LPVOID
)&v
);
5859 ERR("SafeArrayAccessData failed with %x\n", hres
);
5862 for (j
= 0; j
<= ubound
; j
++)
5863 VariantClear(&v
[j
]);
5864 hres
= SafeArrayUnaccessData(a
);
5867 ERR("SafeArrayUnaccessData failed with %x\n", hres
);
5871 VariantClear(&rgvarg
[i
]);
5873 else if (wParamFlags
& PARAMFLAG_FOPT
)
5875 if (wParamFlags
& PARAMFLAG_FHASDEFAULT
)
5876 VariantClear(&rgvarg
[i
]);
5880 if ((V_VT(&varresult
) == VT_ERROR
) && FAILED(V_ERROR(&varresult
)))
5882 WARN("invoked function failed with error 0x%08x\n", V_ERROR(&varresult
));
5883 hres
= DISP_E_EXCEPTION
;
5886 IErrorInfo
*pErrorInfo
;
5887 pExcepInfo
->scode
= V_ERROR(&varresult
);
5888 if (GetErrorInfo(0, &pErrorInfo
) == S_OK
)
5890 IErrorInfo_GetDescription(pErrorInfo
, &pExcepInfo
->bstrDescription
);
5891 IErrorInfo_GetHelpFile(pErrorInfo
, &pExcepInfo
->bstrHelpFile
);
5892 IErrorInfo_GetSource(pErrorInfo
, &pExcepInfo
->bstrSource
);
5893 IErrorInfo_GetHelpContext(pErrorInfo
, &pExcepInfo
->dwHelpContext
);
5895 IErrorInfo_Release(pErrorInfo
);
5899 if (V_VT(&varresult
) != VT_ERROR
)
5901 TRACE("varresult value: ");
5902 dump_Variant(&varresult
);
5906 VariantClear(pVarResult
);
5907 *pVarResult
= varresult
;
5910 VariantClear(&varresult
);
5913 if (SUCCEEDED(hres
) && pVarResult
&& (func_desc
->cParams
== 1) &&
5914 (func_desc
->invkind
& INVOKE_PROPERTYGET
) &&
5915 (func_desc
->lprgelemdescParam
[0].u
.paramdesc
.wParamFlags
& PARAMFLAG_FRETVAL
) &&
5916 (pDispParams
->cArgs
!= 0))
5918 if (V_VT(pVarResult
) == VT_DISPATCH
)
5920 IDispatch
*pDispatch
= V_DISPATCH(pVarResult
);
5921 /* Note: not VariantClear; we still need the dispatch
5922 * pointer to be valid */
5923 VariantInit(pVarResult
);
5924 hres
= IDispatch_Invoke(pDispatch
, DISPID_VALUE
, &IID_NULL
,
5925 GetSystemDefaultLCID(), INVOKE_PROPERTYGET
,
5926 pDispParams
, pVarResult
, pExcepInfo
, pArgErr
);
5927 IDispatch_Release(pDispatch
);
5931 VariantClear(pVarResult
);
5932 hres
= DISP_E_NOTACOLLECTION
;
5937 HeapFree(GetProcessHeap(), 0, buffer
);
5940 case FUNC_DISPATCH
: {
5943 hres
= IUnknown_QueryInterface((LPUNKNOWN
)pIUnk
,&IID_IDispatch
,(LPVOID
*)&disp
);
5944 if (SUCCEEDED(hres
)) {
5945 FIXME("Calling Invoke in IDispatch iface. untested!\n");
5946 hres
= IDispatch_Invoke(
5947 disp
,memid
,&IID_NULL
,LOCALE_USER_DEFAULT
,wFlags
,pDispParams
,
5948 pVarResult
,pExcepInfo
,pArgErr
5951 FIXME("IDispatch::Invoke failed with %08x. (Could be not a real error?)\n", hres
);
5952 IDispatch_Release(disp
);
5954 FIXME("FUNC_DISPATCH used on object without IDispatch iface?\n");
5958 FIXME("Unknown function invocation type %d\n", func_desc
->funckind
);
5963 TRACE("-- 0x%08x\n", hres
);
5966 } else if(SUCCEEDED(hres
= ITypeInfo2_GetVarIndexOfMemId(iface
, memid
, &var_index
))) {
5969 hres
= ITypeInfo2_GetVarDesc(iface
, var_index
, &var_desc
);
5970 if(FAILED(hres
)) return hres
;
5972 FIXME("varseek: Found memid, but variable-based invoking not supported\n");
5973 dump_VARDESC(var_desc
);
5974 ITypeInfo2_ReleaseVarDesc(iface
, var_desc
);
5978 /* not found, look for it in inherited interfaces */
5979 ITypeInfo2_GetTypeKind(iface
, &type_kind
);
5980 if(type_kind
== TKIND_INTERFACE
|| type_kind
== TKIND_DISPATCH
) {
5981 if(This
->impltypelist
) {
5982 /* recursive search */
5984 hres
= ITypeInfo_GetRefTypeInfo(iface
, This
->impltypelist
->hRef
, &pTInfo
);
5985 if(SUCCEEDED(hres
)){
5986 hres
= ITypeInfo_Invoke(pTInfo
,pIUnk
,memid
,wFlags
,pDispParams
,pVarResult
,pExcepInfo
,pArgErr
);
5987 ITypeInfo_Release(pTInfo
);
5990 WARN("Could not search inherited interface!\n");
5993 ERR("did not find member id %d, flags 0x%x!\n", memid
, wFlags
);
5994 return DISP_E_MEMBERNOTFOUND
;
5997 /* ITypeInfo::GetDocumentation
5999 * Retrieves the documentation string, the complete Help file name and path,
6000 * and the context ID for the Help topic for a specified type description.
6002 * (Can be tested by the Visual Basic Editor in Word for instance.)
6004 static HRESULT WINAPI
ITypeInfo_fnGetDocumentation( ITypeInfo2
*iface
,
6005 MEMBERID memid
, BSTR
*pBstrName
, BSTR
*pBstrDocString
,
6006 DWORD
*pdwHelpContext
, BSTR
*pBstrHelpFile
)
6008 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6009 const TLBFuncDesc
*pFDesc
;
6010 const TLBVarDesc
*pVDesc
;
6011 TRACE("(%p) memid %d Name(%p) DocString(%p)"
6012 " HelpContext(%p) HelpFile(%p)\n",
6013 This
, memid
, pBstrName
, pBstrDocString
, pdwHelpContext
, pBstrHelpFile
);
6014 if(memid
==MEMBERID_NIL
){ /* documentation for the typeinfo */
6016 *pBstrName
=SysAllocString(This
->Name
);
6018 *pBstrDocString
=SysAllocString(This
->DocString
);
6020 *pdwHelpContext
=This
->dwHelpContext
;
6022 *pBstrHelpFile
=SysAllocString(This
->DocString
);/* FIXME */
6024 }else {/* for a member */
6025 for(pFDesc
=This
->funclist
; pFDesc
; pFDesc
=pFDesc
->next
)
6026 if(pFDesc
->funcdesc
.memid
==memid
){
6028 *pBstrName
= SysAllocString(pFDesc
->Name
);
6030 *pBstrDocString
=SysAllocString(pFDesc
->HelpString
);
6032 *pdwHelpContext
=pFDesc
->helpcontext
;
6035 for(pVDesc
=This
->varlist
; pVDesc
; pVDesc
=pVDesc
->next
)
6036 if(pVDesc
->vardesc
.memid
==memid
){
6038 *pBstrName
= SysAllocString(pVDesc
->Name
);
6040 *pBstrDocString
=SysAllocString(pVDesc
->HelpString
);
6042 *pdwHelpContext
=pVDesc
->HelpContext
;
6047 if(This
->impltypelist
&&
6048 (This
->TypeAttr
.typekind
==TKIND_INTERFACE
|| This
->TypeAttr
.typekind
==TKIND_DISPATCH
)) {
6049 /* recursive search */
6052 result
= ITypeInfo_GetRefTypeInfo(iface
, This
->impltypelist
->hRef
,
6054 if(SUCCEEDED(result
)) {
6055 result
= ITypeInfo_GetDocumentation(pTInfo
, memid
, pBstrName
,
6056 pBstrDocString
, pdwHelpContext
, pBstrHelpFile
);
6057 ITypeInfo_Release(pTInfo
);
6060 WARN("Could not search inherited interface!\n");
6063 WARN("member %d not found\n", memid
);
6064 return TYPE_E_ELEMENTNOTFOUND
;
6067 /* ITypeInfo::GetDllEntry
6069 * Retrieves a description or specification of an entry point for a function
6072 static HRESULT WINAPI
ITypeInfo_fnGetDllEntry( ITypeInfo2
*iface
, MEMBERID memid
,
6073 INVOKEKIND invKind
, BSTR
*pBstrDllName
, BSTR
*pBstrName
,
6076 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6077 const TLBFuncDesc
*pFDesc
;
6079 TRACE("(%p)->(memid %x, %d, %p, %p, %p)\n", This
, memid
, invKind
, pBstrDllName
, pBstrName
, pwOrdinal
);
6081 if (pBstrDllName
) *pBstrDllName
= NULL
;
6082 if (pBstrName
) *pBstrName
= NULL
;
6083 if (pwOrdinal
) *pwOrdinal
= 0;
6085 if (This
->TypeAttr
.typekind
!= TKIND_MODULE
)
6086 return TYPE_E_BADMODULEKIND
;
6088 for(pFDesc
=This
->funclist
; pFDesc
; pFDesc
=pFDesc
->next
)
6089 if(pFDesc
->funcdesc
.memid
==memid
){
6090 dump_TypeInfo(This
);
6092 dump_TLBFuncDescOne(pFDesc
);
6095 *pBstrDllName
= SysAllocString(This
->DllName
);
6097 if (HIWORD(pFDesc
->Entry
) && (pFDesc
->Entry
!= (void*)-1)) {
6099 *pBstrName
= SysAllocString(pFDesc
->Entry
);
6107 *pwOrdinal
= (DWORD
)pFDesc
->Entry
;
6110 return TYPE_E_ELEMENTNOTFOUND
;
6113 /* internal function to make the inherited interfaces' methods appear
6114 * part of the interface */
6115 static HRESULT
ITypeInfoImpl_GetDispatchRefTypeInfo( ITypeInfo
*iface
,
6116 HREFTYPE
*hRefType
, ITypeInfo
**ppTInfo
)
6118 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6121 TRACE("%p, 0x%x\n", iface
, *hRefType
);
6123 if (This
->impltypelist
&& (*hRefType
& DISPATCH_HREF_MASK
))
6125 ITypeInfo
*pSubTypeInfo
;
6127 hr
= ITypeInfo_GetRefTypeInfo(iface
, This
->impltypelist
->hRef
, &pSubTypeInfo
);
6131 hr
= ITypeInfoImpl_GetDispatchRefTypeInfo(pSubTypeInfo
,
6133 ITypeInfo_Release(pSubTypeInfo
);
6137 *hRefType
-= DISPATCH_HREF_OFFSET
;
6139 if (!(*hRefType
& DISPATCH_HREF_MASK
))
6140 return ITypeInfo_GetRefTypeInfo(iface
, *hRefType
, ppTInfo
);
6145 /* ITypeInfo::GetRefTypeInfo
6147 * If a type description references other type descriptions, it retrieves
6148 * the referenced type descriptions.
6150 static HRESULT WINAPI
ITypeInfo_fnGetRefTypeInfo(
6153 ITypeInfo
**ppTInfo
)
6155 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6156 HRESULT result
= E_FAIL
;
6158 if ((This
->hreftype
!= -1) && (This
->hreftype
== hRefType
))
6160 *ppTInfo
= (ITypeInfo
*)&This
->lpVtbl
;
6161 ITypeInfo_AddRef(*ppTInfo
);
6164 else if (hRefType
== -1 &&
6165 (This
->TypeAttr
.typekind
== TKIND_DISPATCH
) &&
6166 (This
->TypeAttr
.wTypeFlags
& TYPEFLAG_FDUAL
))
6168 /* when we meet a DUAL dispinterface, we must create the interface
6171 ITypeInfoImpl
* pTypeInfoImpl
= (ITypeInfoImpl
*) ITypeInfo_Constructor();
6174 /* the interface version contains the same information as the dispinterface
6175 * copy the contents of the structs.
6177 *pTypeInfoImpl
= *This
;
6178 pTypeInfoImpl
->ref
= 0;
6180 /* change the type to interface */
6181 pTypeInfoImpl
->TypeAttr
.typekind
= TKIND_INTERFACE
;
6183 *ppTInfo
= (ITypeInfo
*) pTypeInfoImpl
;
6185 /* we use data structures from This, so we need to keep a reference
6186 * to it to stop it being destroyed and signal to the new instance to
6187 * not free its data structures when it is destroyed */
6188 pTypeInfoImpl
->no_free_data
= TRUE
;
6189 pTypeInfoImpl
->next
= This
;
6190 ITypeInfo_AddRef((ITypeInfo
*) This
);
6192 ITypeInfo_AddRef(*ppTInfo
);
6196 } else if ((hRefType
!= -1) && (hRefType
& DISPATCH_HREF_MASK
) &&
6197 (This
->TypeAttr
.typekind
== TKIND_DISPATCH
) &&
6198 (This
->TypeAttr
.wTypeFlags
& TYPEFLAG_FDUAL
))
6200 HREFTYPE href_dispatch
= hRefType
;
6201 result
= ITypeInfoImpl_GetDispatchRefTypeInfo((ITypeInfo
*)iface
, &href_dispatch
, ppTInfo
);
6203 TLBRefType
*ref_type
;
6204 LIST_FOR_EACH_ENTRY(ref_type
, &This
->pTypeLib
->ref_list
, TLBRefType
, entry
)
6206 if(ref_type
->reference
== hRefType
)
6209 if(&ref_type
->entry
== &This
->pTypeLib
->ref_list
)
6211 FIXME("Can't find pRefType for ref %x\n", hRefType
);
6214 if(hRefType
!= -1) {
6215 ITypeLib
*pTLib
= NULL
;
6217 if(ref_type
->pImpTLInfo
== TLB_REF_INTERNAL
) {
6219 result
= ITypeInfo_GetContainingTypeLib(iface
, &pTLib
, &Index
);
6221 if(ref_type
->pImpTLInfo
->pImpTypeLib
) {
6222 TRACE("typeinfo in imported typelib that is already loaded\n");
6223 pTLib
= (ITypeLib
*)ref_type
->pImpTLInfo
->pImpTypeLib
;
6224 ITypeLib2_AddRef((ITypeLib
*) pTLib
);
6227 TRACE("typeinfo in imported typelib that isn't already loaded\n");
6228 result
= LoadRegTypeLib( &ref_type
->pImpTLInfo
->guid
,
6229 ref_type
->pImpTLInfo
->wVersionMajor
,
6230 ref_type
->pImpTLInfo
->wVersionMinor
,
6231 ref_type
->pImpTLInfo
->lcid
,
6234 if(!SUCCEEDED(result
)) {
6235 BSTR libnam
=SysAllocString(ref_type
->pImpTLInfo
->name
);
6236 result
=LoadTypeLib(libnam
, &pTLib
);
6237 SysFreeString(libnam
);
6239 if(SUCCEEDED(result
)) {
6240 ref_type
->pImpTLInfo
->pImpTypeLib
= (ITypeLibImpl
*)pTLib
;
6241 ITypeLib2_AddRef(pTLib
);
6245 if(SUCCEEDED(result
)) {
6246 if(ref_type
->index
== TLB_REF_USE_GUID
)
6247 result
= ITypeLib2_GetTypeInfoOfGuid(pTLib
,
6251 result
= ITypeLib2_GetTypeInfo(pTLib
, ref_type
->index
,
6255 ITypeLib2_Release(pTLib
);
6260 TRACE("(%p) hreftype 0x%04x loaded %s (%p)\n", This
, hRefType
,
6261 SUCCEEDED(result
)? "SUCCESS":"FAILURE", *ppTInfo
);
6265 /* ITypeInfo::AddressOfMember
6267 * Retrieves the addresses of static functions or variables, such as those
6270 static HRESULT WINAPI
ITypeInfo_fnAddressOfMember( ITypeInfo2
*iface
,
6271 MEMBERID memid
, INVOKEKIND invKind
, PVOID
*ppv
)
6273 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6279 TRACE("(%p)->(0x%x, 0x%x, %p)\n", This
, memid
, invKind
, ppv
);
6281 hr
= ITypeInfo_GetDllEntry(iface
, memid
, invKind
, &dll
, &entry
, &ordinal
);
6285 module
= LoadLibraryW(dll
);
6288 ERR("couldn't load %s\n", debugstr_w(dll
));
6290 if (entry
) SysFreeString(entry
);
6291 return STG_E_FILENOTFOUND
;
6293 /* FIXME: store library somewhere where we can free it */
6298 INT len
= WideCharToMultiByte(CP_ACP
, 0, entry
, -1, NULL
, 0, NULL
, NULL
);
6299 entryA
= HeapAlloc(GetProcessHeap(), 0, len
);
6300 WideCharToMultiByte(CP_ACP
, 0, entry
, -1, entryA
, len
, NULL
, NULL
);
6302 *ppv
= GetProcAddress(module
, entryA
);
6304 ERR("function not found %s\n", debugstr_a(entryA
));
6306 HeapFree(GetProcessHeap(), 0, entryA
);
6310 *ppv
= GetProcAddress(module
, MAKEINTRESOURCEA(ordinal
));
6312 ERR("function not found %d\n", ordinal
);
6316 if (entry
) SysFreeString(entry
);
6319 return TYPE_E_DLLFUNCTIONNOTFOUND
;
6324 /* ITypeInfo::CreateInstance
6326 * Creates a new instance of a type that describes a component object class
6329 static HRESULT WINAPI
ITypeInfo_fnCreateInstance( ITypeInfo2
*iface
,
6330 IUnknown
*pOuterUnk
, REFIID riid
, VOID
**ppvObj
)
6332 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6336 TRACE("(%p)->(%p, %s, %p)\n", This
, pOuterUnk
, debugstr_guid(riid
), ppvObj
);
6342 WARN("Not able to aggregate\n");
6343 return CLASS_E_NOAGGREGATION
;
6346 hr
= ITypeInfo_GetTypeAttr(iface
, &pTA
);
6347 if(FAILED(hr
)) return hr
;
6349 if(pTA
->typekind
!= TKIND_COCLASS
)
6351 WARN("CreateInstance on typeinfo of type %x\n", pTA
->typekind
);
6357 if(pTA
->wTypeFlags
& TYPEFLAG_FAPPOBJECT
)
6360 hr
= GetActiveObject(&pTA
->guid
, NULL
, &pUnk
);
6361 TRACE("GetActiveObject rets %08x\n", hr
);
6364 hr
= IUnknown_QueryInterface(pUnk
, riid
, ppvObj
);
6365 IUnknown_Release(pUnk
);
6370 hr
= CoCreateInstance(&pTA
->guid
, NULL
,
6371 CLSCTX_INPROC_SERVER
| CLSCTX_LOCAL_SERVER
,
6375 ITypeInfo_ReleaseTypeAttr(iface
, pTA
);
6379 /* ITypeInfo::GetMops
6381 * Retrieves marshalling information.
6383 static HRESULT WINAPI
ITypeInfo_fnGetMops( ITypeInfo2
*iface
, MEMBERID memid
,
6386 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6387 FIXME("(%p) stub!\n", This
);
6391 /* ITypeInfo::GetContainingTypeLib
6393 * Retrieves the containing type library and the index of the type description
6394 * within that type library.
6396 static HRESULT WINAPI
ITypeInfo_fnGetContainingTypeLib( ITypeInfo2
*iface
,
6397 ITypeLib
* *ppTLib
, UINT
*pIndex
)
6399 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6401 /* If a pointer is null, we simply ignore it, the ATL in particular passes pIndex as 0 */
6403 *pIndex
=This
->index
;
6404 TRACE("returning pIndex=%d\n", *pIndex
);
6408 *ppTLib
=(LPTYPELIB
)(This
->pTypeLib
);
6409 ITypeLib2_AddRef(*ppTLib
);
6410 TRACE("returning ppTLib=%p\n", *ppTLib
);
6416 /* ITypeInfo::ReleaseTypeAttr
6418 * Releases a TYPEATTR previously returned by GetTypeAttr.
6421 static void WINAPI
ITypeInfo_fnReleaseTypeAttr( ITypeInfo2
*iface
,
6422 TYPEATTR
* pTypeAttr
)
6424 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6425 TRACE("(%p)->(%p)\n", This
, pTypeAttr
);
6426 HeapFree(GetProcessHeap(), 0, pTypeAttr
);
6429 /* ITypeInfo::ReleaseFuncDesc
6431 * Releases a FUNCDESC previously returned by GetFuncDesc. *
6433 static void WINAPI
ITypeInfo_fnReleaseFuncDesc(
6435 FUNCDESC
*pFuncDesc
)
6437 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6440 TRACE("(%p)->(%p)\n", This
, pFuncDesc
);
6442 for (i
= 0; i
< pFuncDesc
->cParams
; i
++)
6443 TLB_FreeElemDesc(&pFuncDesc
->lprgelemdescParam
[i
]);
6444 TLB_FreeElemDesc(&pFuncDesc
->elemdescFunc
);
6446 SysFreeString((BSTR
)pFuncDesc
);
6449 /* ITypeInfo::ReleaseVarDesc
6451 * Releases a VARDESC previously returned by GetVarDesc.
6453 static void WINAPI
ITypeInfo_fnReleaseVarDesc( ITypeInfo2
*iface
,
6456 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6457 TRACE("(%p)->(%p)\n", This
, pVarDesc
);
6459 TLB_FreeElemDesc(&pVarDesc
->elemdescVar
);
6460 if (pVarDesc
->varkind
== VAR_CONST
)
6461 VariantClear(pVarDesc
->u
.lpvarValue
);
6462 SysFreeString((BSTR
)pVarDesc
);
6465 /* ITypeInfo2::GetTypeKind
6467 * Returns the TYPEKIND enumeration quickly, without doing any allocations.
6470 static HRESULT WINAPI
ITypeInfo2_fnGetTypeKind( ITypeInfo2
* iface
,
6471 TYPEKIND
*pTypeKind
)
6473 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6474 *pTypeKind
=This
->TypeAttr
.typekind
;
6475 TRACE("(%p) type 0x%0x\n", This
,*pTypeKind
);
6479 /* ITypeInfo2::GetTypeFlags
6481 * Returns the type flags without any allocations. This returns a DWORD type
6482 * flag, which expands the type flags without growing the TYPEATTR (type
6486 static HRESULT WINAPI
ITypeInfo2_fnGetTypeFlags( ITypeInfo2
*iface
, ULONG
*pTypeFlags
)
6488 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6489 *pTypeFlags
=This
->TypeAttr
.wTypeFlags
;
6490 TRACE("(%p) flags 0x%x\n", This
,*pTypeFlags
);
6494 /* ITypeInfo2::GetFuncIndexOfMemId
6495 * Binds to a specific member based on a known DISPID, where the member name
6496 * is not known (for example, when binding to a default member).
6499 static HRESULT WINAPI
ITypeInfo2_fnGetFuncIndexOfMemId( ITypeInfo2
* iface
,
6500 MEMBERID memid
, INVOKEKIND invKind
, UINT
*pFuncIndex
)
6502 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6503 const TLBFuncDesc
*pFuncInfo
;
6507 for(i
= 0, pFuncInfo
= This
->funclist
; pFuncInfo
; i
++, pFuncInfo
=pFuncInfo
->next
)
6508 if(memid
== pFuncInfo
->funcdesc
.memid
&& (invKind
& pFuncInfo
->funcdesc
.invkind
))
6514 result
= TYPE_E_ELEMENTNOTFOUND
;
6516 TRACE("(%p) memid 0x%08x invKind 0x%04x -> %s\n", This
,
6517 memid
, invKind
, SUCCEEDED(result
) ? "SUCCESS" : "FAILED");
6521 /* TypeInfo2::GetVarIndexOfMemId
6523 * Binds to a specific member based on a known DISPID, where the member name
6524 * is not known (for example, when binding to a default member).
6527 static HRESULT WINAPI
ITypeInfo2_fnGetVarIndexOfMemId( ITypeInfo2
* iface
,
6528 MEMBERID memid
, UINT
*pVarIndex
)
6530 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6531 TLBVarDesc
*pVarInfo
;
6534 for(i
=0, pVarInfo
=This
->varlist
; pVarInfo
&&
6535 memid
!= pVarInfo
->vardesc
.memid
; i
++, pVarInfo
=pVarInfo
->next
)
6541 result
= TYPE_E_ELEMENTNOTFOUND
;
6543 TRACE("(%p) memid 0x%08x -> %s\n", This
,
6544 memid
, SUCCEEDED(result
) ? "SUCCESS" : "FAILED");
6548 /* ITypeInfo2::GetCustData
6550 * Gets the custom data
6552 static HRESULT WINAPI
ITypeInfo2_fnGetCustData(
6557 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6558 TLBCustData
*pCData
;
6560 for(pCData
=This
->pCustData
; pCData
; pCData
= pCData
->next
)
6561 if( IsEqualIID(guid
, &pCData
->guid
)) break;
6563 TRACE("(%p) guid %s %s found!x)\n", This
, debugstr_guid(guid
), pCData
? "" : "NOT");
6567 VariantInit( pVarVal
);
6568 VariantCopy( pVarVal
, &pCData
->data
);
6571 return E_INVALIDARG
; /* FIXME: correct? */
6574 /* ITypeInfo2::GetFuncCustData
6576 * Gets the custom data
6578 static HRESULT WINAPI
ITypeInfo2_fnGetFuncCustData(
6584 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6585 TLBCustData
*pCData
=NULL
;
6586 TLBFuncDesc
* pFDesc
;
6588 for(i
=0, pFDesc
=This
->funclist
; i
!=index
&& pFDesc
; i
++,
6589 pFDesc
=pFDesc
->next
);
6592 for(pCData
=pFDesc
->pCustData
; pCData
; pCData
= pCData
->next
)
6593 if( IsEqualIID(guid
, &pCData
->guid
)) break;
6595 TRACE("(%p) guid %s %s found!x)\n", This
, debugstr_guid(guid
), pCData
? "" : "NOT");
6598 VariantInit( pVarVal
);
6599 VariantCopy( pVarVal
, &pCData
->data
);
6602 return E_INVALIDARG
; /* FIXME: correct? */
6605 /* ITypeInfo2::GetParamCustData
6607 * Gets the custom data
6609 static HRESULT WINAPI
ITypeInfo2_fnGetParamCustData(
6616 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6617 TLBCustData
*pCData
=NULL
;
6618 TLBFuncDesc
* pFDesc
;
6621 for(i
=0, pFDesc
=This
->funclist
; i
!=indexFunc
&& pFDesc
; i
++,pFDesc
=pFDesc
->next
);
6623 if(pFDesc
&& indexParam
>=0 && indexParam
<pFDesc
->funcdesc
.cParams
)
6624 for(pCData
=pFDesc
->pParamDesc
[indexParam
].pCustData
; pCData
;
6625 pCData
= pCData
->next
)
6626 if( IsEqualIID(guid
, &pCData
->guid
)) break;
6628 TRACE("(%p) guid %s %s found!x)\n", This
, debugstr_guid(guid
), pCData
? "" : "NOT");
6632 VariantInit( pVarVal
);
6633 VariantCopy( pVarVal
, &pCData
->data
);
6636 return E_INVALIDARG
; /* FIXME: correct? */
6639 /* ITypeInfo2::GetVarCustData
6641 * Gets the custom data
6643 static HRESULT WINAPI
ITypeInfo2_fnGetVarCustData(
6649 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6650 TLBCustData
*pCData
=NULL
;
6651 TLBVarDesc
* pVDesc
;
6654 for(i
=0, pVDesc
=This
->varlist
; i
!=index
&& pVDesc
; i
++, pVDesc
=pVDesc
->next
);
6658 for(pCData
=pVDesc
->pCustData
; pCData
; pCData
= pCData
->next
)
6660 if( IsEqualIID(guid
, &pCData
->guid
)) break;
6664 TRACE("(%p) guid %s %s found!x)\n", This
, debugstr_guid(guid
), pCData
? "" : "NOT");
6668 VariantInit( pVarVal
);
6669 VariantCopy( pVarVal
, &pCData
->data
);
6672 return E_INVALIDARG
; /* FIXME: correct? */
6675 /* ITypeInfo2::GetImplCustData
6677 * Gets the custom data
6679 static HRESULT WINAPI
ITypeInfo2_fnGetImplTypeCustData(
6685 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6686 TLBCustData
*pCData
=NULL
;
6687 TLBImplType
* pRDesc
;
6690 for(i
=0, pRDesc
=This
->impltypelist
; i
!=index
&& pRDesc
; i
++, pRDesc
=pRDesc
->next
);
6694 for(pCData
=pRDesc
->pCustData
; pCData
; pCData
= pCData
->next
)
6696 if( IsEqualIID(guid
, &pCData
->guid
)) break;
6700 TRACE("(%p) guid %s %s found!x)\n", This
, debugstr_guid(guid
), pCData
? "" : "NOT");
6704 VariantInit( pVarVal
);
6705 VariantCopy( pVarVal
, &pCData
->data
);
6708 return E_INVALIDARG
; /* FIXME: correct? */
6711 /* ITypeInfo2::GetDocumentation2
6713 * Retrieves the documentation string, the complete Help file name and path,
6714 * the localization context to use, and the context ID for the library Help
6715 * topic in the Help file.
6718 static HRESULT WINAPI
ITypeInfo2_fnGetDocumentation2(
6722 BSTR
*pbstrHelpString
,
6723 DWORD
*pdwHelpStringContext
,
6724 BSTR
*pbstrHelpStringDll
)
6726 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6727 const TLBFuncDesc
*pFDesc
;
6728 const TLBVarDesc
*pVDesc
;
6729 TRACE("(%p) memid %d lcid(0x%x) HelpString(%p) "
6730 "HelpStringContext(%p) HelpStringDll(%p)\n",
6731 This
, memid
, lcid
, pbstrHelpString
, pdwHelpStringContext
,
6732 pbstrHelpStringDll
);
6733 /* the help string should be obtained from the helpstringdll,
6734 * using the _DLLGetDocumentation function, based on the supplied
6735 * lcid. Nice to do sometime...
6737 if(memid
==MEMBERID_NIL
){ /* documentation for the typeinfo */
6739 *pbstrHelpString
=SysAllocString(This
->Name
);
6740 if(pdwHelpStringContext
)
6741 *pdwHelpStringContext
=This
->dwHelpStringContext
;
6742 if(pbstrHelpStringDll
)
6743 *pbstrHelpStringDll
=
6744 SysAllocString(This
->pTypeLib
->HelpStringDll
);/* FIXME */
6746 }else {/* for a member */
6747 for(pFDesc
=This
->funclist
; pFDesc
; pFDesc
=pFDesc
->next
)
6748 if(pFDesc
->funcdesc
.memid
==memid
){
6750 *pbstrHelpString
=SysAllocString(pFDesc
->HelpString
);
6751 if(pdwHelpStringContext
)
6752 *pdwHelpStringContext
=pFDesc
->HelpStringContext
;
6753 if(pbstrHelpStringDll
)
6754 *pbstrHelpStringDll
=
6755 SysAllocString(This
->pTypeLib
->HelpStringDll
);/* FIXME */
6758 for(pVDesc
=This
->varlist
; pVDesc
; pVDesc
=pVDesc
->next
)
6759 if(pVDesc
->vardesc
.memid
==memid
){
6761 *pbstrHelpString
=SysAllocString(pVDesc
->HelpString
);
6762 if(pdwHelpStringContext
)
6763 *pdwHelpStringContext
=pVDesc
->HelpStringContext
;
6764 if(pbstrHelpStringDll
)
6765 *pbstrHelpStringDll
=
6766 SysAllocString(This
->pTypeLib
->HelpStringDll
);/* FIXME */
6770 return TYPE_E_ELEMENTNOTFOUND
;
6773 /* ITypeInfo2::GetAllCustData
6775 * Gets all custom data items for the Type info.
6778 static HRESULT WINAPI
ITypeInfo2_fnGetAllCustData(
6780 CUSTDATA
*pCustData
)
6782 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6783 TLBCustData
*pCData
;
6786 TRACE("(%p) returning %d items\n", This
, This
->ctCustData
);
6788 pCustData
->prgCustData
= TLB_Alloc(This
->ctCustData
* sizeof(CUSTDATAITEM
));
6789 if(pCustData
->prgCustData
){
6790 pCustData
->cCustData
=This
->ctCustData
;
6791 for(i
=0, pCData
=This
->pCustData
; pCData
; i
++, pCData
= pCData
->next
){
6792 pCustData
->prgCustData
[i
].guid
=pCData
->guid
;
6793 VariantCopy(& pCustData
->prgCustData
[i
].varValue
, & pCData
->data
);
6796 ERR(" OUT OF MEMORY!\n");
6797 return E_OUTOFMEMORY
;
6802 /* ITypeInfo2::GetAllFuncCustData
6804 * Gets all custom data items for the specified Function
6807 static HRESULT WINAPI
ITypeInfo2_fnGetAllFuncCustData(
6810 CUSTDATA
*pCustData
)
6812 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6813 TLBCustData
*pCData
;
6814 TLBFuncDesc
* pFDesc
;
6816 TRACE("(%p) index %d\n", This
, index
);
6817 for(i
=0, pFDesc
=This
->funclist
; i
!=index
&& pFDesc
; i
++,
6818 pFDesc
=pFDesc
->next
)
6821 pCustData
->prgCustData
=
6822 TLB_Alloc(pFDesc
->ctCustData
* sizeof(CUSTDATAITEM
));
6823 if(pCustData
->prgCustData
){
6824 pCustData
->cCustData
=pFDesc
->ctCustData
;
6825 for(i
=0, pCData
=pFDesc
->pCustData
; pCData
; i
++,
6826 pCData
= pCData
->next
){
6827 pCustData
->prgCustData
[i
].guid
=pCData
->guid
;
6828 VariantCopy(& pCustData
->prgCustData
[i
].varValue
,
6832 ERR(" OUT OF MEMORY!\n");
6833 return E_OUTOFMEMORY
;
6837 return TYPE_E_ELEMENTNOTFOUND
;
6840 /* ITypeInfo2::GetAllParamCustData
6842 * Gets all custom data items for the Functions
6845 static HRESULT WINAPI
ITypeInfo2_fnGetAllParamCustData( ITypeInfo2
* iface
,
6846 UINT indexFunc
, UINT indexParam
, CUSTDATA
*pCustData
)
6848 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6849 TLBCustData
*pCData
=NULL
;
6850 TLBFuncDesc
* pFDesc
;
6852 TRACE("(%p) index %d\n", This
, indexFunc
);
6853 for(i
=0, pFDesc
=This
->funclist
; i
!=indexFunc
&& pFDesc
; i
++,
6854 pFDesc
=pFDesc
->next
)
6856 if(pFDesc
&& indexParam
>=0 && indexParam
<pFDesc
->funcdesc
.cParams
){
6857 pCustData
->prgCustData
=
6858 TLB_Alloc(pFDesc
->pParamDesc
[indexParam
].ctCustData
*
6859 sizeof(CUSTDATAITEM
));
6860 if(pCustData
->prgCustData
){
6861 pCustData
->cCustData
=pFDesc
->pParamDesc
[indexParam
].ctCustData
;
6862 for(i
=0, pCData
=pFDesc
->pParamDesc
[indexParam
].pCustData
;
6863 pCData
; i
++, pCData
= pCData
->next
){
6864 pCustData
->prgCustData
[i
].guid
=pCData
->guid
;
6865 VariantCopy(& pCustData
->prgCustData
[i
].varValue
,
6869 ERR(" OUT OF MEMORY!\n");
6870 return E_OUTOFMEMORY
;
6874 return TYPE_E_ELEMENTNOTFOUND
;
6877 /* ITypeInfo2::GetAllVarCustData
6879 * Gets all custom data items for the specified Variable
6882 static HRESULT WINAPI
ITypeInfo2_fnGetAllVarCustData( ITypeInfo2
* iface
,
6883 UINT index
, CUSTDATA
*pCustData
)
6885 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6886 TLBCustData
*pCData
;
6887 TLBVarDesc
* pVDesc
;
6889 TRACE("(%p) index %d\n", This
, index
);
6890 for(i
=0, pVDesc
=This
->varlist
; i
!=index
&& pVDesc
; i
++,
6891 pVDesc
=pVDesc
->next
)
6894 pCustData
->prgCustData
=
6895 TLB_Alloc(pVDesc
->ctCustData
* sizeof(CUSTDATAITEM
));
6896 if(pCustData
->prgCustData
){
6897 pCustData
->cCustData
=pVDesc
->ctCustData
;
6898 for(i
=0, pCData
=pVDesc
->pCustData
; pCData
; i
++,
6899 pCData
= pCData
->next
){
6900 pCustData
->prgCustData
[i
].guid
=pCData
->guid
;
6901 VariantCopy(& pCustData
->prgCustData
[i
].varValue
,
6905 ERR(" OUT OF MEMORY!\n");
6906 return E_OUTOFMEMORY
;
6910 return TYPE_E_ELEMENTNOTFOUND
;
6913 /* ITypeInfo2::GetAllImplCustData
6915 * Gets all custom data items for the specified implementation type
6918 static HRESULT WINAPI
ITypeInfo2_fnGetAllImplTypeCustData(
6921 CUSTDATA
*pCustData
)
6923 ITypeInfoImpl
*This
= (ITypeInfoImpl
*)iface
;
6924 TLBCustData
*pCData
;
6925 TLBImplType
* pRDesc
;
6927 TRACE("(%p) index %d\n", This
, index
);
6928 for(i
=0, pRDesc
=This
->impltypelist
; i
!=index
&& pRDesc
; i
++,
6929 pRDesc
=pRDesc
->next
)
6932 pCustData
->prgCustData
=
6933 TLB_Alloc(pRDesc
->ctCustData
* sizeof(CUSTDATAITEM
));
6934 if(pCustData
->prgCustData
){
6935 pCustData
->cCustData
=pRDesc
->ctCustData
;
6936 for(i
=0, pCData
=pRDesc
->pCustData
; pCData
; i
++,
6937 pCData
= pCData
->next
){
6938 pCustData
->prgCustData
[i
].guid
=pCData
->guid
;
6939 VariantCopy(& pCustData
->prgCustData
[i
].varValue
,
6943 ERR(" OUT OF MEMORY!\n");
6944 return E_OUTOFMEMORY
;
6948 return TYPE_E_ELEMENTNOTFOUND
;
6951 static const ITypeInfo2Vtbl tinfvt
=
6954 ITypeInfo_fnQueryInterface
,
6956 ITypeInfo_fnRelease
,
6958 ITypeInfo_fnGetTypeAttr
,
6959 ITypeInfo_fnGetTypeComp
,
6960 ITypeInfo_fnGetFuncDesc
,
6961 ITypeInfo_fnGetVarDesc
,
6962 ITypeInfo_fnGetNames
,
6963 ITypeInfo_fnGetRefTypeOfImplType
,
6964 ITypeInfo_fnGetImplTypeFlags
,
6965 ITypeInfo_fnGetIDsOfNames
,
6967 ITypeInfo_fnGetDocumentation
,
6968 ITypeInfo_fnGetDllEntry
,
6969 ITypeInfo_fnGetRefTypeInfo
,
6970 ITypeInfo_fnAddressOfMember
,
6971 ITypeInfo_fnCreateInstance
,
6972 ITypeInfo_fnGetMops
,
6973 ITypeInfo_fnGetContainingTypeLib
,
6974 ITypeInfo_fnReleaseTypeAttr
,
6975 ITypeInfo_fnReleaseFuncDesc
,
6976 ITypeInfo_fnReleaseVarDesc
,
6978 ITypeInfo2_fnGetTypeKind
,
6979 ITypeInfo2_fnGetTypeFlags
,
6980 ITypeInfo2_fnGetFuncIndexOfMemId
,
6981 ITypeInfo2_fnGetVarIndexOfMemId
,
6982 ITypeInfo2_fnGetCustData
,
6983 ITypeInfo2_fnGetFuncCustData
,
6984 ITypeInfo2_fnGetParamCustData
,
6985 ITypeInfo2_fnGetVarCustData
,
6986 ITypeInfo2_fnGetImplTypeCustData
,
6987 ITypeInfo2_fnGetDocumentation2
,
6988 ITypeInfo2_fnGetAllCustData
,
6989 ITypeInfo2_fnGetAllFuncCustData
,
6990 ITypeInfo2_fnGetAllParamCustData
,
6991 ITypeInfo2_fnGetAllVarCustData
,
6992 ITypeInfo2_fnGetAllImplTypeCustData
,
6995 /******************************************************************************
6996 * CreateDispTypeInfo [OLEAUT32.31]
6998 * Build type information for an object so it can be called through an
6999 * IDispatch interface.
7002 * Success: S_OK. pptinfo contains the created ITypeInfo object.
7003 * Failure: E_INVALIDARG, if one or more arguments is invalid.
7006 * This call allows an objects methods to be accessed through IDispatch, by
7007 * building an ITypeInfo object that IDispatch can use to call through.
7009 HRESULT WINAPI
CreateDispTypeInfo(
7010 INTERFACEDATA
*pidata
, /* [I] Description of the interface to build type info for */
7011 LCID lcid
, /* [I] Locale Id */
7012 ITypeInfo
**pptinfo
) /* [O] Destination for created ITypeInfo object */
7014 ITypeInfoImpl
*pTIClass
, *pTIIface
;
7015 ITypeLibImpl
*pTypeLibImpl
;
7017 TLBFuncDesc
**ppFuncDesc
;
7021 pTypeLibImpl
= TypeLibImpl_Constructor();
7022 if (!pTypeLibImpl
) return E_FAIL
;
7024 pTIIface
= (ITypeInfoImpl
*)ITypeInfo_Constructor();
7025 pTIIface
->pTypeLib
= pTypeLibImpl
;
7026 pTIIface
->index
= 0;
7027 pTIIface
->Name
= NULL
;
7028 pTIIface
->dwHelpContext
= -1;
7029 memset(&pTIIface
->TypeAttr
.guid
, 0, sizeof(GUID
));
7030 pTIIface
->TypeAttr
.lcid
= lcid
;
7031 pTIIface
->TypeAttr
.typekind
= TKIND_INTERFACE
;
7032 pTIIface
->TypeAttr
.wMajorVerNum
= 0;
7033 pTIIface
->TypeAttr
.wMinorVerNum
= 0;
7034 pTIIface
->TypeAttr
.cbAlignment
= 2;
7035 pTIIface
->TypeAttr
.cbSizeInstance
= -1;
7036 pTIIface
->TypeAttr
.cbSizeVft
= -1;
7037 pTIIface
->TypeAttr
.cFuncs
= 0;
7038 pTIIface
->TypeAttr
.cImplTypes
= 0;
7039 pTIIface
->TypeAttr
.cVars
= 0;
7040 pTIIface
->TypeAttr
.wTypeFlags
= 0;
7042 ppFuncDesc
= &pTIIface
->funclist
;
7043 for(func
= 0; func
< pidata
->cMembers
; func
++) {
7044 METHODDATA
*md
= pidata
->pmethdata
+ func
;
7045 *ppFuncDesc
= HeapAlloc(GetProcessHeap(), 0, sizeof(**ppFuncDesc
));
7046 (*ppFuncDesc
)->Name
= SysAllocString(md
->szName
);
7047 (*ppFuncDesc
)->funcdesc
.memid
= md
->dispid
;
7048 (*ppFuncDesc
)->funcdesc
.lprgscode
= NULL
;
7049 (*ppFuncDesc
)->funcdesc
.funckind
= FUNC_VIRTUAL
;
7050 (*ppFuncDesc
)->funcdesc
.invkind
= md
->wFlags
;
7051 (*ppFuncDesc
)->funcdesc
.callconv
= md
->cc
;
7052 (*ppFuncDesc
)->funcdesc
.cParams
= md
->cArgs
;
7053 (*ppFuncDesc
)->funcdesc
.cParamsOpt
= 0;
7054 (*ppFuncDesc
)->funcdesc
.oVft
= md
->iMeth
<< 2;
7055 (*ppFuncDesc
)->funcdesc
.cScodes
= 0;
7056 (*ppFuncDesc
)->funcdesc
.wFuncFlags
= 0;
7057 (*ppFuncDesc
)->funcdesc
.elemdescFunc
.tdesc
.vt
= md
->vtReturn
;
7058 (*ppFuncDesc
)->funcdesc
.elemdescFunc
.u
.paramdesc
.wParamFlags
= PARAMFLAG_NONE
;
7059 (*ppFuncDesc
)->funcdesc
.elemdescFunc
.u
.paramdesc
.pparamdescex
= NULL
;
7060 (*ppFuncDesc
)->funcdesc
.lprgelemdescParam
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
7061 md
->cArgs
* sizeof(ELEMDESC
));
7062 (*ppFuncDesc
)->pParamDesc
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
7063 md
->cArgs
* sizeof(TLBParDesc
));
7064 for(param
= 0; param
< md
->cArgs
; param
++) {
7065 (*ppFuncDesc
)->funcdesc
.lprgelemdescParam
[param
].tdesc
.vt
= md
->ppdata
[param
].vt
;
7066 (*ppFuncDesc
)->pParamDesc
[param
].Name
= SysAllocString(md
->ppdata
[param
].szName
);
7068 (*ppFuncDesc
)->helpcontext
= 0;
7069 (*ppFuncDesc
)->HelpStringContext
= 0;
7070 (*ppFuncDesc
)->HelpString
= NULL
;
7071 (*ppFuncDesc
)->Entry
= NULL
;
7072 (*ppFuncDesc
)->ctCustData
= 0;
7073 (*ppFuncDesc
)->pCustData
= NULL
;
7074 (*ppFuncDesc
)->next
= NULL
;
7075 pTIIface
->TypeAttr
.cFuncs
++;
7076 ppFuncDesc
= &(*ppFuncDesc
)->next
;
7079 dump_TypeInfo(pTIIface
);
7081 pTypeLibImpl
->pTypeInfo
= pTIIface
;
7082 pTypeLibImpl
->TypeInfoCount
++;
7084 pTIClass
= (ITypeInfoImpl
*)ITypeInfo_Constructor();
7085 pTIClass
->pTypeLib
= pTypeLibImpl
;
7086 pTIClass
->index
= 1;
7087 pTIClass
->Name
= NULL
;
7088 pTIClass
->dwHelpContext
= -1;
7089 memset(&pTIClass
->TypeAttr
.guid
, 0, sizeof(GUID
));
7090 pTIClass
->TypeAttr
.lcid
= lcid
;
7091 pTIClass
->TypeAttr
.typekind
= TKIND_COCLASS
;
7092 pTIClass
->TypeAttr
.wMajorVerNum
= 0;
7093 pTIClass
->TypeAttr
.wMinorVerNum
= 0;
7094 pTIClass
->TypeAttr
.cbAlignment
= 2;
7095 pTIClass
->TypeAttr
.cbSizeInstance
= -1;
7096 pTIClass
->TypeAttr
.cbSizeVft
= -1;
7097 pTIClass
->TypeAttr
.cFuncs
= 0;
7098 pTIClass
->TypeAttr
.cImplTypes
= 1;
7099 pTIClass
->TypeAttr
.cVars
= 0;
7100 pTIClass
->TypeAttr
.wTypeFlags
= 0;
7102 pTIClass
->impltypelist
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*pTIClass
->impltypelist
));
7103 pTIClass
->impltypelist
->hRef
= 0;
7105 ref
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*ref
));
7108 ref
->pImpTLInfo
= TLB_REF_INTERNAL
;
7109 list_add_head(&pTypeLibImpl
->ref_list
, &ref
->entry
);
7111 dump_TypeInfo(pTIClass
);
7113 pTIIface
->next
= pTIClass
;
7114 pTypeLibImpl
->TypeInfoCount
++;
7116 *pptinfo
= (ITypeInfo
*)pTIClass
;
7118 ITypeInfo_AddRef(*pptinfo
);
7119 ITypeLib_Release((ITypeLib
*)&pTypeLibImpl
->lpVtbl
);
7125 static HRESULT WINAPI
ITypeComp_fnQueryInterface(ITypeComp
* iface
, REFIID riid
, LPVOID
* ppv
)
7127 ITypeInfoImpl
*This
= info_impl_from_ITypeComp(iface
);
7129 return ITypeInfo_QueryInterface((ITypeInfo
*)This
, riid
, ppv
);
7132 static ULONG WINAPI
ITypeComp_fnAddRef(ITypeComp
* iface
)
7134 ITypeInfoImpl
*This
= info_impl_from_ITypeComp(iface
);
7136 return ITypeInfo_AddRef((ITypeInfo
*)This
);
7139 static ULONG WINAPI
ITypeComp_fnRelease(ITypeComp
* iface
)
7141 ITypeInfoImpl
*This
= info_impl_from_ITypeComp(iface
);
7143 return ITypeInfo_Release((ITypeInfo
*)This
);
7146 static HRESULT WINAPI
ITypeComp_fnBind(
7151 ITypeInfo
** ppTInfo
,
7152 DESCKIND
* pDescKind
,
7155 ITypeInfoImpl
*This
= info_impl_from_ITypeComp(iface
);
7156 const TLBFuncDesc
*pFDesc
;
7157 const TLBVarDesc
*pVDesc
;
7158 HRESULT hr
= DISP_E_MEMBERNOTFOUND
;
7160 TRACE("(%s, %x, 0x%x, %p, %p, %p)\n", debugstr_w(szName
), lHash
, wFlags
, ppTInfo
, pDescKind
, pBindPtr
);
7162 *pDescKind
= DESCKIND_NONE
;
7163 pBindPtr
->lpfuncdesc
= NULL
;
7166 for(pFDesc
= This
->funclist
; pFDesc
; pFDesc
= pFDesc
->next
)
7167 if (!strcmpiW(pFDesc
->Name
, szName
)) {
7168 if (!wFlags
|| (pFDesc
->funcdesc
.invkind
& wFlags
))
7171 /* name found, but wrong flags */
7172 hr
= TYPE_E_TYPEMISMATCH
;
7177 HRESULT hr
= TLB_AllocAndInitFuncDesc(
7179 &pBindPtr
->lpfuncdesc
,
7180 This
->TypeAttr
.typekind
== TKIND_DISPATCH
);
7183 *pDescKind
= DESCKIND_FUNCDESC
;
7184 *ppTInfo
= (ITypeInfo
*)&This
->lpVtbl
;
7185 ITypeInfo_AddRef(*ppTInfo
);
7188 for(pVDesc
= This
->varlist
; pVDesc
; pVDesc
= pVDesc
->next
) {
7189 if (!strcmpiW(pVDesc
->Name
, szName
)) {
7190 HRESULT hr
= TLB_AllocAndInitVarDesc(&pVDesc
->vardesc
, &pBindPtr
->lpvardesc
);
7193 *pDescKind
= DESCKIND_VARDESC
;
7194 *ppTInfo
= (ITypeInfo
*)&This
->lpVtbl
;
7195 ITypeInfo_AddRef(*ppTInfo
);
7200 /* FIXME: search each inherited interface, not just the first */
7201 if (hr
== DISP_E_MEMBERNOTFOUND
&& This
->impltypelist
) {
7202 /* recursive search */
7206 hr
=ITypeInfo_GetRefTypeInfo((ITypeInfo
*)&This
->lpVtbl
, This
->impltypelist
->hRef
, &pTInfo
);
7209 hr
= ITypeInfo_GetTypeComp(pTInfo
,&pTComp
);
7210 ITypeInfo_Release(pTInfo
);
7214 hr
= ITypeComp_Bind(pTComp
, szName
, lHash
, wFlags
, ppTInfo
, pDescKind
, pBindPtr
);
7215 ITypeComp_Release(pTComp
);
7218 WARN("Could not search inherited interface!\n");
7220 WARN("did not find member with name %s, flags 0x%x!\n", debugstr_w(szName
), wFlags
);
7224 static HRESULT WINAPI
ITypeComp_fnBindType(
7228 ITypeInfo
** ppTInfo
,
7229 ITypeComp
** ppTComp
)
7231 TRACE("(%s, %x, %p, %p)\n", debugstr_w(szName
), lHash
, ppTInfo
, ppTComp
);
7233 /* strange behaviour (does nothing) but like the
7236 if (!ppTInfo
|| !ppTComp
)
7245 static const ITypeCompVtbl tcompvt
=
7248 ITypeComp_fnQueryInterface
,
7250 ITypeComp_fnRelease
,
7253 ITypeComp_fnBindType