typelib.c File Reference

#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <ctype.h>
#include "winerror.h"
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winreg.h"
#include "winuser.h"
#include "winternl.h"
#include "lzexpand.h"
#include "objbase.h"
#include "typelib.h"
#include "wine/debug.h"
#include "variant.h"
#include "wine/asm.h"
#include "wine/heap.h"
#include "wine/list.h"

Include dependency graph for typelib.c:

Go to the source code of this file.

Classes
struct	NE_NAMEINFO
struct	NE_TYPEINFO
struct	tlibredirect_data
struct	tagTLBGuid
struct	tagTLBCustData
struct	tagTLBImpLib
struct	tagTLBString
struct	tagITypeLibImpl
struct	tagTLBRefType
struct	tagTLBParDesc
struct	tagTLBFuncDesc
struct	tagTLBVarDesc
struct	tagTLBImplType
struct	tagITypeInfoImpl
struct	tagTLBContext
struct	TLB_PEFile
struct	TLB_NEFile
struct	TLB_Mapping
struct	bitstream
struct	sltg_ref_lookup_t
struct	SLTG_InternalOtherTypeInfo
struct	search_res_tlb_params
struct	tagWMSFT_SegContents
struct	tagWMSFT_TLBFile
struct	tagWMSFT_RefChunk
struct	tagWMSFT_ImpFile

Macros
#define	COBJMACROS
#define	NONAMELESSUNION
#define	FromLEWord(X)   (X)
#define	FromLEDWord(X)   (X)
#define	DISPATCH_HREF_OFFSET   0x01000000
#define	DISPATCH_HREF_MASK   0xff000000
#define	FromLEWords(X, Y)   /*nothing*/
#define	FromLEDWords(X, Y)   /*nothing*/
#define	XX(x)   if (TYPEFLAG_##x & tattr->wTypeFlags) MESSAGE(#x"|");
#define	TLB_REF_USE_GUID   -2
#define	TLB_REF_INTERNAL   (void*)-2
#define	TLB_REF_NOT_FOUND   (void*)-1
#define	SLTG_SIGNATURE   0x47544c53 /* "SLTG" */
#define	X(x)   TRACE_(typelib)("tt "#x": %x\n",pTITail->res##x);
#define	INVBUF_ELEMENT_SIZE    (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *) + sizeof(VARTYPE))
#define	INVBUF_GET_ARG_ARRAY(buffer, params)   (buffer)
#define	INVBUF_GET_MISSING_ARG_ARRAY(buffer, params)    ((VARIANTARG *)((char *)(buffer) + sizeof(VARIANTARG) * (params)))
#define	INVBUF_GET_ARG_PTR_ARRAY(buffer, params)    ((VARIANTARG **)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG)) * (params)))
#define	INVBUF_GET_ARG_TYPE_ARRAY(buffer, params)    ((VARTYPE *)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *)) * (params)))

Typedefs
typedef struct tagTLBGuid	TLBGuid
typedef struct tagTLBCustData	TLBCustData
typedef struct tagTLBImpLib	TLBImpLib
typedef struct tagTLBString	TLBString
typedef struct tagITypeLibImpl	ITypeLibImpl
typedef struct tagTLBRefType	TLBRefType
typedef struct tagTLBParDesc	TLBParDesc
typedef struct tagTLBFuncDesc	TLBFuncDesc
typedef struct tagTLBVarDesc	TLBVarDesc
typedef struct tagTLBImplType	TLBImplType
typedef struct tagITypeInfoImpl	ITypeInfoImpl
typedef struct tagTLBContext	TLBContext
typedef struct TLB_PEFile	TLB_PEFile
typedef struct TLB_NEFile	TLB_NEFile
typedef struct TLB_Mapping	TLB_Mapping
typedef struct tagWMSFT_SegContents	WMSFT_SegContents
typedef struct tagWMSFT_TLBFile	WMSFT_TLBFile
typedef struct tagWMSFT_RefChunk	WMSFT_RefChunk
typedef struct tagWMSFT_ImpFile	WMSFT_ImpFile

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
	WINE_DECLARE_DEBUG_CHANNEL (typelib)
static HRESULT	typedescvt_to_variantvt (ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
static HRESULT	TLB_AllocAndInitVarDesc (const VARDESC *src, VARDESC **dest_ptr)
static void	TLB_FreeVarDesc (VARDESC *)
static BOOL	find_typelib_key (REFGUID guid, WORD *wMaj, WORD *wMin)
static WCHAR *	get_typelib_key (REFGUID guid, WORD wMaj, WORD wMin, WCHAR *buffer)
static WCHAR *	get_interface_key (REFGUID guid, WCHAR *buffer)
static WCHAR *	get_lcid_subkey (LCID lcid, SYSKIND syskind, WCHAR *buffer)
static HRESULT	TLB_ReadTypeLib (LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath, ITypeLib2 **ppTypeLib)
static HRESULT	query_typelib_path (REFGUID guid, WORD wMaj, WORD wMin, SYSKIND syskind, LCID lcid, BSTR *path, BOOL redir)
HRESULT WINAPI	QueryPathOfRegTypeLib (REFGUID guid, WORD wMaj, WORD wMin, LCID lcid, LPBSTR path)
HRESULT WINAPI	CreateTypeLib (SYSKIND syskind, LPCOLESTR file, ICreateTypeLib **ctlib)
HRESULT WINAPI	LoadTypeLib (const OLECHAR *szFile, ITypeLib **pptLib)
HRESULT WINAPI	LoadTypeLibEx (LPCOLESTR szFile, REGKIND regkind, ITypeLib **pptLib)
HRESULT WINAPI	LoadRegTypeLib (REFGUID rguid, WORD wVerMajor, WORD wVerMinor, LCID lcid, ITypeLib **ppTLib)
static void	TLB_register_interface (TLIBATTR *libattr, LPOLESTR name, TYPEATTR *tattr, DWORD flag)
HRESULT WINAPI	RegisterTypeLib (ITypeLib *ptlib, const WCHAR *szFullPath, const WCHAR *szHelpDir)
static void	TLB_unregister_interface (GUID *guid, REGSAM flag)
HRESULT WINAPI	UnRegisterTypeLib (REFGUID libid, WORD wVerMajor, WORD wVerMinor, LCID lcid, SYSKIND syskind)
HRESULT WINAPI	RegisterTypeLibForUser (ITypeLib *ptlib, OLECHAR *szFullPath, OLECHAR *szHelpDir)
HRESULT WINAPI	UnRegisterTypeLibForUser (REFGUID libid, WORD wVerMajor, WORD wVerMinor, LCID lcid, SYSKIND syskind)
static ITypeLibImpl *	impl_from_ITypeLib2 (ITypeLib2 *iface)
static ITypeLibImpl *	impl_from_ITypeLib (ITypeLib *iface)
static ITypeLibImpl *	impl_from_ITypeComp (ITypeComp *iface)
static ITypeLibImpl *	impl_from_ICreateTypeLib2 (ICreateTypeLib2 *iface)
static ITypeLib2 *	ITypeLib2_Constructor_MSFT (LPVOID pLib, DWORD dwTLBLength)
static ITypeLib2 *	ITypeLib2_Constructor_SLTG (LPVOID pLib, DWORD dwTLBLength)
static ITypeInfoImpl *	info_impl_from_ITypeComp (ITypeComp *iface)
static ITypeInfoImpl *	impl_from_ITypeInfo2 (ITypeInfo2 *iface)
static ITypeInfoImpl *	impl_from_ITypeInfo (ITypeInfo *iface)
static ITypeInfoImpl *	info_impl_from_ICreateTypeInfo2 (ICreateTypeInfo2 *iface)
static ITypeInfoImpl *	ITypeInfoImpl_Constructor (void)
static void	ITypeInfoImpl_Destroy (ITypeInfoImpl *This)
static BSTR	TLB_get_bstr (const TLBString *str)
static int	TLB_str_memcmp (void *left, const TLBString *str, DWORD len)
static const GUID *	TLB_get_guidref (const TLBGuid *guid)
static const GUID *	TLB_get_guid_null (const TLBGuid *guid)
static int	get_ptr_size (SYSKIND syskind)
static void	dump_TypeDesc (const TYPEDESC *pTD, char *szVarType)
static void	dump_ELEMDESC (const ELEMDESC *edesc)
static void	dump_FUNCDESC (const FUNCDESC *funcdesc)
static void	dump_TLBFuncDescOne (const TLBFuncDesc *pfd)
static void	dump_TLBFuncDesc (const TLBFuncDesc *pfd, UINT n)
static void	dump_TLBVarDesc (const TLBVarDesc *pvd, UINT n)
static void	dump_TLBImpLib (const TLBImpLib *import)
static void	dump_TLBRefType (const ITypeLibImpl *pTL)
static void	dump_TLBImplType (const TLBImplType *impl, UINT n)
static void	dump_DispParms (const DISPPARAMS *pdp)
static void	dump_TypeInfo (const ITypeInfoImpl *pty)
static void	dump_VARDESC (const VARDESC *v)
static void	TLB_abort (void)
static SIZE_T	TLB_SizeTypeDesc (const TYPEDESC *tdesc, BOOL alloc_initial_space)
static void *	TLB_CopyTypeDesc (TYPEDESC *dest, const TYPEDESC *src, void *buffer)
static void	TLB_FreeCustData (struct list *custdata_list)
static BSTR	TLB_MultiByteToBSTR (const char *ptr)
static TLBFuncDesc *	TLB_get_funcdesc_by_memberid (TLBFuncDesc *funcdescs, UINT n, MEMBERID memid)
static TLBVarDesc *	TLB_get_vardesc_by_memberid (TLBVarDesc *vardescs, UINT n, MEMBERID memid)
static TLBVarDesc *	TLB_get_vardesc_by_name (TLBVarDesc *vardescs, UINT n, const OLECHAR *name)
static TLBCustData *	TLB_get_custdata_by_guid (struct list *custdata_list, REFGUID guid)
static ITypeInfoImpl *	TLB_get_typeinfo_by_name (ITypeInfoImpl **typeinfos, UINT n, const OLECHAR *name)
static void	TLBVarDesc_Constructor (TLBVarDesc *var_desc)
static TLBVarDesc *	TLBVarDesc_Alloc (UINT n)
static TLBParDesc *	TLBParDesc_Constructor (UINT n)
static void	TLBFuncDesc_Constructor (TLBFuncDesc *func_desc)
static TLBFuncDesc *	TLBFuncDesc_Alloc (UINT n)
static void	TLBImplType_Constructor (TLBImplType *impl)
static TLBImplType *	TLBImplType_Alloc (UINT n)
static TLBGuid *	TLB_append_guid (struct list *guid_list, const GUID *new_guid, HREFTYPE hreftype)
static HRESULT	TLB_set_custdata (struct list *custdata_list, TLBGuid *tlbguid, VARIANT *var)
static TLBString *	TLB_append_str (struct list *string_list, BSTR new_str)
static HRESULT	TLB_get_size_from_hreftype (ITypeInfoImpl *info, HREFTYPE href, ULONG *size, WORD *align)
static HRESULT	TLB_size_instance (ITypeInfoImpl *info, SYSKIND sys, TYPEDESC *tdesc, ULONG *size, WORD *align)
static void	MSFT_Seek (TLBContext *pcx, LONG where)
static DWORD	MSFT_Read (void *buffer, DWORD count, TLBContext *pcx, LONG where)
static DWORD	MSFT_ReadLEDWords (void *buffer, DWORD count, TLBContext *pcx, LONG where)
static DWORD	MSFT_ReadLEWords (void *buffer, DWORD count, TLBContext *pcx, LONG where)
static HRESULT	MSFT_ReadAllGuids (TLBContext *pcx)
static TLBGuid *	MSFT_ReadGuid (int offset, TLBContext *pcx)
static HREFTYPE	MSFT_ReadHreftype (TLBContext *pcx, int offset)
static HRESULT	MSFT_ReadAllNames (TLBContext *pcx)
static TLBString *	MSFT_ReadName (TLBContext *pcx, int offset)
static TLBString *	MSFT_ReadString (TLBContext *pcx, int offset)
static void	MSFT_ReadValue (VARIANT *pVar, int offset, TLBContext *pcx)
static int	MSFT_CustData (TLBContext *pcx, int offset, struct list *custdata_list)
static void	MSFT_GetTdesc (TLBContext *pcx, INT type, TYPEDESC *pTd)
static BOOL	TLB_is_propgetput (INVOKEKIND invkind)
static void	MSFT_DoFuncs (TLBContext *pcx, ITypeInfoImpl *pTI, int cFuncs, int cVars, int offset, TLBFuncDesc **pptfd)
static void	MSFT_DoVars (TLBContext *pcx, ITypeInfoImpl *pTI, int cFuncs, int cVars, int offset, TLBVarDesc **pptvd)
static void	MSFT_DoImplTypes (TLBContext *pcx, ITypeInfoImpl *pTI, int count, int offset)
static ITypeInfoImpl *	MSFT_DoTypeInfo (TLBContext *pcx, int count, ITypeLibImpl *pLibInfo)
static HRESULT	MSFT_ReadAllStrings (TLBContext *pcx)
static HRESULT	MSFT_ReadAllRefs (TLBContext *pcx)
static TLB_PEFile *	pefile_impl_from_IUnknown (IUnknown *iface)
static HRESULT WINAPI	TLB_PEFile_QueryInterface (IUnknown *iface, REFIID riid, void **ppv)
static ULONG WINAPI	TLB_PEFile_AddRef (IUnknown *iface)
static ULONG WINAPI	TLB_PEFile_Release (IUnknown *iface)
static HRESULT	TLB_PEFile_Open (LPCWSTR path, INT index, LPVOID *ppBase, DWORD *pdwTLBLength, IUnknown **ppFile)
static TLB_NEFile *	nefile_impl_from_IUnknown (IUnknown *iface)
static HRESULT WINAPI	TLB_NEFile_QueryInterface (IUnknown *iface, REFIID riid, void **ppv)
static ULONG WINAPI	TLB_NEFile_AddRef (IUnknown *iface)
static ULONG WINAPI	TLB_NEFile_Release (IUnknown *iface)
static int	read_xx_header (HFILE lzfd)
static BOOL	find_ne_resource (HFILE lzfd, LPCSTR typeid, LPCSTR resid, DWORD *resLen, DWORD *resOff)
static HRESULT	TLB_NEFile_Open (LPCWSTR path, INT index, LPVOID *ppBase, DWORD *pdwTLBLength, IUnknown **ppFile)
static TLB_Mapping *	mapping_impl_from_IUnknown (IUnknown *iface)
static HRESULT WINAPI	TLB_Mapping_QueryInterface (IUnknown *iface, REFIID riid, void **ppv)
static ULONG WINAPI	TLB_Mapping_AddRef (IUnknown *iface)
static ULONG WINAPI	TLB_Mapping_Release (IUnknown *iface)
static HRESULT	TLB_Mapping_Open (LPCWSTR path, LPVOID *ppBase, DWORD *pdwTLBLength, IUnknown **ppFile)
static ITypeLibImpl *	TypeLibImpl_Constructor (void)
static BOOL	TLB_GUIDFromString (const char *str, GUID *guid)
static const char *	lookup_code (const BYTE *table, DWORD table_size, struct bitstream *bits)
static const TLBString *	decode_string (const BYTE *table, const char *stream, DWORD stream_length, ITypeLibImpl *lib)
static WORD	SLTG_ReadString (const char *ptr, const TLBString **pStr, ITypeLibImpl *lib)
static WORD	SLTG_ReadStringA (const char *ptr, char **str)
static TLBString *	SLTG_ReadName (const char *pNameTable, int offset, ITypeLibImpl *lib)
static DWORD	SLTG_ReadLibBlk (LPVOID pLibBlk, ITypeLibImpl *pTypeLibImpl)
static HRESULT	sltg_get_typelib_ref (const sltg_ref_lookup_t *table, DWORD typeinfo_ref, HREFTYPE *typelib_ref)
static WORD *	SLTG_DoType (WORD *pType, char *pBlk, TYPEDESC *pTD, const sltg_ref_lookup_t *ref_lookup)
static WORD *	SLTG_DoElem (WORD *pType, char *pBlk, ELEMDESC *pElem, const sltg_ref_lookup_t *ref_lookup)
static sltg_ref_lookup_t *	SLTG_DoRefs (SLTG_RefInfo *pRef, ITypeLibImpl *pTL, char *pNameTable)
static char *	SLTG_DoImpls (char *pBlk, ITypeInfoImpl *pTI, BOOL OneOnly, const sltg_ref_lookup_t *ref_lookup)
static void	SLTG_DoVars (char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsigned short cVars, const char *pNameTable, const sltg_ref_lookup_t *ref_lookup, const BYTE *hlp_strings)
static void	SLTG_DoFuncs (char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsigned short cFuncs, char *pNameTable, const sltg_ref_lookup_t *ref_lookup, const BYTE *hlp_strings)
static void	SLTG_ProcessCoClass (char *pBlk, ITypeInfoImpl *pTI, char *pNameTable, SLTG_TypeInfoHeader *pTIHeader, SLTG_TypeInfoTail *pTITail)
static void	SLTG_ProcessInterface (char *pBlk, ITypeInfoImpl *pTI, char *pNameTable, SLTG_TypeInfoHeader *pTIHeader, const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings)
static void	SLTG_ProcessRecord (char *pBlk, ITypeInfoImpl *pTI, const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader, const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings)
static void	SLTG_ProcessAlias (char *pBlk, ITypeInfoImpl *pTI, char *pNameTable, SLTG_TypeInfoHeader *pTIHeader, const SLTG_TypeInfoTail *pTITail)
static void	SLTG_ProcessDispatch (char *pBlk, ITypeInfoImpl *pTI, char *pNameTable, SLTG_TypeInfoHeader *pTIHeader, const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings)
static void	SLTG_ProcessEnum (char *pBlk, ITypeInfoImpl *pTI, const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader, const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings)
static void	SLTG_ProcessModule (char *pBlk, ITypeInfoImpl *pTI, char *pNameTable, SLTG_TypeInfoHeader *pTIHeader, const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings)
static HRESULT WINAPI	ITypeLib2_fnQueryInterface (ITypeLib2 *iface, REFIID riid, void **ppv)
static ULONG WINAPI	ITypeLib2_fnAddRef (ITypeLib2 *iface)
static ULONG WINAPI	ITypeLib2_fnRelease (ITypeLib2 *iface)
static UINT WINAPI	ITypeLib2_fnGetTypeInfoCount (ITypeLib2 *iface)
static HRESULT WINAPI	ITypeLib2_fnGetTypeInfo (ITypeLib2 *iface, UINT index, ITypeInfo **ppTInfo)
static HRESULT WINAPI	ITypeLib2_fnGetTypeInfoType (ITypeLib2 *iface, UINT index, TYPEKIND *pTKind)
static HRESULT WINAPI	ITypeLib2_fnGetTypeInfoOfGuid (ITypeLib2 *iface, REFGUID guid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	ITypeLib2_fnGetLibAttr (ITypeLib2 *iface, LPTLIBATTR *attr)
static HRESULT WINAPI	ITypeLib2_fnGetTypeComp (ITypeLib2 *iface, ITypeComp **ppTComp)
static HRESULT WINAPI	ITypeLib2_fnGetDocumentation (ITypeLib2 *iface, INT index, BSTR *pBstrName, BSTR *pBstrDocString, DWORD *pdwHelpContext, BSTR *pBstrHelpFile)
static HRESULT WINAPI	ITypeLib2_fnIsName (ITypeLib2 *iface, LPOLESTR szNameBuf, ULONG lHashVal, BOOL *pfName)
static HRESULT WINAPI	ITypeLib2_fnFindName (ITypeLib2 *iface, LPOLESTR name, ULONG hash, ITypeInfo **ppTInfo, MEMBERID *memid, UINT16 *found)
static VOID WINAPI	ITypeLib2_fnReleaseTLibAttr (ITypeLib2 *iface, TLIBATTR *pTLibAttr)
static HRESULT WINAPI	ITypeLib2_fnGetCustData (ITypeLib2 *iface, REFGUID guid, VARIANT *pVarVal)
static HRESULT WINAPI	ITypeLib2_fnGetLibStatistics (ITypeLib2 *iface, ULONG *pcUniqueNames, ULONG *pcchUniqueNames)
static HRESULT WINAPI	ITypeLib2_fnGetDocumentation2 (ITypeLib2 *iface, INT index, LCID lcid, BSTR *pbstrHelpString, DWORD *pdwHelpStringContext, BSTR *pbstrHelpStringDll)
static HRESULT	TLB_copy_all_custdata (struct list *custdata_list, CUSTDATA *pCustData)
static HRESULT WINAPI	ITypeLib2_fnGetAllCustData (ITypeLib2 *iface, CUSTDATA *pCustData)
static HRESULT WINAPI	ITypeLibComp_fnQueryInterface (ITypeComp *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	ITypeLibComp_fnAddRef (ITypeComp *iface)
static ULONG WINAPI	ITypeLibComp_fnRelease (ITypeComp *iface)
static HRESULT WINAPI	ITypeLibComp_fnBind (ITypeComp *iface, OLECHAR *szName, ULONG lHash, WORD wFlags, ITypeInfo **ppTInfo, DESCKIND *pDescKind, BINDPTR *pBindPtr)
static HRESULT WINAPI	ITypeLibComp_fnBindType (ITypeComp *iface, OLECHAR *szName, ULONG lHash, ITypeInfo **ppTInfo, ITypeComp **ppTComp)
static HRESULT WINAPI	ITypeInfo_fnQueryInterface (ITypeInfo2 *iface, REFIID riid, VOID **ppvObject)
static ULONG WINAPI	ITypeInfo_fnAddRef (ITypeInfo2 *iface)
static ULONG WINAPI	ITypeInfo_fnRelease (ITypeInfo2 *iface)
static HRESULT WINAPI	ITypeInfo_fnGetTypeAttr (ITypeInfo2 *iface, LPTYPEATTR *ppTypeAttr)
static HRESULT WINAPI	ITypeInfo_fnGetTypeComp (ITypeInfo2 *iface, ITypeComp **ppTComp)
static SIZE_T	TLB_SizeElemDesc (const ELEMDESC *elemdesc)
static HRESULT	TLB_CopyElemDesc (const ELEMDESC *src, ELEMDESC *dest, char **buffer)
static HRESULT	TLB_SanitizeBSTR (BSTR str)
static HRESULT	TLB_SanitizeVariant (VARIANT *var)
static void	TLB_FreeElemDesc (ELEMDESC *elemdesc)
static HRESULT	TLB_AllocAndInitFuncDesc (const FUNCDESC *src, FUNCDESC **dest_ptr, BOOL dispinterface)
HRESULT	ITypeInfoImpl_GetInternalFuncDesc (ITypeInfo *iface, UINT index, const FUNCDESC **ppFuncDesc)
static HRESULT	ITypeInfoImpl_GetInternalDispatchFuncDesc (ITypeInfo *iface, UINT index, const FUNCDESC **ppFuncDesc, UINT *funcs, UINT *hrefoffset)
static void	ITypeInfoImpl_ElemDescAddHrefOffset (LPELEMDESC pElemDesc, UINT hrefoffset)
static void	ITypeInfoImpl_FuncDescAddHrefOffset (LPFUNCDESC pFuncDesc, UINT hrefoffset)
static HRESULT WINAPI	ITypeInfo_fnGetFuncDesc (ITypeInfo2 *iface, UINT index, LPFUNCDESC *ppFuncDesc)
static HRESULT WINAPI	ITypeInfo_fnGetVarDesc (ITypeInfo2 *iface, UINT index, LPVARDESC *ppVarDesc)
static HRESULT WINAPI	ITypeInfo_fnGetNames (ITypeInfo2 *iface, MEMBERID memid, BSTR *rgBstrNames, UINT cMaxNames, UINT *pcNames)
static HRESULT WINAPI	ITypeInfo_fnGetRefTypeOfImplType (ITypeInfo2 *iface, UINT index, HREFTYPE *pRefType)
static HRESULT WINAPI	ITypeInfo_fnGetImplTypeFlags (ITypeInfo2 *iface, UINT index, INT *pImplTypeFlags)
static HRESULT WINAPI	ITypeInfo_fnGetIDsOfNames (ITypeInfo2 *iface, LPOLESTR *rgszNames, UINT cNames, MEMBERID *pMemId)
HRESULT WINAPI	DispCallFunc (void *pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, UINT cActuals, VARTYPE *prgvt, VARIANTARG **prgpvarg, VARIANT *pvargResult)
static HRESULT	userdefined_to_variantvt (ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
static HRESULT	get_iface_guid (ITypeInfo *tinfo, HREFTYPE href, GUID *guid)
static BOOL	func_restricted (const FUNCDESC *desc)
static HRESULT WINAPI	ITypeInfo_fnInvoke (ITypeInfo2 *iface, VOID *pIUnk, MEMBERID memid, UINT16 wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *pArgErr)
static HRESULT WINAPI	ITypeInfo_fnGetDocumentation (ITypeInfo2 *iface, MEMBERID memid, BSTR *pBstrName, BSTR *pBstrDocString, DWORD *pdwHelpContext, BSTR *pBstrHelpFile)
static HRESULT WINAPI	ITypeInfo_fnGetDllEntry (ITypeInfo2 *iface, MEMBERID memid, INVOKEKIND invKind, BSTR *pBstrDllName, BSTR *pBstrName, WORD *pwOrdinal)
static HRESULT	ITypeInfoImpl_GetDispatchRefTypeInfo (ITypeInfo *iface, HREFTYPE *hRefType, ITypeInfo **ppTInfo)
static BOOL CALLBACK	search_res_tlb (HMODULE hModule, LPCWSTR lpszType, LPWSTR lpszName, LONG_PTR lParam)
static HRESULT WINAPI	ITypeInfo_fnGetRefTypeInfo (ITypeInfo2 *iface, HREFTYPE hRefType, ITypeInfo **ppTInfo)
static HRESULT WINAPI	ITypeInfo_fnAddressOfMember (ITypeInfo2 *iface, MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
static HRESULT WINAPI	ITypeInfo_fnCreateInstance (ITypeInfo2 *iface, IUnknown *pOuterUnk, REFIID riid, VOID **ppvObj)
static HRESULT WINAPI	ITypeInfo_fnGetMops (ITypeInfo2 *iface, MEMBERID memid, BSTR *pBstrMops)
static HRESULT WINAPI	ITypeInfo_fnGetContainingTypeLib (ITypeInfo2 *iface, ITypeLib **ppTLib, UINT *pIndex)
static void WINAPI	ITypeInfo_fnReleaseTypeAttr (ITypeInfo2 *iface, TYPEATTR *pTypeAttr)
static void WINAPI	ITypeInfo_fnReleaseFuncDesc (ITypeInfo2 *iface, FUNCDESC *pFuncDesc)
static void WINAPI	ITypeInfo_fnReleaseVarDesc (ITypeInfo2 *iface, VARDESC *pVarDesc)
static HRESULT WINAPI	ITypeInfo2_fnGetTypeKind (ITypeInfo2 *iface, TYPEKIND *pTypeKind)
static HRESULT WINAPI	ITypeInfo2_fnGetTypeFlags (ITypeInfo2 *iface, ULONG *pTypeFlags)
static HRESULT WINAPI	ITypeInfo2_fnGetFuncIndexOfMemId (ITypeInfo2 *iface, MEMBERID memid, INVOKEKIND invKind, UINT *pFuncIndex)
static HRESULT WINAPI	ITypeInfo2_fnGetVarIndexOfMemId (ITypeInfo2 *iface, MEMBERID memid, UINT *pVarIndex)
static HRESULT WINAPI	ITypeInfo2_fnGetCustData (ITypeInfo2 *iface, REFGUID guid, VARIANT *pVarVal)
static HRESULT WINAPI	ITypeInfo2_fnGetFuncCustData (ITypeInfo2 *iface, UINT index, REFGUID guid, VARIANT *pVarVal)
static HRESULT WINAPI	ITypeInfo2_fnGetParamCustData (ITypeInfo2 *iface, UINT indexFunc, UINT indexParam, REFGUID guid, VARIANT *pVarVal)
static HRESULT WINAPI	ITypeInfo2_fnGetVarCustData (ITypeInfo2 *iface, UINT index, REFGUID guid, VARIANT *pVarVal)
static HRESULT WINAPI	ITypeInfo2_fnGetImplTypeCustData (ITypeInfo2 *iface, UINT index, REFGUID guid, VARIANT *pVarVal)
static HRESULT WINAPI	ITypeInfo2_fnGetDocumentation2 (ITypeInfo2 *iface, MEMBERID memid, LCID lcid, BSTR *pbstrHelpString, DWORD *pdwHelpStringContext, BSTR *pbstrHelpStringDll)
static HRESULT WINAPI	ITypeInfo2_fnGetAllCustData (ITypeInfo2 *iface, CUSTDATA *pCustData)
static HRESULT WINAPI	ITypeInfo2_fnGetAllFuncCustData (ITypeInfo2 *iface, UINT index, CUSTDATA *pCustData)
static HRESULT WINAPI	ITypeInfo2_fnGetAllParamCustData (ITypeInfo2 *iface, UINT indexFunc, UINT indexParam, CUSTDATA *pCustData)
static HRESULT WINAPI	ITypeInfo2_fnGetAllVarCustData (ITypeInfo2 *iface, UINT index, CUSTDATA *pCustData)
static HRESULT WINAPI	ITypeInfo2_fnGetAllImplTypeCustData (ITypeInfo2 *iface, UINT index, CUSTDATA *pCustData)
HRESULT WINAPI	CreateDispTypeInfo (INTERFACEDATA *pidata, LCID lcid, ITypeInfo **pptinfo)
static HRESULT WINAPI	ITypeComp_fnQueryInterface (ITypeComp *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	ITypeComp_fnAddRef (ITypeComp *iface)
static ULONG WINAPI	ITypeComp_fnRelease (ITypeComp *iface)
static HRESULT WINAPI	ITypeComp_fnBind (ITypeComp *iface, OLECHAR *szName, ULONG lHash, WORD wFlags, ITypeInfo **ppTInfo, DESCKIND *pDescKind, BINDPTR *pBindPtr)
static HRESULT WINAPI	ITypeComp_fnBindType (ITypeComp *iface, OLECHAR *szName, ULONG lHash, ITypeInfo **ppTInfo, ITypeComp **ppTComp)
HRESULT WINAPI	CreateTypeLib2 (SYSKIND syskind, LPCOLESTR szFile, ICreateTypeLib2 **ppctlib)
static HRESULT WINAPI	ICreateTypeLib2_fnQueryInterface (ICreateTypeLib2 *iface, REFIID riid, void **object)
static ULONG WINAPI	ICreateTypeLib2_fnAddRef (ICreateTypeLib2 *iface)
static ULONG WINAPI	ICreateTypeLib2_fnRelease (ICreateTypeLib2 *iface)
static HRESULT WINAPI	ICreateTypeLib2_fnCreateTypeInfo (ICreateTypeLib2 *iface, LPOLESTR name, TYPEKIND kind, ICreateTypeInfo **ctinfo)
static HRESULT WINAPI	ICreateTypeLib2_fnSetName (ICreateTypeLib2 *iface, LPOLESTR name)
static HRESULT WINAPI	ICreateTypeLib2_fnSetVersion (ICreateTypeLib2 *iface, WORD majorVerNum, WORD minorVerNum)
static HRESULT WINAPI	ICreateTypeLib2_fnSetGuid (ICreateTypeLib2 *iface, REFGUID guid)
static HRESULT WINAPI	ICreateTypeLib2_fnSetDocString (ICreateTypeLib2 *iface, LPOLESTR doc)
static HRESULT WINAPI	ICreateTypeLib2_fnSetHelpFileName (ICreateTypeLib2 *iface, LPOLESTR helpFileName)
static HRESULT WINAPI	ICreateTypeLib2_fnSetHelpContext (ICreateTypeLib2 *iface, DWORD helpContext)
static HRESULT WINAPI	ICreateTypeLib2_fnSetLcid (ICreateTypeLib2 *iface, LCID lcid)
static HRESULT WINAPI	ICreateTypeLib2_fnSetLibFlags (ICreateTypeLib2 *iface, UINT libFlags)
static HRESULT	WMSFT_compile_strings (ITypeLibImpl *This, WMSFT_TLBFile *file)
static HRESULT	WMSFT_compile_names (ITypeLibImpl *This, WMSFT_TLBFile *file)
static int	hash_guid (GUID *guid)
static HRESULT	WMSFT_compile_guids (ITypeLibImpl *This, WMSFT_TLBFile *file)
static DWORD	WMSFT_encode_variant (VARIANT *value, WMSFT_TLBFile *file)
static DWORD	WMSFT_append_typedesc (TYPEDESC *desc, WMSFT_TLBFile *file, DWORD *out_mix, INT16 *out_size)
static DWORD	WMSFT_append_arraydesc (ARRAYDESC *desc, WMSFT_TLBFile *file)
static DWORD	WMSFT_compile_custdata (struct list *custdata_list, WMSFT_TLBFile *file)
static DWORD	WMSFT_compile_typeinfo_aux (ITypeInfoImpl *info, WMSFT_TLBFile *file)
static DWORD	WMSFT_compile_typeinfo_ref (ITypeInfoImpl *info, WMSFT_TLBFile *file)
static DWORD	WMSFT_compile_typeinfo (ITypeInfoImpl *info, INT16 index, WMSFT_TLBFile *file, char *data)
static void	WMSFT_compile_typeinfo_seg (ITypeLibImpl *This, WMSFT_TLBFile *file, DWORD *junk)
static void	WMSFT_compile_impfile (ITypeLibImpl *This, WMSFT_TLBFile *file)
static void	WMSFT_compile_impinfo (ITypeLibImpl *This, WMSFT_TLBFile *file)
static void	WMSFT_compile_guidhash (ITypeLibImpl *This, WMSFT_TLBFile *file)
static void	WMSFT_compile_namehash (ITypeLibImpl *This, WMSFT_TLBFile *file)
static void	tmp_fill_segdir_seg (MSFT_pSeg *segdir, WMSFT_SegContents *contents, DWORD *running_offset)
static void	WMSFT_write_segment (HANDLE outfile, WMSFT_SegContents *segment)
static HRESULT	WMSFT_fixup_typeinfos (ITypeLibImpl *This, WMSFT_TLBFile *file, DWORD file_len)
static void	WMSFT_free_file (WMSFT_TLBFile *file)
static HRESULT WINAPI	ICreateTypeLib2_fnSaveAllChanges (ICreateTypeLib2 *iface)
static HRESULT WINAPI	ICreateTypeLib2_fnDeleteTypeInfo (ICreateTypeLib2 *iface, LPOLESTR name)
static HRESULT WINAPI	ICreateTypeLib2_fnSetCustData (ICreateTypeLib2 *iface, REFGUID guid, VARIANT *varVal)
static HRESULT WINAPI	ICreateTypeLib2_fnSetHelpStringContext (ICreateTypeLib2 *iface, ULONG helpStringContext)
static HRESULT WINAPI	ICreateTypeLib2_fnSetHelpStringDll (ICreateTypeLib2 *iface, LPOLESTR filename)
static HRESULT WINAPI	ICreateTypeInfo2_fnQueryInterface (ICreateTypeInfo2 *iface, REFIID riid, void **object)
static ULONG WINAPI	ICreateTypeInfo2_fnAddRef (ICreateTypeInfo2 *iface)
static ULONG WINAPI	ICreateTypeInfo2_fnRelease (ICreateTypeInfo2 *iface)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetGuid (ICreateTypeInfo2 *iface, REFGUID guid)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetTypeFlags (ICreateTypeInfo2 *iface, UINT typeFlags)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetDocString (ICreateTypeInfo2 *iface, LPOLESTR doc)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetHelpContext (ICreateTypeInfo2 *iface, DWORD helpContext)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetVersion (ICreateTypeInfo2 *iface, WORD majorVerNum, WORD minorVerNum)
static HRESULT WINAPI	ICreateTypeInfo2_fnAddRefTypeInfo (ICreateTypeInfo2 *iface, ITypeInfo *typeInfo, HREFTYPE *refType)
static HRESULT WINAPI	ICreateTypeInfo2_fnAddFuncDesc (ICreateTypeInfo2 *iface, UINT index, FUNCDESC *funcDesc)
static HRESULT WINAPI	ICreateTypeInfo2_fnAddImplType (ICreateTypeInfo2 *iface, UINT index, HREFTYPE refType)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetImplTypeFlags (ICreateTypeInfo2 *iface, UINT index, INT implTypeFlags)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetAlignment (ICreateTypeInfo2 *iface, WORD alignment)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetSchema (ICreateTypeInfo2 *iface, LPOLESTR schema)
static HRESULT WINAPI	ICreateTypeInfo2_fnAddVarDesc (ICreateTypeInfo2 *iface, UINT index, VARDESC *varDesc)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetFuncAndParamNames (ICreateTypeInfo2 *iface, UINT index, LPOLESTR *names, UINT numNames)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetVarName (ICreateTypeInfo2 *iface, UINT index, LPOLESTR name)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetTypeDescAlias (ICreateTypeInfo2 *iface, TYPEDESC *tdescAlias)
static HRESULT WINAPI	ICreateTypeInfo2_fnDefineFuncAsDllEntry (ICreateTypeInfo2 *iface, UINT index, LPOLESTR dllName, LPOLESTR procName)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetFuncDocString (ICreateTypeInfo2 *iface, UINT index, LPOLESTR docString)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetVarDocString (ICreateTypeInfo2 *iface, UINT index, LPOLESTR docString)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetFuncHelpContext (ICreateTypeInfo2 *iface, UINT index, DWORD helpContext)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetVarHelpContext (ICreateTypeInfo2 *iface, UINT index, DWORD helpContext)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetMops (ICreateTypeInfo2 *iface, UINT index, BSTR bstrMops)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetTypeIdldesc (ICreateTypeInfo2 *iface, IDLDESC *idlDesc)
static HRESULT WINAPI	ICreateTypeInfo2_fnLayOut (ICreateTypeInfo2 *iface)
static HRESULT WINAPI	ICreateTypeInfo2_fnDeleteFuncDesc (ICreateTypeInfo2 *iface, UINT index)
static HRESULT WINAPI	ICreateTypeInfo2_fnDeleteFuncDescByMemId (ICreateTypeInfo2 *iface, MEMBERID memid, INVOKEKIND invKind)
static HRESULT WINAPI	ICreateTypeInfo2_fnDeleteVarDesc (ICreateTypeInfo2 *iface, UINT index)
static HRESULT WINAPI	ICreateTypeInfo2_fnDeleteVarDescByMemId (ICreateTypeInfo2 *iface, MEMBERID memid)
static HRESULT WINAPI	ICreateTypeInfo2_fnDeleteImplType (ICreateTypeInfo2 *iface, UINT index)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetCustData (ICreateTypeInfo2 *iface, REFGUID guid, VARIANT *varVal)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetFuncCustData (ICreateTypeInfo2 *iface, UINT index, REFGUID guid, VARIANT *varVal)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetParamCustData (ICreateTypeInfo2 *iface, UINT funcIndex, UINT paramIndex, REFGUID guid, VARIANT *varVal)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetVarCustData (ICreateTypeInfo2 *iface, UINT index, REFGUID guid, VARIANT *varVal)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetImplTypeCustData (ICreateTypeInfo2 *iface, UINT index, REFGUID guid, VARIANT *varVal)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetHelpStringContext (ICreateTypeInfo2 *iface, ULONG helpStringContext)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetFuncHelpStringContext (ICreateTypeInfo2 *iface, UINT index, ULONG helpStringContext)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetVarHelpStringContext (ICreateTypeInfo2 *iface, UINT index, ULONG helpStringContext)
static HRESULT WINAPI	ICreateTypeInfo2_fnInvalidate (ICreateTypeInfo2 *iface)
static HRESULT WINAPI	ICreateTypeInfo2_fnSetName (ICreateTypeInfo2 *iface, LPOLESTR name)
void WINAPI	ClearCustData (CUSTDATA *lpCust)

Variables
static const WCHAR	TypeLibW [] = {'T','y','p','e','L','i','b',0}
static const WCHAR	FLAGSW [] = {'F','L','A','G','S',0}
static const WCHAR	HELPDIRW [] = {'H','E','L','P','D','I','R',0}
static const WCHAR	ProxyStubClsidW [] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d',0}
static const WCHAR	ProxyStubClsid32W [] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0}
static const ITypeLib2Vtbl	tlbvt
static const ITypeCompVtbl	tlbtcvt
static const ICreateTypeLib2Vtbl	CreateTypeLib2Vtbl
static const ITypeInfo2Vtbl	tinfvt
static const ITypeCompVtbl	tcompvt
static const ICreateTypeInfo2Vtbl	CreateTypeInfo2Vtbl
static const char *const	typekind_desc []
static TYPEDESC	std_typedesc [VT_LPWSTR+1]
static struct list	tlb_cache = LIST_INIT(tlb_cache)
static CRITICAL_SECTION	cache_section = { &cache_section_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	cache_section_debug
static const IUnknownVtbl	TLB_PEFile_Vtable
static const IUnknownVtbl	TLB_NEFile_Vtable
static const IUnknownVtbl	TLB_Mapping_Vtable

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 56 of file typelib.c.

DISPATCH_HREF_MASK

#define DISPATCH_HREF_MASK   0xff000000

Definition at line 130 of file typelib.c.

DISPATCH_HREF_OFFSET

#define DISPATCH_HREF_OFFSET   0x01000000

Definition at line 129 of file typelib.c.

FromLEDWord

#define FromLEDWord

(

X

)

(X)

Definition at line 126 of file typelib.c.

FromLEDWords

#define FromLEDWords	(		X,
			Y
	)		/*nothing*/

Definition at line 166 of file typelib.c.

FromLEWord

#define FromLEWord

(

X

)

(X)

Definition at line 125 of file typelib.c.

FromLEWords

#define FromLEWords	(		X,
			Y
	)		/*nothing*/

Definition at line 165 of file typelib.c.

INVBUF_ELEMENT_SIZE

#define INVBUF_ELEMENT_SIZE    (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *) + sizeof(VARTYPE))

Definition at line 7273 of file typelib.c.

INVBUF_GET_ARG_ARRAY

#define INVBUF_GET_ARG_ARRAY	(		buffer,
			params
	)		(buffer)

Definition at line 7275 of file typelib.c.

INVBUF_GET_ARG_PTR_ARRAY

#define INVBUF_GET_ARG_PTR_ARRAY	(		buffer,
			params
	)		((VARIANTARG **)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG)) * (params)))

Definition at line 7278 of file typelib.c.

INVBUF_GET_ARG_TYPE_ARRAY

#define INVBUF_GET_ARG_TYPE_ARRAY	(		buffer,
			params
	)		((VARTYPE *)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *)) * (params)))

Definition at line 7280 of file typelib.c.

INVBUF_GET_MISSING_ARG_ARRAY

#define INVBUF_GET_MISSING_ARG_ARRAY	(		buffer,
			params
	)		((VARIANTARG *)((char *)(buffer) + sizeof(VARIANTARG) * (params)))

Definition at line 7276 of file typelib.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 57 of file typelib.c.

SLTG_SIGNATURE

#define SLTG_SIGNATURE   0x47544c53 /* "SLTG" */

Definition at line 3285 of file typelib.c.

TLB_REF_INTERNAL

#define TLB_REF_INTERNAL   (void*)-2

Definition at line 1196 of file typelib.c.

TLB_REF_NOT_FOUND

#define TLB_REF_NOT_FOUND   (void*)-1

Definition at line 1197 of file typelib.c.

TLB_REF_USE_GUID

#define TLB_REF_USE_GUID   -2

Definition at line 1194 of file typelib.c.

X

#define X

(

x

)

TRACE_(typelib)("tt "#x": %x\n",pTITail->res##x);

XX

#define XX

(

x

)

if (TYPEFLAG_##x & tattr->wTypeFlags) MESSAGE(#x"|");

Typedef Documentation

ITypeInfoImpl

typedef struct tagITypeInfoImpl ITypeInfoImpl

ITypeLibImpl

typedef struct tagITypeLibImpl ITypeLibImpl

TLB_Mapping

typedef struct TLB_Mapping TLB_Mapping

TLB_NEFile

typedef struct TLB_NEFile TLB_NEFile

TLB_PEFile

typedef struct TLB_PEFile TLB_PEFile

TLBContext

typedef struct tagTLBContext TLBContext

TLBCustData

typedef struct tagTLBCustData TLBCustData

TLBFuncDesc

typedef struct tagTLBFuncDesc TLBFuncDesc

TLBGuid

typedef struct tagTLBGuid TLBGuid

TLBImpLib

typedef struct tagTLBImpLib TLBImpLib

TLBImplType

typedef struct tagTLBImplType TLBImplType

TLBParDesc

typedef struct tagTLBParDesc TLBParDesc

TLBRefType

typedef struct tagTLBRefType TLBRefType

TLBString

typedef struct tagTLBString TLBString

TLBVarDesc

typedef struct tagTLBVarDesc TLBVarDesc

WMSFT_ImpFile

typedef struct tagWMSFT_ImpFile WMSFT_ImpFile

WMSFT_RefChunk

typedef struct tagWMSFT_RefChunk WMSFT_RefChunk

WMSFT_SegContents

typedef struct tagWMSFT_SegContents WMSFT_SegContents

WMSFT_TLBFile

typedef struct tagWMSFT_TLBFile WMSFT_TLBFile

Function Documentation

ClearCustData()

void WINAPI ClearCustData

(

CUSTDATA *

lpCust

)

Definition at line 11635 of file typelib.c.

{
    if (lpCust && lpCust->cCustData)
    {
        if (lpCust->prgCustData)
        {
            DWORD i;
 
            for (i = 0; i < lpCust->cCustData; i++)
                VariantClear(&lpCust->prgCustData[i].varValue);
 
            CoTaskMemFree(lpCust->prgCustData);
            lpCust->prgCustData = NULL;
        }
        lpCust->cCustData = 0;
    }
}

Referenced by test_ClearCustData().

CreateDispTypeInfo()

HRESULT WINAPI CreateDispTypeInfo	(	INTERFACEDATA *	pidata,
		LCID	lcid,
		ITypeInfo **	pptinfo
	)

Definition at line 8792 of file typelib.c.

{
    ITypeInfoImpl *pTIClass, *pTIIface;
    ITypeLibImpl *pTypeLibImpl;
    unsigned int param, func;
    TLBFuncDesc *pFuncDesc;
    TLBRefType *ref;
 
    TRACE("\n");
    pTypeLibImpl = TypeLibImpl_Constructor();
    if (!pTypeLibImpl) return E_FAIL;
 
    pTypeLibImpl->TypeInfoCount = 2;
    pTypeLibImpl->typeinfos = heap_alloc_zero(pTypeLibImpl->TypeInfoCount * sizeof(ITypeInfoImpl*));
 
    pTIIface = pTypeLibImpl->typeinfos[0] = ITypeInfoImpl_Constructor();
    pTIIface->pTypeLib = pTypeLibImpl;
    pTIIface->index = 0;
    pTIIface->Name = NULL;
    pTIIface->dwHelpContext = -1;
    pTIIface->guid = NULL;
    pTIIface->typeattr.lcid = lcid;
    pTIIface->typeattr.typekind = TKIND_INTERFACE;
    pTIIface->typeattr.wMajorVerNum = 0;
    pTIIface->typeattr.wMinorVerNum = 0;
    pTIIface->typeattr.cbAlignment = 2;
    pTIIface->typeattr.cbSizeInstance = -1;
    pTIIface->typeattr.cbSizeVft = -1;
    pTIIface->typeattr.cFuncs = 0;
    pTIIface->typeattr.cImplTypes = 0;
    pTIIface->typeattr.cVars = 0;
    pTIIface->typeattr.wTypeFlags = 0;
    pTIIface->hreftype = 0;
 
    pTIIface->funcdescs = TLBFuncDesc_Alloc(pidata->cMembers);
    pFuncDesc = pTIIface->funcdescs;
    for(func = 0; func < pidata->cMembers; func++) {
        METHODDATA *md = pidata->pmethdata + func;
        pFuncDesc->Name = TLB_append_str(&pTypeLibImpl->name_list, md->szName);
        pFuncDesc->funcdesc.memid = md->dispid;
        pFuncDesc->funcdesc.lprgscode = NULL;
        pFuncDesc->funcdesc.funckind = FUNC_VIRTUAL;
        pFuncDesc->funcdesc.invkind = md->wFlags;
        pFuncDesc->funcdesc.callconv = md->cc;
        pFuncDesc->funcdesc.cParams = md->cArgs;
        pFuncDesc->funcdesc.cParamsOpt = 0;
        pFuncDesc->funcdesc.oVft = md->iMeth * sizeof(void *);
        pFuncDesc->funcdesc.cScodes = 0;
        pFuncDesc->funcdesc.wFuncFlags = 0;
        pFuncDesc->funcdesc.elemdescFunc.tdesc.vt = md->vtReturn;
        pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.wParamFlags = PARAMFLAG_NONE;
        pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.pparamdescex = NULL;
        pFuncDesc->funcdesc.lprgelemdescParam = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                                                              md->cArgs * sizeof(ELEMDESC));
        pFuncDesc->pParamDesc = TLBParDesc_Constructor(md->cArgs);
        for(param = 0; param < md->cArgs; param++) {
            pFuncDesc->funcdesc.lprgelemdescParam[param].tdesc.vt = md->ppdata[param].vt;
            pFuncDesc->pParamDesc[param].Name = TLB_append_str(&pTypeLibImpl->name_list, md->ppdata[param].szName);
        }
        pFuncDesc->helpcontext = 0;
        pFuncDesc->HelpStringContext = 0;
        pFuncDesc->HelpString = NULL;
        pFuncDesc->Entry = NULL;
        list_init(&pFuncDesc->custdata_list);
        pTIIface->typeattr.cFuncs++;
        ++pFuncDesc;
    }
 
    dump_TypeInfo(pTIIface);
 
    pTIClass = pTypeLibImpl->typeinfos[1] = ITypeInfoImpl_Constructor();
    pTIClass->pTypeLib = pTypeLibImpl;
    pTIClass->index = 1;
    pTIClass->Name = NULL;
    pTIClass->dwHelpContext = -1;
    pTIClass->guid = NULL;
    pTIClass->typeattr.lcid = lcid;
    pTIClass->typeattr.typekind = TKIND_COCLASS;
    pTIClass->typeattr.wMajorVerNum = 0;
    pTIClass->typeattr.wMinorVerNum = 0;
    pTIClass->typeattr.cbAlignment = 2;
    pTIClass->typeattr.cbSizeInstance = -1;
    pTIClass->typeattr.cbSizeVft = -1;
    pTIClass->typeattr.cFuncs = 0;
    pTIClass->typeattr.cImplTypes = 1;
    pTIClass->typeattr.cVars = 0;
    pTIClass->typeattr.wTypeFlags = 0;
    pTIClass->hreftype = sizeof(MSFT_TypeInfoBase);
 
    pTIClass->impltypes = TLBImplType_Alloc(1);
 
    ref = heap_alloc_zero(sizeof(*ref));
    ref->pImpTLInfo = TLB_REF_INTERNAL;
    list_add_head(&pTypeLibImpl->ref_list, &ref->entry);
 
    dump_TypeInfo(pTIClass);
 
    *pptinfo = (ITypeInfo *)&pTIClass->ITypeInfo2_iface;
 
    ITypeInfo_AddRef(*pptinfo);
    ITypeLib2_Release(&pTypeLibImpl->ITypeLib2_iface);
 
    return S_OK;
 
}

Referenced by test_CreateDispTypeInfo().

CreateTypeLib()

HRESULT WINAPI CreateTypeLib	(	SYSKIND	syskind,
		LPCOLESTR	file,
		ICreateTypeLib **	ctlib
	)

Definition at line 425 of file typelib.c.

{
    ICreateTypeLib2 *typelib2;
    HRESULT hres;
 
    FIXME("(%d, %s, %p): forwarding to CreateTypeLib2\n", syskind, debugstr_w(file), ctlib);
 
    hres = CreateTypeLib2(syskind, file, &typelib2);
    if(SUCCEEDED(hres))
    {
        hres = ICreateTypeLib2_QueryInterface(typelib2, &IID_ICreateTypeLib, (void **)&ctlib);
        ICreateTypeLib2_Release(typelib2);
    }
 
    return hres;
}

CreateTypeLib2()

HRESULT WINAPI CreateTypeLib2	(	SYSKIND	syskind,
		LPCOLESTR	szFile,
		ICreateTypeLib2 **	ppctlib
	)

Definition at line 9043 of file typelib.c.

{
    ITypeLibImpl *This;
    HRESULT hres;
 
    TRACE("(%d,%s,%p)\n", syskind, debugstr_w(szFile), ppctlib);
 
    if (!szFile) return E_INVALIDARG;
 
    This = TypeLibImpl_Constructor();
    if (!This)
        return E_OUTOFMEMORY;
 
    This->lcid = GetSystemDefaultLCID();
    This->syskind = syskind;
    This->ptr_size = get_ptr_size(syskind);
 
    This->path = heap_alloc((lstrlenW(szFile) + 1) * sizeof(WCHAR));
    if (!This->path) {
        ITypeLib2_Release(&This->ITypeLib2_iface);
        return E_OUTOFMEMORY;
    }
    lstrcpyW(This->path, szFile);
 
    hres = ITypeLib2_QueryInterface(&This->ITypeLib2_iface, &IID_ICreateTypeLib2, (LPVOID*)ppctlib);
    ITypeLib2_Release(&This->ITypeLib2_iface);
    return hres;
}

Referenced by CreateTypeLib(), test_create_typelib_lcid(), test_CreateTypeLib(), test_dep(), test_SetDocString(), test_SetFuncAndParamNames(), test_SetTypeDescAlias(), test_SetVarHelpContext(), test_stub(), and test_TypeInfo2_GetContainingTypeLib().

decode_string()

static const TLBString * decode_string ( const BYTE *  table, const char *  stream, DWORD  stream_length, ITypeLibImpl *  lib  )

static

Definition at line 3742 of file typelib.c.

{
    DWORD buf_size, table_size;
    const char *p;
    struct bitstream bits;
    BSTR buf;
    TLBString *tlbstr;
 
    if (!stream_length) return NULL;
 
    bits.buffer = (const BYTE *)stream;
    bits.length = stream_length;
    bits.current = 0;
 
    buf_size = *(const WORD *)table;
    table += sizeof(WORD);
    table_size = *(const DWORD *)table;
    table += sizeof(DWORD);
 
    buf = SysAllocStringLen(NULL, buf_size);
    buf[0] = 0;
 
    while ((p = lookup_code(table, table_size, &bits)))
    {
        static const WCHAR spaceW[] = { ' ',0 };
        if (buf[0]) lstrcatW(buf, spaceW);
        MultiByteToWideChar(CP_ACP, 0, p, -1, buf + lstrlenW(buf), buf_size - lstrlenW(buf));
    }
 
    tlbstr = TLB_append_str(&lib->string_list, buf);
    SysFreeString(buf);
 
    return tlbstr;
}

Referenced by ITypeLib2_Constructor_SLTG(), SLTG_DoFuncs(), and SLTG_DoVars().

DispCallFunc()

HRESULT WINAPI DispCallFunc	(	void *	pvInstance,
		ULONG_PTR	oVft,
		CALLCONV	cc,
		VARTYPE	vtReturn,
		UINT	cActuals,
		VARTYPE *	prgvt,
		VARIANTARG **	prgpvarg,
		VARIANT *	pvargResult
	)

Definition at line 7071 of file typelib.c.

{
    FIXME( "(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d)): not implemented for this CPU\n",
           pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult));
    return E_NOTIMPL;
}

Referenced by invoke_builtin_function(), ITypeInfo_fnInvoke(), and test_DispCallFunc().

dump_DispParms()

static void dump_DispParms ( const DISPPARAMS *  pdp )

static

Definition at line 1552 of file typelib.c.

{
    unsigned int index;
 
    TRACE("args=%u named args=%u\n", pdp->cArgs, pdp->cNamedArgs);
 
    if (pdp->cNamedArgs && pdp->rgdispidNamedArgs)
    {
        TRACE("named args:\n");
        for (index = 0; index < pdp->cNamedArgs; index++)
            TRACE( "\t0x%x\n", pdp->rgdispidNamedArgs[index] );
    }
 
    if (pdp->cArgs && pdp->rgvarg)
    {
        TRACE("args:\n");
        for (index = 0; index < pdp->cArgs; index++)
            TRACE("  [%d] %s\n", index, debugstr_variant(pdp->rgvarg+index));
    }
}

Referenced by ITypeInfo_fnInvoke().

dump_ELEMDESC()

static void dump_ELEMDESC ( const ELEMDESC *  edesc )

static

Definition at line 1405 of file typelib.c.

                                                 {
  char buf[200];
  USHORT flags = edesc->u.paramdesc.wParamFlags;
  dump_TypeDesc(&edesc->tdesc,buf);
  MESSAGE("\t\ttdesc.vartype %d (%s)\n",edesc->tdesc.vt,buf);
  MESSAGE("\t\tu.paramdesc.wParamFlags");
  if (!flags) MESSAGE(" PARAMFLAGS_NONE");
  if (flags & PARAMFLAG_FIN) MESSAGE(" PARAMFLAG_FIN");
  if (flags & PARAMFLAG_FOUT) MESSAGE(" PARAMFLAG_FOUT");
  if (flags & PARAMFLAG_FLCID) MESSAGE(" PARAMFLAG_FLCID");
  if (flags & PARAMFLAG_FRETVAL) MESSAGE(" PARAMFLAG_FRETVAL");
  if (flags & PARAMFLAG_FOPT) MESSAGE(" PARAMFLAG_FOPT");
  if (flags & PARAMFLAG_FHASDEFAULT) MESSAGE(" PARAMFLAG_FHASDEFAULT");
  if (flags & PARAMFLAG_FHASCUSTDATA) MESSAGE(" PARAMFLAG_FHASCUSTDATA");
  MESSAGE("\n\t\tu.paramdesc.lpex %p\n",edesc->u.paramdesc.pparamdescex);
}

Referenced by dump_FUNCDESC(), dump_VARDESC(), and TLB_AllocAndInitFuncDesc().

dump_FUNCDESC()

static void dump_FUNCDESC ( const FUNCDESC *  funcdesc )

static

Definition at line 1421 of file typelib.c.

                                                    {
  int i;
  MESSAGE("memid is %08x\n",funcdesc->memid);
  for (i=0;i<funcdesc->cParams;i++) {
      MESSAGE("Param %d:\n",i);
      dump_ELEMDESC(funcdesc->lprgelemdescParam+i);
  }
  MESSAGE("\tfunckind: %d (",funcdesc->funckind);
  switch (funcdesc->funckind) {
  case FUNC_VIRTUAL: MESSAGE("virtual");break;
  case FUNC_PUREVIRTUAL: MESSAGE("pure virtual");break;
  case FUNC_NONVIRTUAL: MESSAGE("nonvirtual");break;
  case FUNC_STATIC: MESSAGE("static");break;
  case FUNC_DISPATCH: MESSAGE("dispatch");break;
  default: MESSAGE("unknown");break;
  }
  MESSAGE(")\n\tinvkind: %d (",funcdesc->invkind);
  switch (funcdesc->invkind) {
  case INVOKE_FUNC: MESSAGE("func");break;
  case INVOKE_PROPERTYGET: MESSAGE("property get");break;
  case INVOKE_PROPERTYPUT: MESSAGE("property put");break;
  case INVOKE_PROPERTYPUTREF: MESSAGE("property put ref");break;
  }
  MESSAGE(")\n\tcallconv: %d (",funcdesc->callconv);
  switch (funcdesc->callconv) {
  case CC_CDECL: MESSAGE("cdecl");break;
  case CC_PASCAL: MESSAGE("pascal");break;
  case CC_STDCALL: MESSAGE("stdcall");break;
  case CC_SYSCALL: MESSAGE("syscall");break;
  default:break;
  }
  MESSAGE(")\n\toVft: %d\n", funcdesc->oVft);
  MESSAGE("\tcParamsOpt: %d\n", funcdesc->cParamsOpt);
  MESSAGE("\twFlags: %x\n", funcdesc->wFuncFlags);
 
  MESSAGE("\telemdescFunc (return value type):\n");
  dump_ELEMDESC(&funcdesc->elemdescFunc);
}

Referenced by dump_TLBFuncDescOne().

dump_TLBFuncDesc()

static void dump_TLBFuncDesc ( const TLBFuncDesc *  pfd, UINT  n  )

static

Definition at line 1493 of file typelib.c.

{
    while (n)
    {
      dump_TLBFuncDescOne(pfd);
      ++pfd;
      --n;
    }
}

Referenced by dump_TypeInfo(), SLTG_ProcessDispatch(), and SLTG_ProcessInterface().

dump_TLBFuncDescOne()

static void dump_TLBFuncDescOne ( const TLBFuncDesc *  pfd )

static

Definition at line 1473 of file typelib.c.

{
  int i;
  MESSAGE("%s(%u)\n", debugstr_w(TLB_get_bstr(pfd->Name)), pfd->funcdesc.cParams);
  for (i=0;i<pfd->funcdesc.cParams;i++)
      MESSAGE("\tparm%d: %s\n",i,debugstr_w(TLB_get_bstr(pfd->pParamDesc[i].Name)));
 
 
  dump_FUNCDESC(&(pfd->funcdesc));
 
  MESSAGE("\thelpstring: %s\n", debugstr_w(TLB_get_bstr(pfd->HelpString)));
  if(pfd->Entry == NULL)
      MESSAGE("\tentry: (null)\n");
  else if(pfd->Entry == (void*)-1)
      MESSAGE("\tentry: invalid\n");
  else if(IS_INTRESOURCE(pfd->Entry))
      MESSAGE("\tentry: %p\n", pfd->Entry);
  else
      MESSAGE("\tentry: %s\n", debugstr_w(TLB_get_bstr(pfd->Entry)));
}

Referenced by dump_TLBFuncDesc(), ITypeInfo_fnGetDllEntry(), and ITypeInfo_fnInvoke().

dump_TLBImpLib()

static void dump_TLBImpLib ( const TLBImpLib *  import )

static

Definition at line 1512 of file typelib.c.

{
    TRACE_(typelib)("%s %s\n", debugstr_guid(TLB_get_guidref(import->guid)),
            debugstr_w(import->name));
    TRACE_(typelib)("v%d.%d lcid=%x offset=%x\n", import->wVersionMajor,
            import->wVersionMinor, import->lcid, import->offset);
}

Referenced by dump_TLBRefType().

dump_TLBImplType()

static void dump_TLBImplType ( const TLBImplType *  impl, UINT  n  )

static

Definition at line 1540 of file typelib.c.

{
    if(!impl)
        return;
    while (n) {
        TRACE_(typelib)("implementing/inheriting interface hRef = %x implflags %x\n",
            impl->hRef, impl->implflags);
        ++impl;
        --n;
    }
}

Referenced by dump_TypeInfo().

dump_TLBRefType()

static void dump_TLBRefType ( const ITypeLibImpl *  pTL )

static

Definition at line 1520 of file typelib.c.

{
    TLBRefType *ref;
 
    LIST_FOR_EACH_ENTRY(ref, &pTL->ref_list, TLBRefType, entry)
    {
        TRACE_(typelib)("href:0x%08x\n", ref->reference);
        if(ref->index == -1)
        TRACE_(typelib)("%s\n", debugstr_guid(TLB_get_guidref(ref->guid)));
        else
        TRACE_(typelib)("type no: %d\n", ref->index);
 
        if(ref->pImpTLInfo != TLB_REF_INTERNAL && ref->pImpTLInfo != TLB_REF_NOT_FOUND)
        {
            TRACE_(typelib)("in lib\n");
            dump_TLBImpLib(ref->pImpTLInfo);
        }
    }
}

Referenced by SLTG_DoRefs().

dump_TLBVarDesc()

static void dump_TLBVarDesc ( const TLBVarDesc *  pvd, UINT  n  )

static

Definition at line 1502 of file typelib.c.

{
    while (n)
    {
      TRACE_(typelib)("%s\n", debugstr_w(TLB_get_bstr(pvd->Name)));
      ++pvd;
      --n;
    }
}

Referenced by dump_TypeInfo().

dump_TypeDesc()

static void dump_TypeDesc ( const TYPEDESC *  pTD, char *  szVarType  )

static

Definition at line 1356 of file typelib.c.

                                                               {
    if (pTD->vt & VT_RESERVED)
    szVarType += strlen(strcpy(szVarType, "reserved | "));
    if (pTD->vt & VT_BYREF)
    szVarType += strlen(strcpy(szVarType, "ref to "));
    if (pTD->vt & VT_ARRAY)
    szVarType += strlen(strcpy(szVarType, "array of "));
    if (pTD->vt & VT_VECTOR)
    szVarType += strlen(strcpy(szVarType, "vector of "));
    switch(pTD->vt & VT_TYPEMASK) {
    case VT_UI1: sprintf(szVarType, "VT_UI1"); break;
    case VT_I2: sprintf(szVarType, "VT_I2"); break;
    case VT_I4: sprintf(szVarType, "VT_I4"); break;
    case VT_R4: sprintf(szVarType, "VT_R4"); break;
    case VT_R8: sprintf(szVarType, "VT_R8"); break;
    case VT_BOOL: sprintf(szVarType, "VT_BOOL"); break;
    case VT_ERROR: sprintf(szVarType, "VT_ERROR"); break;
    case VT_CY: sprintf(szVarType, "VT_CY"); break;
    case VT_DATE: sprintf(szVarType, "VT_DATE"); break;
    case VT_BSTR: sprintf(szVarType, "VT_BSTR"); break;
    case VT_UNKNOWN: sprintf(szVarType, "VT_UNKNOWN"); break;
    case VT_DISPATCH: sprintf(szVarType, "VT_DISPATCH"); break;
    case VT_I1: sprintf(szVarType, "VT_I1"); break;
    case VT_UI2: sprintf(szVarType, "VT_UI2"); break;
    case VT_UI4: sprintf(szVarType, "VT_UI4"); break;
    case VT_INT: sprintf(szVarType, "VT_INT"); break;
    case VT_UINT: sprintf(szVarType, "VT_UINT"); break;
    case VT_VARIANT: sprintf(szVarType, "VT_VARIANT"); break;
    case VT_VOID: sprintf(szVarType, "VT_VOID"); break;
    case VT_HRESULT: sprintf(szVarType, "VT_HRESULT"); break;
    case VT_USERDEFINED: sprintf(szVarType, "VT_USERDEFINED ref = %x",
                 pTD->u.hreftype); break;
    case VT_LPSTR: sprintf(szVarType, "VT_LPSTR"); break;
    case VT_LPWSTR: sprintf(szVarType, "VT_LPWSTR"); break;
    case VT_PTR: sprintf(szVarType, "ptr to ");
      dump_TypeDesc(pTD->u.lptdesc, szVarType + 7);
      break;
    case VT_SAFEARRAY: sprintf(szVarType, "safearray of ");
      dump_TypeDesc(pTD->u.lptdesc, szVarType + 13);
      break;
    case VT_CARRAY: sprintf(szVarType, "%d dim array of ",
                pTD->u.lpadesc->cDims); /* FIXME print out sizes */
      dump_TypeDesc(&pTD->u.lpadesc->tdescElem, szVarType + strlen(szVarType));
      break;
 
    default: sprintf(szVarType, "unknown(%d)", pTD->vt & VT_TYPEMASK); break;
    }
}

Referenced by dump_ELEMDESC(), dump_TypeDesc(), and SLTG_DoVars().

dump_TypeInfo()

static void dump_TypeInfo ( const ITypeInfoImpl *  pty )

static

Definition at line 1573 of file typelib.c.

{
    TRACE("%p ref=%u\n", pty, pty->ref);
    TRACE("%s %s\n", debugstr_w(TLB_get_bstr(pty->Name)), debugstr_w(TLB_get_bstr(pty->DocString)));
    TRACE("attr:%s\n", debugstr_guid(TLB_get_guidref(pty->guid)));
    TRACE("kind:%s\n", typekind_desc[pty->typeattr.typekind]);
    TRACE("fct:%u var:%u impl:%u\n", pty->typeattr.cFuncs, pty->typeattr.cVars, pty->typeattr.cImplTypes);
    TRACE("wTypeFlags: 0x%04x\n", pty->typeattr.wTypeFlags);
    TRACE("parent tlb:%p index in TLB:%u\n",pty->pTypeLib, pty->index);
    if (pty->typeattr.typekind == TKIND_MODULE) TRACE("dllname:%s\n", debugstr_w(TLB_get_bstr(pty->DllName)));
    if (TRACE_ON(ole))
        dump_TLBFuncDesc(pty->funcdescs, pty->typeattr.cFuncs);
    dump_TLBVarDesc(pty->vardescs, pty->typeattr.cVars);
    dump_TLBImplType(pty->impltypes, pty->typeattr.cImplTypes);
}

Referenced by CreateDispTypeInfo(), ITypeInfo_fnGetDllEntry(), ITypeInfo_fnGetRefTypeOfImplType(), MSFT_DoTypeInfo(), and SLTG_ProcessModule().

dump_VARDESC()

static void dump_VARDESC ( const VARDESC *  v )

static

Definition at line 1589 of file typelib.c.

{
    MESSAGE("memid %d\n",v->memid);
    MESSAGE("lpstrSchema %s\n",debugstr_w(v->lpstrSchema));
    MESSAGE("oInst %d\n",v->u.oInst);
    dump_ELEMDESC(&(v->elemdescVar));
    MESSAGE("wVarFlags %x\n",v->wVarFlags);
    MESSAGE("varkind %d\n",v->varkind);
}

Referenced by ITypeInfo_fnInvoke().

find_ne_resource()

static BOOL find_ne_resource ( HFILE  lzfd, LPCSTR  typeid, LPCSTR  resid, DWORD *  resLen, DWORD *  resOff  )

static

Definition at line 3049 of file typelib.c.

{
    IMAGE_OS2_HEADER nehd;
    NE_TYPEINFO *typeInfo;
    NE_NAMEINFO *nameInfo;
    DWORD nehdoffset;
    LPBYTE resTab;
    DWORD resTabSize;
    int count;
 
    /* Read in NE header */
    nehdoffset = LZSeek( lzfd, 0, SEEK_CUR );
    if ( sizeof(nehd) != LZRead( lzfd, (LPSTR)&nehd, sizeof(nehd) ) ) return FALSE;
 
    resTabSize = nehd.ne_restab - nehd.ne_rsrctab;
    if ( !resTabSize )
    {
        TRACE("No resources in NE dll\n" );
        return FALSE;
    }
 
    /* Read in resource table */
    resTab = heap_alloc( resTabSize );
    if ( !resTab ) return FALSE;
 
    LZSeek( lzfd, nehd.ne_rsrctab + nehdoffset, SEEK_SET );
    if ( resTabSize != LZRead( lzfd, (char*)resTab, resTabSize ) )
    {
        heap_free( resTab );
        return FALSE;
    }
 
    /* Find resource */
    typeInfo = (NE_TYPEINFO *)(resTab + 2);
 
    if (!IS_INTRESOURCE(typeid))  /* named type */
    {
        BYTE len = strlen( typeid );
        while (typeInfo->type_id)
        {
            if (!(typeInfo->type_id & 0x8000))
            {
                BYTE *p = resTab + typeInfo->type_id;
                if ((*p == len) && !_strnicmp( (char*)p+1, typeid, len )) goto found_type;
            }
            typeInfo = (NE_TYPEINFO *)((char *)(typeInfo + 1) +
                                       typeInfo->count * sizeof(NE_NAMEINFO));
        }
    }
    else  /* numeric type id */
    {
        WORD id = LOWORD(typeid) | 0x8000;
        while (typeInfo->type_id)
        {
            if (typeInfo->type_id == id) goto found_type;
            typeInfo = (NE_TYPEINFO *)((char *)(typeInfo + 1) +
                                       typeInfo->count * sizeof(NE_NAMEINFO));
        }
    }
    TRACE("No typeid entry found for %p\n", typeid );
    heap_free( resTab );
    return FALSE;
 
 found_type:
    nameInfo = (NE_NAMEINFO *)(typeInfo + 1);
 
    if (!IS_INTRESOURCE(resid))  /* named resource */
    {
        BYTE len = strlen( resid );
        for (count = typeInfo->count; count > 0; count--, nameInfo++)
        {
            BYTE *p = resTab + nameInfo->id;
            if (nameInfo->id & 0x8000) continue;
            if ((*p == len) && !_strnicmp( (char*)p+1, resid, len )) goto found_name;
        }
    }
    else  /* numeric resource id */
    {
        WORD id = LOWORD(resid) | 0x8000;
        for (count = typeInfo->count; count > 0; count--, nameInfo++)
            if (nameInfo->id == id) goto found_name;
    }
    TRACE("No resid entry found for %p\n", typeid );
    heap_free( resTab );
    return FALSE;
 
 found_name:
    /* Return resource data */
    if ( resLen ) *resLen = nameInfo->length << *(WORD *)resTab;
    if ( resOff ) *resOff = nameInfo->offset << *(WORD *)resTab;
 
    heap_free( resTab );
    return TRUE;
}

Referenced by TLB_NEFile_Open().

find_typelib_key()

static BOOL find_typelib_key ( REFGUID  guid, WORD *  wMaj, WORD *  wMin  )

static

Definition at line 172 of file typelib.c.

{
    static const WCHAR typelibW[] = {'T','y','p','e','l','i','b','\\',0};
    WCHAR buffer[60];
    char key_name[16];
    DWORD len, i;
    INT best_maj = -1, best_min = -1;
    HKEY hkey;
 
    memcpy( buffer, typelibW, sizeof(typelibW) );
    StringFromGUID2( guid, buffer + lstrlenW(buffer), 40 );
 
    if (RegOpenKeyExW( HKEY_CLASSES_ROOT, buffer, 0, KEY_READ, &hkey ) != ERROR_SUCCESS)
        return FALSE;
 
    len = sizeof(key_name);
    i = 0;
    while (RegEnumKeyExA(hkey, i++, key_name, &len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
    {
        INT v_maj, v_min;
 
        if (sscanf(key_name, "%x.%x", &v_maj, &v_min) == 2)
        {
            TRACE("found %s: %x.%x\n", debugstr_w(buffer), v_maj, v_min);
 
            if (*wMaj == 0xffff && *wMin == 0xffff)
            {
                if (v_maj > best_maj) best_maj = v_maj;
                if (v_min > best_min) best_min = v_min;
            }
            else if (*wMaj == v_maj)
            {
                best_maj = v_maj;
 
                if (*wMin == v_min)
                {
                    best_min = v_min;
                    break; /* exact match */
                }
                if (*wMin != 0xffff && v_min > best_min) best_min = v_min;
            }
        }
        len = sizeof(key_name);
    }
    RegCloseKey( hkey );
 
    TRACE("found best_maj %d, best_min %d\n", best_maj, best_min);
 
    if (*wMaj == 0xffff && *wMin == 0xffff)
    {
        if (best_maj >= 0 && best_min >= 0)
        {
            *wMaj = best_maj;
            *wMin = best_min;
            return TRUE;
        }
    }
 
    if (*wMaj == best_maj && best_min >= 0)
    {
        *wMin = best_min;
        return TRUE;
    }
    return FALSE;
}

Referenced by query_typelib_path().

func_restricted()

static BOOL func_restricted ( const FUNCDESC *  desc )

inlinestatic

Definition at line 7268 of file typelib.c.

{
    return (desc->wFuncFlags & FUNCFLAG_FRESTRICTED) && (desc->memid >= 0);
}

Referenced by ITypeInfo_fnInvoke().

get_iface_guid()

static HRESULT get_iface_guid ( ITypeInfo *  tinfo, HREFTYPE  href, GUID *  guid  )

static

Definition at line 7215 of file typelib.c.

{
    ITypeInfo *tinfo2;
    TYPEATTR *tattr;
    HRESULT hres;
    int flags, i;
 
    hres = ITypeInfo_GetRefTypeInfo(tinfo, href, &tinfo2);
    if(FAILED(hres))
        return hres;
 
    hres = ITypeInfo_GetTypeAttr(tinfo2, &tattr);
    if(FAILED(hres)) {
        ITypeInfo_Release(tinfo2);
        return hres;
    }
 
    switch(tattr->typekind) {
    case TKIND_ALIAS:
        hres = get_iface_guid(tinfo2, tattr->tdescAlias.u.hreftype, guid);
        break;
 
    case TKIND_INTERFACE:
    case TKIND_DISPATCH:
        *guid = tattr->guid;
        break;
 
    case TKIND_COCLASS:
        for (i = 0; i < tattr->cImplTypes; i++)
        {
            ITypeInfo_GetImplTypeFlags(tinfo2, i, &flags);
            if (flags & IMPLTYPEFLAG_FDEFAULT)
                break;
        }
 
        if (i == tattr->cImplTypes)
            i = 0;
 
        hres = ITypeInfo_GetRefTypeOfImplType(tinfo2, i, &href);
        if (SUCCEEDED(hres))
            hres = get_iface_guid(tinfo2, href, guid);
        break;
 
    default:
        ERR("Unexpected typekind %d\n", tattr->typekind);
        hres = E_UNEXPECTED;
    }
 
    ITypeInfo_ReleaseTypeAttr(tinfo2, tattr);
    ITypeInfo_Release(tinfo2);
    return hres;
}

Referenced by get_iface_guid(), and ITypeInfo_fnInvoke().

get_interface_key()

static WCHAR * get_interface_key ( REFGUID  guid, WCHAR *  buffer  )

static

Definition at line 253 of file typelib.c.

{
    static const WCHAR InterfaceW[] = {'I','n','t','e','r','f','a','c','e','\\',0};
 
    memcpy( buffer, InterfaceW, sizeof(InterfaceW) );
    StringFromGUID2( guid, buffer + lstrlenW(buffer), 40 );
    return buffer;
}

Referenced by TLB_register_interface(), and TLB_unregister_interface().

get_lcid_subkey()

static WCHAR * get_lcid_subkey ( LCID  lcid, SYSKIND  syskind, WCHAR *  buffer  )

static

Definition at line 264 of file typelib.c.

{
    static const WCHAR LcidFormatW[] = {'%','l','x','\\',0};
    static const WCHAR win16W[] = {'w','i','n','1','6',0};
    static const WCHAR win32W[] = {'w','i','n','3','2',0};
    static const WCHAR win64W[] = {'w','i','n','6','4',0};
 
    swprintf( buffer, LcidFormatW, lcid );
    switch(syskind)
    {
    case SYS_WIN16: lstrcatW( buffer, win16W ); break;
    case SYS_WIN32: lstrcatW( buffer, win32W ); break;
    case SYS_WIN64: lstrcatW( buffer, win64W ); break;
    default:
        TRACE("Typelib is for unsupported syskind %i\n", syskind);
        return NULL;
    }
    return buffer;
}

Referenced by query_typelib_path(), RegisterTypeLib(), and UnRegisterTypeLib().

get_ptr_size()

static int get_ptr_size ( SYSKIND  syskind )

static

Definition at line 1339 of file typelib.c.

{
    switch(syskind){
    case SYS_WIN64:
        return 8;
    case SYS_WIN32:
    case SYS_MAC:
    case SYS_WIN16:
        return 4;
    }
    WARN("Unhandled syskind: 0x%x\n", syskind);
    return 4;
}

Referenced by CreateTypeLib2(), ITypeLib2_Constructor_MSFT(), SLTG_ReadLibBlk(), and TLB_size_instance().

get_typelib_key()

static WCHAR * get_typelib_key ( REFGUID  guid, WORD  wMaj, WORD  wMin, WCHAR *  buffer  )

static

Definition at line 240 of file typelib.c.

{
    static const WCHAR TypelibW[] = {'T','y','p','e','l','i','b','\\',0};
    static const WCHAR VersionFormatW[] = {'\\','%','x','.','%','x',0};
 
    memcpy( buffer, TypelibW, sizeof(TypelibW) );
    StringFromGUID2( guid, buffer + lstrlenW(buffer), 40 );
    swprintf( buffer + lstrlenW(buffer), VersionFormatW, wMaj, wMin );
    return buffer;
}

Referenced by query_typelib_path(), RegisterTypeLib(), and UnRegisterTypeLib().

hash_guid()

static int hash_guid ( GUID *  guid )

inlinestatic

Definition at line 9426 of file typelib.c.

{
    int i, hash = 0;
 
    for (i = 0; i < 8; i ++)
        hash ^= ((const short *)guid)[i];
 
    return hash & 0x1f;
}

Referenced by WMSFT_compile_guids().

ICreateTypeInfo2_fnAddFuncDesc()

static HRESULT WINAPI ICreateTypeInfo2_fnAddFuncDesc ( ICreateTypeInfo2 *  iface, UINT  index, FUNCDESC *  funcDesc  )

static

Definition at line 10811 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    TLBFuncDesc tmp_func_desc, *func_desc;
    int buf_size, i;
    char *buffer;
    HRESULT hres;
 
    TRACE("%p %u %p\n", This, index, funcDesc);
 
    if (!funcDesc || funcDesc->oVft & 3)
        return E_INVALIDARG;
 
    switch (This->typeattr.typekind) {
    case TKIND_MODULE:
        if (funcDesc->funckind != FUNC_STATIC)
            return TYPE_E_BADMODULEKIND;
        break;
    case TKIND_DISPATCH:
        if (funcDesc->funckind != FUNC_DISPATCH)
            return TYPE_E_BADMODULEKIND;
        break;
    default:
        if (funcDesc->funckind != FUNC_PUREVIRTUAL)
            return TYPE_E_BADMODULEKIND;
    }
 
    if (index > This->typeattr.cFuncs)
        return TYPE_E_ELEMENTNOTFOUND;
 
    if (funcDesc->invkind & (INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF) &&
            !funcDesc->cParams)
        return TYPE_E_INCONSISTENTPROPFUNCS;
 
#ifdef _WIN64
    if(This->pTypeLib->syskind == SYS_WIN64 &&
            funcDesc->oVft % 8 != 0)
        return E_INVALIDARG;
#endif
 
    memset(&tmp_func_desc, 0, sizeof(tmp_func_desc));
    TLBFuncDesc_Constructor(&tmp_func_desc);
 
    tmp_func_desc.funcdesc = *funcDesc;
 
    if (tmp_func_desc.funcdesc.oVft != 0)
        tmp_func_desc.funcdesc.oVft |= 1;
 
    if (funcDesc->cScodes && funcDesc->lprgscode) {
        tmp_func_desc.funcdesc.lprgscode = heap_alloc(sizeof(SCODE) * funcDesc->cScodes);
        memcpy(tmp_func_desc.funcdesc.lprgscode, funcDesc->lprgscode, sizeof(SCODE) * funcDesc->cScodes);
    } else {
        tmp_func_desc.funcdesc.lprgscode = NULL;
        tmp_func_desc.funcdesc.cScodes = 0;
    }
 
    buf_size = TLB_SizeElemDesc(&funcDesc->elemdescFunc);
    for (i = 0; i < funcDesc->cParams; ++i) {
        buf_size += sizeof(ELEMDESC);
        buf_size += TLB_SizeElemDesc(funcDesc->lprgelemdescParam + i);
    }
    tmp_func_desc.funcdesc.lprgelemdescParam = heap_alloc(buf_size);
    buffer = (char*)(tmp_func_desc.funcdesc.lprgelemdescParam + funcDesc->cParams);
 
    hres = TLB_CopyElemDesc(&funcDesc->elemdescFunc, &tmp_func_desc.funcdesc.elemdescFunc, &buffer);
    if (FAILED(hres)) {
        heap_free(tmp_func_desc.funcdesc.lprgelemdescParam);
        heap_free(tmp_func_desc.funcdesc.lprgscode);
        return hres;
    }
 
    for (i = 0; i < funcDesc->cParams; ++i) {
        hres = TLB_CopyElemDesc(funcDesc->lprgelemdescParam + i,
                tmp_func_desc.funcdesc.lprgelemdescParam + i, &buffer);
        if (FAILED(hres)) {
            heap_free(tmp_func_desc.funcdesc.lprgelemdescParam);
            heap_free(tmp_func_desc.funcdesc.lprgscode);
            return hres;
        }
        if (tmp_func_desc.funcdesc.lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT &&
                tmp_func_desc.funcdesc.lprgelemdescParam[i].tdesc.vt != VT_VARIANT &&
                tmp_func_desc.funcdesc.lprgelemdescParam[i].tdesc.vt != VT_USERDEFINED){
            hres = TLB_SanitizeVariant(&tmp_func_desc.funcdesc.lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
            if (FAILED(hres)) {
                heap_free(tmp_func_desc.funcdesc.lprgelemdescParam);
                heap_free(tmp_func_desc.funcdesc.lprgscode);
                return hres;
            }
        }
    }
 
    tmp_func_desc.pParamDesc = TLBParDesc_Constructor(funcDesc->cParams);
 
    if (This->funcdescs) {
        This->funcdescs = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->funcdescs,
                sizeof(TLBFuncDesc) * (This->typeattr.cFuncs + 1));
 
        if (index < This->typeattr.cFuncs) {
            memmove(This->funcdescs + index + 1, This->funcdescs + index,
                    (This->typeattr.cFuncs - index) * sizeof(TLBFuncDesc));
            func_desc = This->funcdescs + index;
        } else
            func_desc = This->funcdescs + This->typeattr.cFuncs;
 
        /* move custdata lists to the new memory location */
        for(i = 0; i < This->typeattr.cFuncs + 1; ++i){
            if(index != i){
                TLBFuncDesc *fd = &This->funcdescs[i];
                if(fd->custdata_list.prev == fd->custdata_list.next)
                    list_init(&fd->custdata_list);
                else{
                    fd->custdata_list.prev->next = &fd->custdata_list;
                    fd->custdata_list.next->prev = &fd->custdata_list;
                }
            }
        }
    } else
        func_desc = This->funcdescs = heap_alloc(sizeof(TLBFuncDesc));
 
    memcpy(func_desc, &tmp_func_desc, sizeof(tmp_func_desc));
    list_init(&func_desc->custdata_list);
 
    ++This->typeattr.cFuncs;
 
    This->needs_layout = TRUE;
 
    return S_OK;
}

ICreateTypeInfo2_fnAddImplType()

static HRESULT WINAPI ICreateTypeInfo2_fnAddImplType ( ICreateTypeInfo2 *  iface, UINT  index, HREFTYPE  refType  )

static

Definition at line 10941 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    TLBImplType *impl_type;
    HRESULT hres;
 
    TRACE("%p %u %d\n", This, index, refType);
 
    switch(This->typeattr.typekind){
        case TKIND_COCLASS: {
            if (index == -1) {
                FIXME("Unhandled index: -1\n");
                return E_NOTIMPL;
            }
 
            if(index != This->typeattr.cImplTypes)
                return TYPE_E_ELEMENTNOTFOUND;
 
            break;
        }
        case TKIND_INTERFACE:
        case TKIND_DISPATCH:
            if (index != 0 || This->typeattr.cImplTypes)
                return TYPE_E_ELEMENTNOTFOUND;
            break;
        default:
            FIXME("Unimplemented typekind: %d\n", This->typeattr.typekind);
            return E_NOTIMPL;
    }
 
    if (This->impltypes){
        UINT i;
 
        This->impltypes = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->impltypes,
                sizeof(TLBImplType) * (This->typeattr.cImplTypes + 1));
 
        if (index < This->typeattr.cImplTypes) {
            memmove(This->impltypes + index + 1, This->impltypes + index,
                    (This->typeattr.cImplTypes - index) * sizeof(TLBImplType));
            impl_type = This->impltypes + index;
        } else
            impl_type = This->impltypes + This->typeattr.cImplTypes;
 
        /* move custdata lists to the new memory location */
        for(i = 0; i < This->typeattr.cImplTypes + 1; ++i){
            if(index != i){
                TLBImplType *it = &This->impltypes[i];
                if(it->custdata_list.prev == it->custdata_list.next)
                    list_init(&it->custdata_list);
                else{
                    it->custdata_list.prev->next = &it->custdata_list;
                    it->custdata_list.next->prev = &it->custdata_list;
                }
            }
        }
    } else
        impl_type = This->impltypes = heap_alloc(sizeof(TLBImplType));
 
    memset(impl_type, 0, sizeof(TLBImplType));
    TLBImplType_Constructor(impl_type);
    impl_type->hRef = refType;
 
    ++This->typeattr.cImplTypes;
 
    if((refType & (~0x3)) == (This->pTypeLib->dispatch_href & (~0x3)))
        This->typeattr.wTypeFlags |= TYPEFLAG_FDISPATCHABLE;
 
    hres = ICreateTypeInfo2_LayOut(iface);
    if (FAILED(hres))
        return hres;
 
    return S_OK;
}

ICreateTypeInfo2_fnAddRef()

static ULONG WINAPI ICreateTypeInfo2_fnAddRef ( ICreateTypeInfo2 *  iface )

static

Definition at line 10594 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    return ITypeInfo2_AddRef(&This->ITypeInfo2_iface);
}

ICreateTypeInfo2_fnAddRefTypeInfo()

static HRESULT WINAPI ICreateTypeInfo2_fnAddRefTypeInfo ( ICreateTypeInfo2 *  iface, ITypeInfo *  typeInfo, HREFTYPE *  refType  )

static

Definition at line 10703 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    UINT index;
    ITypeLib *container;
    TLBRefType *ref_type;
    TLBImpLib *implib;
    TYPEATTR *typeattr;
    TLIBATTR *libattr;
    HRESULT hres;
 
    TRACE("%p %p %p\n", This, typeInfo, refType);
 
    if (!typeInfo || !refType)
        return E_INVALIDARG;
 
    hres = ITypeInfo_GetContainingTypeLib(typeInfo, &container, &index);
    if (FAILED(hres))
        return hres;
 
    if (container == (ITypeLib*)&This->pTypeLib->ITypeLib2_iface) {
        ITypeInfoImpl *target = impl_from_ITypeInfo(typeInfo);
 
        ITypeLib_Release(container);
 
        *refType = target->hreftype;
 
        return S_OK;
    }
 
    hres = ITypeLib_GetLibAttr(container, &libattr);
    if (FAILED(hres)) {
        ITypeLib_Release(container);
        return hres;
    }
 
    LIST_FOR_EACH_ENTRY(implib, &This->pTypeLib->implib_list, TLBImpLib, entry){
        if(IsEqualGUID(&implib->guid->guid, &libattr->guid) &&
                implib->lcid == libattr->lcid &&
                implib->wVersionMajor == libattr->wMajorVerNum &&
                implib->wVersionMinor == libattr->wMinorVerNum)
            break;
    }
 
    if(&implib->entry == &This->pTypeLib->implib_list){
        implib = heap_alloc_zero(sizeof(TLBImpLib));
 
        if((ITypeLib2Vtbl*)container->lpVtbl == &tlbvt){
            const ITypeLibImpl *our_container = impl_from_ITypeLib2((ITypeLib2*)container);
            implib->name = SysAllocString(our_container->path);
        }else{
            hres = QueryPathOfRegTypeLib(&libattr->guid, libattr->wMajorVerNum,
                    libattr->wMinorVerNum, libattr->lcid, &implib->name);
            if(FAILED(hres)){
                implib->name = NULL;
                TRACE("QueryPathOfRegTypeLib failed, no name stored: %08x\n", hres);
            }
        }
 
        implib->guid = TLB_append_guid(&This->pTypeLib->guid_list, &libattr->guid, 2);
        implib->lcid = libattr->lcid;
        implib->wVersionMajor = libattr->wMajorVerNum;
        implib->wVersionMinor = libattr->wMinorVerNum;
 
        list_add_tail(&This->pTypeLib->implib_list, &implib->entry);
    }
 
    ITypeLib_ReleaseTLibAttr(container, libattr);
    ITypeLib_Release(container);
 
    hres = ITypeInfo_GetTypeAttr(typeInfo, &typeattr);
    if (FAILED(hres))
        return hres;
 
    index = 0;
    LIST_FOR_EACH_ENTRY(ref_type, &This->pTypeLib->ref_list, TLBRefType, entry){
        if(ref_type->index == TLB_REF_USE_GUID &&
                IsEqualGUID(&ref_type->guid->guid, &typeattr->guid) &&
                ref_type->tkind == typeattr->typekind)
            break;
        ++index;
    }
 
    if(&ref_type->entry == &This->pTypeLib->ref_list){
        ref_type = heap_alloc_zero(sizeof(TLBRefType));
 
        ref_type->tkind = typeattr->typekind;
        ref_type->pImpTLInfo = implib;
        ref_type->reference = index * sizeof(MSFT_ImpInfo);
 
        ref_type->index = TLB_REF_USE_GUID;
 
        ref_type->guid = TLB_append_guid(&This->pTypeLib->guid_list, &typeattr->guid, ref_type->reference+1);
 
        list_add_tail(&This->pTypeLib->ref_list, &ref_type->entry);
    }
 
    ITypeInfo_ReleaseTypeAttr(typeInfo, typeattr);
 
    *refType = ref_type->reference | 0x1;
 
    if(IsEqualGUID(&ref_type->guid->guid, &IID_IDispatch))
        This->pTypeLib->dispatch_href = *refType;
 
    return S_OK;
}

ICreateTypeInfo2_fnAddVarDesc()

static HRESULT WINAPI ICreateTypeInfo2_fnAddVarDesc ( ICreateTypeInfo2 *  iface, UINT  index, VARDESC *  varDesc  )

static

Definition at line 11064 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    TLBVarDesc *var_desc;
 
    TRACE("%p %u %p\n", This, index, varDesc);
 
    if (This->vardescs){
        UINT i;
 
        This->vardescs = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->vardescs,
                sizeof(TLBVarDesc) * (This->typeattr.cVars + 1));
 
        if (index < This->typeattr.cVars) {
            memmove(This->vardescs + index + 1, This->vardescs + index,
                    (This->typeattr.cVars - index) * sizeof(TLBVarDesc));
            var_desc = This->vardescs + index;
        } else
            var_desc = This->vardescs + This->typeattr.cVars;
 
        /* move custdata lists to the new memory location */
        for(i = 0; i < This->typeattr.cVars + 1; ++i){
            if(index != i){
                TLBVarDesc *var = &This->vardescs[i];
                if(var->custdata_list.prev == var->custdata_list.next)
                    list_init(&var->custdata_list);
                else{
                    var->custdata_list.prev->next = &var->custdata_list;
                    var->custdata_list.next->prev = &var->custdata_list;
                }
            }
        }
    } else
        var_desc = This->vardescs = heap_alloc_zero(sizeof(TLBVarDesc));
 
    TLBVarDesc_Constructor(var_desc);
    TLB_AllocAndInitVarDesc(varDesc, &var_desc->vardesc_create);
    var_desc->vardesc = *var_desc->vardesc_create;
 
    ++This->typeattr.cVars;
 
    This->needs_layout = TRUE;
 
    return S_OK;
}

ICreateTypeInfo2_fnDefineFuncAsDllEntry()

static HRESULT WINAPI ICreateTypeInfo2_fnDefineFuncAsDllEntry ( ICreateTypeInfo2 *  iface, UINT  index, LPOLESTR  dllName, LPOLESTR  procName  )

static

Definition at line 11196 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %u %s %s - stub\n", This, index, wine_dbgstr_w(dllName), wine_dbgstr_w(procName));
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnDeleteFuncDesc()

static HRESULT WINAPI ICreateTypeInfo2_fnDeleteFuncDesc ( ICreateTypeInfo2 *  iface, UINT  index  )

static

Definition at line 11441 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %u - stub\n", This, index);
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnDeleteFuncDescByMemId()

static HRESULT WINAPI ICreateTypeInfo2_fnDeleteFuncDescByMemId ( ICreateTypeInfo2 *  iface, MEMBERID  memid, INVOKEKIND  invKind  )

static

Definition at line 11449 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %x %d - stub\n", This, memid, invKind);
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnDeleteImplType()

static HRESULT WINAPI ICreateTypeInfo2_fnDeleteImplType ( ICreateTypeInfo2 *  iface, UINT  index  )

static

Definition at line 11473 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %u - stub\n", This, index);
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnDeleteVarDesc()

static HRESULT WINAPI ICreateTypeInfo2_fnDeleteVarDesc ( ICreateTypeInfo2 *  iface, UINT  index  )

static

Definition at line 11457 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %u - stub\n", This, index);
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnDeleteVarDescByMemId()

static HRESULT WINAPI ICreateTypeInfo2_fnDeleteVarDescByMemId ( ICreateTypeInfo2 *  iface, MEMBERID  memid  )

static

Definition at line 11465 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %x - stub\n", This, memid);
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnInvalidate()

static HRESULT WINAPI ICreateTypeInfo2_fnInvalidate ( ICreateTypeInfo2 *  iface )

static

Definition at line 11558 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p - stub\n", This);
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnLayOut()

static HRESULT WINAPI ICreateTypeInfo2_fnLayOut ( ICreateTypeInfo2 *  iface )

static

Definition at line 11298 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    ITypeInfo *tinfo;
    TLBFuncDesc *func_desc;
    UINT user_vft = 0, i, depth = 0;
    HRESULT hres = S_OK;
 
    TRACE("%p\n", This);
 
    This->needs_layout = FALSE;
 
    hres = ICreateTypeInfo2_QueryInterface(iface, &IID_ITypeInfo, (LPVOID*)&tinfo);
    if (FAILED(hres))
        return hres;
 
    if (This->typeattr.typekind == TKIND_INTERFACE) {
        ITypeInfo *inh;
        TYPEATTR *attr;
        HREFTYPE inh_href;
 
        hres = ITypeInfo_GetRefTypeOfImplType(tinfo, 0, &inh_href);
 
        if (SUCCEEDED(hres)) {
            hres = ITypeInfo_GetRefTypeInfo(tinfo, inh_href, &inh);
 
            if (SUCCEEDED(hres)) {
                hres = ITypeInfo_GetTypeAttr(inh, &attr);
                if (FAILED(hres)) {
                    ITypeInfo_Release(inh);
                    ITypeInfo_Release(tinfo);
                    return hres;
                }
                This->typeattr.cbSizeVft = attr->cbSizeVft;
                ITypeInfo_ReleaseTypeAttr(inh, attr);
 
                do{
                    ++depth;
                    hres = ITypeInfo_GetRefTypeOfImplType(inh, 0, &inh_href);
                    if(SUCCEEDED(hres)){
                        ITypeInfo *next;
                        hres = ITypeInfo_GetRefTypeInfo(inh, inh_href, &next);
                        if(SUCCEEDED(hres)){
                            ITypeInfo_Release(inh);
                            inh = next;
                        }
                    }
                }while(SUCCEEDED(hres));
                hres = S_OK;
 
                ITypeInfo_Release(inh);
            } else if (hres == TYPE_E_ELEMENTNOTFOUND) {
                This->typeattr.cbSizeVft = 0;
                hres = S_OK;
            } else {
                ITypeInfo_Release(tinfo);
                return hres;
            }
        } else if (hres == TYPE_E_ELEMENTNOTFOUND) {
            This->typeattr.cbSizeVft = 0;
            hres = S_OK;
        } else {
            ITypeInfo_Release(tinfo);
            return hres;
        }
    } else if (This->typeattr.typekind == TKIND_DISPATCH)
        This->typeattr.cbSizeVft = 7 * This->pTypeLib->ptr_size;
    else
        This->typeattr.cbSizeVft = 0;
 
    func_desc = This->funcdescs;
    i = 0;
    while (i < This->typeattr.cFuncs) {
        if (!(func_desc->funcdesc.oVft & 0x1))
            func_desc->funcdesc.oVft = This->typeattr.cbSizeVft;
 
        if ((func_desc->funcdesc.oVft & 0xFFFC) > user_vft)
            user_vft = func_desc->funcdesc.oVft & 0xFFFC;
 
        This->typeattr.cbSizeVft += This->pTypeLib->ptr_size;
 
        if (func_desc->funcdesc.memid == MEMBERID_NIL) {
            TLBFuncDesc *iter;
            UINT j = 0;
            BOOL reset = FALSE;
 
            func_desc->funcdesc.memid = 0x60000000 + (depth << 16) + i;
 
            iter = This->funcdescs;
            while (j < This->typeattr.cFuncs) {
                if (iter != func_desc && iter->funcdesc.memid == func_desc->funcdesc.memid) {
                    if (!reset) {
                        func_desc->funcdesc.memid = 0x60000000 + (depth << 16) + This->typeattr.cFuncs;
                        reset = TRUE;
                    } else
                        ++func_desc->funcdesc.memid;
                    iter = This->funcdescs;
                    j = 0;
                } else {
                    ++iter;
                    ++j;
                }
            }
        }
 
        ++func_desc;
        ++i;
    }
 
    if (user_vft > This->typeattr.cbSizeVft)
        This->typeattr.cbSizeVft = user_vft + This->pTypeLib->ptr_size;
 
    for(i = 0; i < This->typeattr.cVars; ++i){
        TLBVarDesc *var_desc = &This->vardescs[i];
        if(var_desc->vardesc.memid == MEMBERID_NIL){
            UINT j = 0;
            BOOL reset = FALSE;
            TLBVarDesc *iter;
 
            var_desc->vardesc.memid = 0x40000000 + (depth << 16) + i;
 
            iter = This->vardescs;
            while (j < This->typeattr.cVars) {
                if (iter != var_desc && iter->vardesc.memid == var_desc->vardesc.memid) {
                    if (!reset) {
                        var_desc->vardesc.memid = 0x40000000 + (depth << 16) + This->typeattr.cVars;
                        reset = TRUE;
                    } else
                        ++var_desc->vardesc.memid;
                    iter = This->vardescs;
                    j = 0;
                } else {
                    ++iter;
                    ++j;
                }
            }
        }
    }
 
    ITypeInfo_Release(tinfo);
    return hres;
}

ICreateTypeInfo2_fnQueryInterface()

static HRESULT WINAPI ICreateTypeInfo2_fnQueryInterface ( ICreateTypeInfo2 *  iface, REFIID  riid, void **  object  )

static

Definition at line 10586 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    return ITypeInfo2_QueryInterface(&This->ITypeInfo2_iface, riid, object);
}

ICreateTypeInfo2_fnRelease()

static ULONG WINAPI ICreateTypeInfo2_fnRelease ( ICreateTypeInfo2 *  iface )

static

Definition at line 10601 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    return ITypeInfo2_Release(&This->ITypeInfo2_iface);
}

ICreateTypeInfo2_fnSetAlignment()

static HRESULT WINAPI ICreateTypeInfo2_fnSetAlignment ( ICreateTypeInfo2 *  iface, WORD  alignment  )

static

Definition at line 11035 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    TRACE("%p %d\n", This, alignment);
 
    This->typeattr.cbAlignment = alignment;
 
    return S_OK;
}

ICreateTypeInfo2_fnSetCustData()

static HRESULT WINAPI ICreateTypeInfo2_fnSetCustData ( ICreateTypeInfo2 *  iface, REFGUID  guid, VARIANT *  varVal  )

static

Definition at line 11481 of file typelib.c.

{
    TLBGuid *tlbguid;
 
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    TRACE("%p %s %p\n", This, debugstr_guid(guid), varVal);
 
    if (!guid || !varVal)
        return E_INVALIDARG;
 
    tlbguid = TLB_append_guid(&This->pTypeLib->guid_list, guid, -1);
 
    return TLB_set_custdata(This->pcustdata_list, tlbguid, varVal);
}

ICreateTypeInfo2_fnSetDocString()

static HRESULT WINAPI ICreateTypeInfo2_fnSetDocString ( ICreateTypeInfo2 *  iface, LPOLESTR  doc  )

static

Definition at line 10663 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    TRACE("%p %s\n", This, wine_dbgstr_w(doc));
 
    if (!doc)
        return E_INVALIDARG;
 
    This->DocString = TLB_append_str(&This->pTypeLib->string_list, doc);
 
    return S_OK;
}

ICreateTypeInfo2_fnSetFuncAndParamNames()

static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncAndParamNames ( ICreateTypeInfo2 *  iface, UINT  index, LPOLESTR *  names, UINT  numNames  )

static

Definition at line 11111 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    TLBFuncDesc *func_desc = &This->funcdescs[index];
    int i;
 
    TRACE("%p %u %p %u\n", This, index, names, numNames);
 
    if (!names)
        return E_INVALIDARG;
 
    if (index >= This->typeattr.cFuncs || numNames == 0)
        return TYPE_E_ELEMENTNOTFOUND;
 
    if (func_desc->funcdesc.invkind & (INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF)){
        if(numNames > func_desc->funcdesc.cParams)
            return TYPE_E_ELEMENTNOTFOUND;
    } else
        if(numNames > func_desc->funcdesc.cParams + 1)
            return TYPE_E_ELEMENTNOTFOUND;
 
    for(i = 0; i < This->typeattr.cFuncs; ++i) {
        TLBFuncDesc *iter = &This->funcdescs[i];
        if (iter->Name && !wcscmp(TLB_get_bstr(iter->Name), *names)) {
            if (iter->funcdesc.invkind & (INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF | INVOKE_PROPERTYGET) &&
                    func_desc->funcdesc.invkind & (INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF | INVOKE_PROPERTYGET) &&
                    func_desc->funcdesc.invkind != iter->funcdesc.invkind)
                continue;
            return TYPE_E_AMBIGUOUSNAME;
        }
    }
 
    func_desc->Name = TLB_append_str(&This->pTypeLib->name_list, *names);
 
    for (i = 1; i < numNames; ++i) {
        TLBParDesc *par_desc = func_desc->pParamDesc + i - 1;
        par_desc->Name = TLB_append_str(&This->pTypeLib->name_list, *(names + i));
    }
 
    return S_OK;
}

ICreateTypeInfo2_fnSetFuncCustData()

static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncCustData ( ICreateTypeInfo2 *  iface, UINT  index, REFGUID  guid, VARIANT *  varVal  )

static

Definition at line 11498 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %u %s %p - stub\n", This, index, debugstr_guid(guid), varVal);
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnSetFuncDocString()

static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncDocString ( ICreateTypeInfo2 *  iface, UINT  index, LPOLESTR  docString  )

static

Definition at line 11204 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    TLBFuncDesc *func_desc = &This->funcdescs[index];
 
    TRACE("%p %u %s\n", This, index, wine_dbgstr_w(docString));
 
    if(!docString)
        return E_INVALIDARG;
 
    if(index >= This->typeattr.cFuncs)
        return TYPE_E_ELEMENTNOTFOUND;
 
    func_desc->HelpString = TLB_append_str(&This->pTypeLib->string_list, docString);
 
    return S_OK;
}

ICreateTypeInfo2_fnSetFuncHelpContext()

static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncHelpContext ( ICreateTypeInfo2 *  iface, UINT  index, DWORD  helpContext  )

static

Definition at line 11242 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    TLBFuncDesc *func_desc = &This->funcdescs[index];
 
    TRACE("%p %u %d\n", This, index, helpContext);
 
    if(index >= This->typeattr.cFuncs)
        return TYPE_E_ELEMENTNOTFOUND;
 
    func_desc->helpcontext = helpContext;
 
    return S_OK;
}

ICreateTypeInfo2_fnSetFuncHelpStringContext()

static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncHelpStringContext ( ICreateTypeInfo2 *  iface, UINT  index, ULONG  helpStringContext  )

static

Definition at line 11542 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %u %u - stub\n", This, index, helpStringContext);
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnSetGuid()

static HRESULT WINAPI ICreateTypeInfo2_fnSetGuid ( ICreateTypeInfo2 *  iface, REFGUID  guid  )

static

Definition at line 10608 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    TRACE("%p %s\n", This, debugstr_guid(guid));
 
    This->guid = TLB_append_guid(&This->pTypeLib->guid_list, guid, This->hreftype);
 
    return S_OK;
}

ICreateTypeInfo2_fnSetHelpContext()

static HRESULT WINAPI ICreateTypeInfo2_fnSetHelpContext ( ICreateTypeInfo2 *  iface, DWORD  helpContext  )

static

Definition at line 10678 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    TRACE("%p %d\n", This, helpContext);
 
    This->dwHelpContext = helpContext;
 
    return S_OK;
}

ICreateTypeInfo2_fnSetHelpStringContext()

static HRESULT WINAPI ICreateTypeInfo2_fnSetHelpStringContext ( ICreateTypeInfo2 *  iface, ULONG  helpStringContext  )

static

Definition at line 11530 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    TRACE("%p %u\n", This, helpStringContext);
 
    This->dwHelpStringContext = helpStringContext;
 
    return S_OK;
}

ICreateTypeInfo2_fnSetImplTypeCustData()

static HRESULT WINAPI ICreateTypeInfo2_fnSetImplTypeCustData ( ICreateTypeInfo2 *  iface, UINT  index, REFGUID  guid, VARIANT *  varVal  )

static

Definition at line 11522 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %u %s %p - stub\n", This, index, debugstr_guid(guid), varVal);
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnSetImplTypeFlags()

static HRESULT WINAPI ICreateTypeInfo2_fnSetImplTypeFlags ( ICreateTypeInfo2 *  iface, UINT  index, INT  implTypeFlags  )

static

Definition at line 11016 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    TLBImplType *impl_type = &This->impltypes[index];
 
    TRACE("%p %u %x\n", This, index, implTypeFlags);
 
    if (This->typeattr.typekind != TKIND_COCLASS)
        return TYPE_E_BADMODULEKIND;
 
    if (index >= This->typeattr.cImplTypes)
        return TYPE_E_ELEMENTNOTFOUND;
 
    impl_type->implflags = implTypeFlags;
 
    return S_OK;
}

ICreateTypeInfo2_fnSetMops()

static HRESULT WINAPI ICreateTypeInfo2_fnSetMops ( ICreateTypeInfo2 *  iface, UINT  index, BSTR  bstrMops  )

static

Definition at line 11274 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %u %s - stub\n", This, index, wine_dbgstr_w(bstrMops));
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnSetName()

static HRESULT WINAPI ICreateTypeInfo2_fnSetName ( ICreateTypeInfo2 *  iface, LPOLESTR  name  )

static

Definition at line 11565 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    TRACE("%p %s\n", This, wine_dbgstr_w(name));
 
    if (!name)
        return E_INVALIDARG;
 
    This->Name = TLB_append_str(&This->pTypeLib->name_list, name);
 
    return S_OK;
}

ICreateTypeInfo2_fnSetParamCustData()

static HRESULT WINAPI ICreateTypeInfo2_fnSetParamCustData ( ICreateTypeInfo2 *  iface, UINT  funcIndex, UINT  paramIndex, REFGUID  guid, VARIANT *  varVal  )

static

Definition at line 11506 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %u %u %s %p - stub\n", This, funcIndex, paramIndex, debugstr_guid(guid), varVal);
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnSetSchema()

static HRESULT WINAPI ICreateTypeInfo2_fnSetSchema ( ICreateTypeInfo2 *  iface, LPOLESTR  schema  )

static

Definition at line 11047 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    TRACE("%p %s\n", This, wine_dbgstr_w(schema));
 
    if (!schema)
        return E_INVALIDARG;
 
    This->Schema = TLB_append_str(&This->pTypeLib->string_list, schema);
 
    This->typeattr.lpstrSchema = This->Schema->str;
 
    return S_OK;
}

ICreateTypeInfo2_fnSetTypeDescAlias()

static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeDescAlias ( ICreateTypeInfo2 *  iface, TYPEDESC *  tdescAlias  )

static

Definition at line 11171 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    HRESULT hr;
 
    TRACE("%p %p\n", This, tdescAlias);
 
    if(!tdescAlias)
        return E_INVALIDARG;
 
    if(This->typeattr.typekind != TKIND_ALIAS)
        return TYPE_E_BADMODULEKIND;
 
    hr = TLB_size_instance(This, This->pTypeLib->syskind, tdescAlias, &This->typeattr.cbSizeInstance, &This->typeattr.cbAlignment);
    if(FAILED(hr))
        return hr;
 
    heap_free(This->tdescAlias);
    This->tdescAlias = heap_alloc(TLB_SizeTypeDesc(tdescAlias, TRUE));
    TLB_CopyTypeDesc(NULL, tdescAlias, This->tdescAlias);
 
    return S_OK;
}

ICreateTypeInfo2_fnSetTypeFlags()

static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeFlags ( ICreateTypeInfo2 *  iface, UINT  typeFlags  )

static

Definition at line 10620 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    WORD old_flags;
    HRESULT hres;
 
    TRACE("%p %x\n", This, typeFlags);
 
    if (typeFlags & TYPEFLAG_FDUAL) {
        static const WCHAR stdole2tlb[] = { 's','t','d','o','l','e','2','.','t','l','b',0 };
        ITypeLib *stdole;
        ITypeInfo *dispatch;
        HREFTYPE hreftype;
        HRESULT hres;
 
        hres = LoadTypeLib(stdole2tlb, &stdole);
        if(FAILED(hres))
            return hres;
 
        hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IDispatch, &dispatch);
        ITypeLib_Release(stdole);
        if(FAILED(hres))
            return hres;
 
        hres = ICreateTypeInfo2_AddRefTypeInfo(iface, dispatch, &hreftype);
        ITypeInfo_Release(dispatch);
        if(FAILED(hres))
            return hres;
    }
 
    old_flags = This->typeattr.wTypeFlags;
    This->typeattr.wTypeFlags = typeFlags;
 
    hres = ICreateTypeInfo2_LayOut(iface);
    if (FAILED(hres)) {
        This->typeattr.wTypeFlags = old_flags;
        return hres;
    }
 
    return S_OK;
}

ICreateTypeInfo2_fnSetTypeIdldesc()

static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeIdldesc ( ICreateTypeInfo2 *  iface, IDLDESC *  idlDesc  )

static

Definition at line 11282 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    TRACE("%p %p\n", This, idlDesc);
 
    if (!idlDesc)
        return E_INVALIDARG;
 
    This->typeattr.idldescType.dwReserved = idlDesc->dwReserved;
    This->typeattr.idldescType.wIDLFlags = idlDesc->wIDLFlags;
 
    return S_OK;
}

ICreateTypeInfo2_fnSetVarCustData()

static HRESULT WINAPI ICreateTypeInfo2_fnSetVarCustData ( ICreateTypeInfo2 *  iface, UINT  index, REFGUID  guid, VARIANT *  varVal  )

static

Definition at line 11514 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %u %s %p - stub\n", This, index, debugstr_guid(guid), varVal);
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnSetVarDocString()

static HRESULT WINAPI ICreateTypeInfo2_fnSetVarDocString ( ICreateTypeInfo2 *  iface, UINT  index, LPOLESTR  docString  )

static

Definition at line 11223 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    TLBVarDesc *var_desc = &This->vardescs[index];
 
    TRACE("%p %u %s\n", This, index, wine_dbgstr_w(docString));
 
    if(!docString)
        return E_INVALIDARG;
 
    if(index >= This->typeattr.cVars)
        return TYPE_E_ELEMENTNOTFOUND;
 
    var_desc->HelpString = TLB_append_str(&This->pTypeLib->string_list, docString);
 
    return S_OK;
}

ICreateTypeInfo2_fnSetVarHelpContext()

static HRESULT WINAPI ICreateTypeInfo2_fnSetVarHelpContext ( ICreateTypeInfo2 *  iface, UINT  index, DWORD  helpContext  )

static

Definition at line 11258 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    TLBVarDesc *var_desc = &This->vardescs[index];
 
    TRACE("%p %u %d\n", This, index, helpContext);
 
    if(index >= This->typeattr.cVars)
        return TYPE_E_ELEMENTNOTFOUND;
 
    var_desc->HelpContext = helpContext;
 
    return S_OK;
}

ICreateTypeInfo2_fnSetVarHelpStringContext()

static HRESULT WINAPI ICreateTypeInfo2_fnSetVarHelpStringContext ( ICreateTypeInfo2 *  iface, UINT  index, ULONG  helpStringContext  )

static

Definition at line 11550 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
    FIXME("%p %u %u - stub\n", This, index, helpStringContext);
    return E_NOTIMPL;
}

ICreateTypeInfo2_fnSetVarName()

static HRESULT WINAPI ICreateTypeInfo2_fnSetVarName ( ICreateTypeInfo2 *  iface, UINT  index, LPOLESTR  name  )

static

Definition at line 11154 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    TRACE("%p %u %s\n", This, index, wine_dbgstr_w(name));
 
    if(!name)
        return E_INVALIDARG;
 
    if(index >= This->typeattr.cVars)
        return TYPE_E_ELEMENTNOTFOUND;
 
    This->vardescs[index].Name = TLB_append_str(&This->pTypeLib->name_list, name);
    return S_OK;
}

ICreateTypeInfo2_fnSetVersion()

static HRESULT WINAPI ICreateTypeInfo2_fnSetVersion ( ICreateTypeInfo2 *  iface, WORD  majorVerNum, WORD  minorVerNum  )

static

Definition at line 10690 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ICreateTypeInfo2(iface);
 
    TRACE("%p %d %d\n", This, majorVerNum, minorVerNum);
 
    This->typeattr.wMajorVerNum = majorVerNum;
    This->typeattr.wMinorVerNum = minorVerNum;
 
    return S_OK;
}

ICreateTypeLib2_fnAddRef()

static ULONG WINAPI ICreateTypeLib2_fnAddRef ( ICreateTypeLib2 *  iface )

static

Definition at line 9081 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
    return ITypeLib2_AddRef(&This->ITypeLib2_iface);
}

ICreateTypeLib2_fnCreateTypeInfo()

static HRESULT WINAPI ICreateTypeLib2_fnCreateTypeInfo ( ICreateTypeLib2 *  iface, LPOLESTR  name, TYPEKIND  kind, ICreateTypeInfo **  ctinfo  )

static

Definition at line 9095 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
    ITypeInfoImpl *info;
    HRESULT hres;
 
    TRACE("%p %s %d %p\n", This, wine_dbgstr_w(name), kind, ctinfo);
 
    if (!ctinfo || !name)
        return E_INVALIDARG;
 
    info = TLB_get_typeinfo_by_name(This->typeinfos, This->TypeInfoCount, name);
    if (info)
        return TYPE_E_NAMECONFLICT;
 
    if (This->typeinfos)
        This->typeinfos = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->typeinfos,
                sizeof(ITypeInfoImpl*) * (This->TypeInfoCount + 1));
    else
        This->typeinfos = heap_alloc_zero(sizeof(ITypeInfoImpl*));
 
    info = This->typeinfos[This->TypeInfoCount] = ITypeInfoImpl_Constructor();
 
    info->pTypeLib = This;
    info->Name = TLB_append_str(&This->name_list, name);
    info->index = This->TypeInfoCount;
    info->typeattr.typekind = kind;
    info->typeattr.cbAlignment = 4;
 
    switch (info->typeattr.typekind) {
    case TKIND_ENUM:
    case TKIND_INTERFACE:
    case TKIND_DISPATCH:
    case TKIND_COCLASS:
        info->typeattr.cbSizeInstance = This->ptr_size;
        break;
    case TKIND_RECORD:
    case TKIND_UNION:
        info->typeattr.cbSizeInstance = 0;
        break;
    case TKIND_MODULE:
        info->typeattr.cbSizeInstance = 2;
        break;
    case TKIND_ALIAS:
        info->typeattr.cbSizeInstance = -0x75;
        break;
    default:
        FIXME("unrecognized typekind %d\n", info->typeattr.typekind);
        info->typeattr.cbSizeInstance = 0xdeadbeef;
        break;
    }
 
    hres = ITypeInfo2_QueryInterface(&info->ITypeInfo2_iface,
            &IID_ICreateTypeInfo, (void **)ctinfo);
    if (FAILED(hres)) {
        ITypeInfo2_Release(&info->ITypeInfo2_iface);
        return hres;
    }
 
    info->hreftype = info->index * sizeof(MSFT_TypeInfoBase);
 
    ++This->TypeInfoCount;
 
    return S_OK;
}

ICreateTypeLib2_fnDeleteTypeInfo()

static HRESULT WINAPI ICreateTypeLib2_fnDeleteTypeInfo ( ICreateTypeLib2 *  iface, LPOLESTR  name  )

static

Definition at line 10520 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
    FIXME("%p %s - stub\n", This, wine_dbgstr_w(name));
    return E_NOTIMPL;
}

ICreateTypeLib2_fnQueryInterface()

static HRESULT WINAPI ICreateTypeLib2_fnQueryInterface ( ICreateTypeLib2 *  iface, REFIID  riid, void **  object  )

static

Definition at line 9073 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
    return ITypeLib2_QueryInterface(&This->ITypeLib2_iface, riid, object);
}

ICreateTypeLib2_fnRelease()

static ULONG WINAPI ICreateTypeLib2_fnRelease ( ICreateTypeLib2 *  iface )

static

Definition at line 9088 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
    return ITypeLib2_Release(&This->ITypeLib2_iface);
}

ICreateTypeLib2_fnSaveAllChanges()

static HRESULT WINAPI ICreateTypeLib2_fnSaveAllChanges ( ICreateTypeLib2 *  iface )

static

Definition at line 10306 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
    WMSFT_TLBFile file;
    DWORD written, junk_size, junk_offs, running_offset;
    BOOL br;
    HANDLE outfile;
    HRESULT hres;
    DWORD *junk;
    UINT i;
 
    TRACE("%p\n", This);
 
    for(i = 0; i < This->TypeInfoCount; ++i)
        if(This->typeinfos[i]->needs_layout)
            ICreateTypeInfo2_LayOut(&This->typeinfos[i]->ICreateTypeInfo2_iface);
 
    memset(&file, 0, sizeof(file));
 
    file.header.magic1 = 0x5446534D;
    file.header.magic2 = 0x00010002;
    file.header.lcid = This->set_lcid ? This->set_lcid : MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
    file.header.lcid2 = This->set_lcid;
    file.header.varflags = 0x40 | This->syskind;
    if (This->HelpFile)
        file.header.varflags |= 0x10;
    if (This->HelpStringDll)
        file.header.varflags |= HELPDLLFLAG;
    file.header.version = (This->ver_minor << 16) | This->ver_major;
    file.header.flags = This->libflags;
    file.header.helpstringcontext = 0; /* TODO - SetHelpStringContext not implemented yet */
    file.header.helpcontext = This->dwHelpContext;
    file.header.res44 = 0x20;
    file.header.res48 = 0x80;
    file.header.dispatchpos = This->dispatch_href;
 
    WMSFT_compile_namehash(This, &file);
    /* do name and string compilation to get offsets for other compilations */
    hres = WMSFT_compile_names(This, &file);
    if (FAILED(hres)){
        WMSFT_free_file(&file);
        return hres;
    }
 
    hres = WMSFT_compile_strings(This, &file);
    if (FAILED(hres)){
        WMSFT_free_file(&file);
        return hres;
    }
 
    WMSFT_compile_guidhash(This, &file);
    hres = WMSFT_compile_guids(This, &file);
    if (FAILED(hres)){
        WMSFT_free_file(&file);
        return hres;
    }
 
    if(This->HelpFile)
        file.header.helpfile = This->HelpFile->offset;
    else
        file.header.helpfile = -1;
 
    if(This->DocString)
        file.header.helpstring = This->DocString->offset;
    else
        file.header.helpstring = -1;
 
    /* do some more segment compilation */
    file.header.nimpinfos = list_count(&This->ref_list);
    file.header.nrtypeinfos = This->TypeInfoCount;
 
    if(This->Name)
        file.header.NameOffset = This->Name->offset;
    else
        file.header.NameOffset = -1;
 
    file.header.CustomDataOffset = WMSFT_compile_custdata(&This->custdata_list, &file);
 
    if(This->guid)
        file.header.posguid = This->guid->offset;
    else
        file.header.posguid = -1;
 
    junk_size = file.header.nrtypeinfos * sizeof(DWORD);
    if(file.header.varflags & HELPDLLFLAG)
        junk_size += sizeof(DWORD);
    if(junk_size){
        junk = heap_alloc_zero(junk_size);
        if(file.header.varflags & HELPDLLFLAG){
            *junk = This->HelpStringDll->offset;
            junk_offs = 1;
        }else
            junk_offs = 0;
    }else{
        junk = NULL;
        junk_offs = 0;
    }
 
    WMSFT_compile_typeinfo_seg(This, &file, junk + junk_offs);
    WMSFT_compile_impinfo(This, &file);
 
    running_offset = 0;
 
    TRACE("header at: 0x%x\n", running_offset);
    running_offset += sizeof(file.header);
 
    TRACE("junk at: 0x%x\n", running_offset);
    running_offset += junk_size;
 
    TRACE("segdir at: 0x%x\n", running_offset);
    running_offset += sizeof(file.segdir);
 
    TRACE("typeinfo at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pTypeInfoTab, &file.typeinfo_seg, &running_offset);
 
    TRACE("guidhashtab at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pGuidHashTab, &file.guidhash_seg, &running_offset);
 
    TRACE("guidtab at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pGuidTab, &file.guid_seg, &running_offset);
 
    TRACE("reftab at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pRefTab, &file.ref_seg, &running_offset);
 
    TRACE("impinfo at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pImpInfo, &file.impinfo_seg, &running_offset);
 
    TRACE("impfiles at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pImpFiles, &file.impfile_seg, &running_offset);
 
    TRACE("namehashtab at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pNameHashTab, &file.namehash_seg, &running_offset);
 
    TRACE("nametab at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pNametab, &file.name_seg, &running_offset);
 
    TRACE("stringtab at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pStringtab, &file.string_seg, &running_offset);
 
    TRACE("typdesc at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pTypdescTab, &file.typdesc_seg, &running_offset);
 
    TRACE("arraydescriptions at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pArrayDescriptions, &file.arraydesc_seg, &running_offset);
 
    TRACE("custdata at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pCustData, &file.custdata_seg, &running_offset);
 
    TRACE("cdguids at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.pCDGuids, &file.cdguids_seg, &running_offset);
 
    TRACE("res0e at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.res0e, NULL, &running_offset);
 
    TRACE("res0f at: 0x%x\n", running_offset);
    tmp_fill_segdir_seg(&file.segdir.res0f, NULL, &running_offset);
 
    TRACE("aux_seg at: 0x%x\n", running_offset);
 
    WMSFT_fixup_typeinfos(This, &file, running_offset);
 
    outfile = CreateFileW(This->path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
            FILE_ATTRIBUTE_NORMAL, 0);
    if (outfile == INVALID_HANDLE_VALUE){
        WMSFT_free_file(&file);
        heap_free(junk);
        return TYPE_E_IOERROR;
    }
 
    br = WriteFile(outfile, &file.header, sizeof(file.header), &written, NULL);
    if (!br) {
        WMSFT_free_file(&file);
        CloseHandle(outfile);
        heap_free(junk);
        return TYPE_E_IOERROR;
    }
 
    br = WriteFile(outfile, junk, junk_size, &written, NULL);
    heap_free(junk);
    if (!br) {
        WMSFT_free_file(&file);
        CloseHandle(outfile);
        return TYPE_E_IOERROR;
    }
 
    br = WriteFile(outfile, &file.segdir, sizeof(file.segdir), &written, NULL);
    if (!br) {
        WMSFT_free_file(&file);
        CloseHandle(outfile);
        return TYPE_E_IOERROR;
    }
 
    WMSFT_write_segment(outfile, &file.typeinfo_seg);
    WMSFT_write_segment(outfile, &file.guidhash_seg);
    WMSFT_write_segment(outfile, &file.guid_seg);
    WMSFT_write_segment(outfile, &file.ref_seg);
    WMSFT_write_segment(outfile, &file.impinfo_seg);
    WMSFT_write_segment(outfile, &file.impfile_seg);
    WMSFT_write_segment(outfile, &file.namehash_seg);
    WMSFT_write_segment(outfile, &file.name_seg);
    WMSFT_write_segment(outfile, &file.string_seg);
    WMSFT_write_segment(outfile, &file.typdesc_seg);
    WMSFT_write_segment(outfile, &file.arraydesc_seg);
    WMSFT_write_segment(outfile, &file.custdata_seg);
    WMSFT_write_segment(outfile, &file.cdguids_seg);
    WMSFT_write_segment(outfile, &file.aux_seg);
 
    WMSFT_free_file(&file);
 
    CloseHandle(outfile);
 
    return S_OK;
}

ICreateTypeLib2_fnSetCustData()

static HRESULT WINAPI ICreateTypeLib2_fnSetCustData ( ICreateTypeLib2 *  iface, REFGUID  guid, VARIANT *  varVal  )

static

Definition at line 10528 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
    TLBGuid *tlbguid;
 
    TRACE("%p %s %p\n", This, debugstr_guid(guid), varVal);
 
    if (!guid || !varVal)
        return E_INVALIDARG;
 
    tlbguid = TLB_append_guid(&This->guid_list, guid, -1);
 
    return TLB_set_custdata(&This->custdata_list, tlbguid, varVal);
}

ICreateTypeLib2_fnSetDocString()

static HRESULT WINAPI ICreateTypeLib2_fnSetDocString ( ICreateTypeLib2 *  iface, LPOLESTR  doc  )

static

Definition at line 9202 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
    TRACE("%p %s\n", This, wine_dbgstr_w(doc));
 
    if (!doc)
        return E_INVALIDARG;
 
    This->DocString = TLB_append_str(&This->string_list, doc);
 
    return S_OK;
}

ICreateTypeLib2_fnSetGuid()

static HRESULT WINAPI ICreateTypeLib2_fnSetGuid ( ICreateTypeLib2 *  iface, REFGUID  guid  )

static

Definition at line 9190 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
    TRACE("%p %s\n", This, debugstr_guid(guid));
 
    This->guid = TLB_append_guid(&This->guid_list, guid, -2);
 
    return S_OK;
}

ICreateTypeLib2_fnSetHelpContext()

static HRESULT WINAPI ICreateTypeLib2_fnSetHelpContext ( ICreateTypeLib2 *  iface, DWORD  helpContext  )

static

Definition at line 9232 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
    TRACE("%p %d\n", This, helpContext);
 
    This->dwHelpContext = helpContext;
 
    return S_OK;
}

ICreateTypeLib2_fnSetHelpFileName()

static HRESULT WINAPI ICreateTypeLib2_fnSetHelpFileName ( ICreateTypeLib2 *  iface, LPOLESTR  helpFileName  )

static

Definition at line 9217 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
    TRACE("%p %s\n", This, wine_dbgstr_w(helpFileName));
 
    if (!helpFileName)
        return E_INVALIDARG;
 
    This->HelpFile = TLB_append_str(&This->string_list, helpFileName);
 
    return S_OK;
}

ICreateTypeLib2_fnSetHelpStringContext()

static HRESULT WINAPI ICreateTypeLib2_fnSetHelpStringContext ( ICreateTypeLib2 *  iface, ULONG  helpStringContext  )

static

Definition at line 10544 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
    FIXME("%p %u - stub\n", This, helpStringContext);
    return E_NOTIMPL;
}

ICreateTypeLib2_fnSetHelpStringDll()

static HRESULT WINAPI ICreateTypeLib2_fnSetHelpStringDll ( ICreateTypeLib2 *  iface, LPOLESTR  filename  )

static

Definition at line 10552 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
    TRACE("%p %s\n", This, wine_dbgstr_w(filename));
 
    if (!filename)
        return E_INVALIDARG;
 
    This->HelpStringDll = TLB_append_str(&This->string_list, filename);
 
    return S_OK;
}

ICreateTypeLib2_fnSetLcid()

static HRESULT WINAPI ICreateTypeLib2_fnSetLcid ( ICreateTypeLib2 *  iface, LCID  lcid  )

static

Definition at line 9244 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
    TRACE("%p %x\n", This, lcid);
 
    This->set_lcid = lcid;
 
    return S_OK;
}

ICreateTypeLib2_fnSetLibFlags()

static HRESULT WINAPI ICreateTypeLib2_fnSetLibFlags ( ICreateTypeLib2 *  iface, UINT  libFlags  )

static

Definition at line 9256 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
    TRACE("%p %x\n", This, libFlags);
 
    This->libflags = libFlags;
 
    return S_OK;
}

ICreateTypeLib2_fnSetName()

static HRESULT WINAPI ICreateTypeLib2_fnSetName ( ICreateTypeLib2 *  iface, LPOLESTR  name  )

static

Definition at line 9162 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
    TRACE("%p %s\n", This, wine_dbgstr_w(name));
 
    if (!name)
        return E_INVALIDARG;
 
    This->Name = TLB_append_str(&This->name_list, name);
 
    return S_OK;
}

ICreateTypeLib2_fnSetVersion()

static HRESULT WINAPI ICreateTypeLib2_fnSetVersion ( ICreateTypeLib2 *  iface, WORD  majorVerNum, WORD  minorVerNum  )

static

Definition at line 9177 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ICreateTypeLib2(iface);
 
    TRACE("%p %d %d\n", This, majorVerNum, minorVerNum);
 
    This->ver_major = majorVerNum;
    This->ver_minor = minorVerNum;
 
    return S_OK;
}

impl_from_ICreateTypeLib2()

static ITypeLibImpl * impl_from_ICreateTypeLib2 ( ICreateTypeLib2 *  iface )

inlinestatic

Definition at line 1164 of file typelib.c.

{
    return CONTAINING_RECORD(iface, ITypeLibImpl, ICreateTypeLib2_iface);
}

Referenced by ICreateTypeLib2_fnAddRef(), ICreateTypeLib2_fnCreateTypeInfo(), ICreateTypeLib2_fnDeleteTypeInfo(), ICreateTypeLib2_fnQueryInterface(), ICreateTypeLib2_fnRelease(), ICreateTypeLib2_fnSaveAllChanges(), ICreateTypeLib2_fnSetCustData(), ICreateTypeLib2_fnSetDocString(), ICreateTypeLib2_fnSetGuid(), ICreateTypeLib2_fnSetHelpContext(), ICreateTypeLib2_fnSetHelpFileName(), ICreateTypeLib2_fnSetHelpStringContext(), ICreateTypeLib2_fnSetHelpStringDll(), ICreateTypeLib2_fnSetLcid(), ICreateTypeLib2_fnSetLibFlags(), ICreateTypeLib2_fnSetName(), and ICreateTypeLib2_fnSetVersion().

impl_from_ITypeComp()

static ITypeLibImpl * impl_from_ITypeComp ( ITypeComp *  iface )

inlinestatic

Definition at line 1159 of file typelib.c.

{
    return CONTAINING_RECORD(iface, ITypeLibImpl, ITypeComp_iface);
}

Referenced by ITypeLibComp_fnAddRef(), ITypeLibComp_fnBind(), ITypeLibComp_fnBindType(), ITypeLibComp_fnQueryInterface(), and ITypeLibComp_fnRelease().

impl_from_ITypeInfo()

static ITypeInfoImpl * impl_from_ITypeInfo ( ITypeInfo *  iface )

inlinestatic

Definition at line 1289 of file typelib.c.

{
    return impl_from_ITypeInfo2((ITypeInfo2*)iface);
}

Referenced by ICreateTypeInfo2_fnAddRefTypeInfo(), ITypeInfoImpl_GetDispatchRefTypeInfo(), ITypeInfoImpl_GetInternalDispatchFuncDesc(), and ITypeInfoImpl_GetInternalFuncDesc().

impl_from_ITypeInfo2()

static ITypeInfoImpl * impl_from_ITypeInfo2 ( ITypeInfo2 *  iface )

inlinestatic

Definition at line 1284 of file typelib.c.

{
    return CONTAINING_RECORD(iface, ITypeInfoImpl, ITypeInfo2_iface);
}

Referenced by impl_from_ITypeInfo(), ITypeInfo2_fnGetAllCustData(), ITypeInfo2_fnGetAllFuncCustData(), ITypeInfo2_fnGetAllImplTypeCustData(), ITypeInfo2_fnGetAllParamCustData(), ITypeInfo2_fnGetAllVarCustData(), ITypeInfo2_fnGetCustData(), ITypeInfo2_fnGetDocumentation2(), ITypeInfo2_fnGetFuncCustData(), ITypeInfo2_fnGetFuncIndexOfMemId(), ITypeInfo2_fnGetImplTypeCustData(), ITypeInfo2_fnGetParamCustData(), ITypeInfo2_fnGetTypeFlags(), ITypeInfo2_fnGetTypeKind(), ITypeInfo2_fnGetVarCustData(), ITypeInfo2_fnGetVarIndexOfMemId(), ITypeInfo_fnAddRef(), ITypeInfo_fnAddressOfMember(), ITypeInfo_fnCreateInstance(), ITypeInfo_fnGetContainingTypeLib(), ITypeInfo_fnGetDllEntry(), ITypeInfo_fnGetDocumentation(), ITypeInfo_fnGetFuncDesc(), ITypeInfo_fnGetIDsOfNames(), ITypeInfo_fnGetImplTypeFlags(), ITypeInfo_fnGetMops(), ITypeInfo_fnGetNames(), ITypeInfo_fnGetRefTypeInfo(), ITypeInfo_fnGetRefTypeOfImplType(), ITypeInfo_fnGetTypeAttr(), ITypeInfo_fnGetTypeComp(), ITypeInfo_fnGetVarDesc(), ITypeInfo_fnInvoke(), ITypeInfo_fnQueryInterface(), ITypeInfo_fnRelease(), ITypeInfo_fnReleaseFuncDesc(), ITypeInfo_fnReleaseTypeAttr(), and ITypeInfo_fnReleaseVarDesc().

impl_from_ITypeLib()

static ITypeLibImpl * impl_from_ITypeLib ( ITypeLib *  iface )

inlinestatic

Definition at line 1154 of file typelib.c.

{
    return impl_from_ITypeLib2((ITypeLib2*)iface);
}

Referenced by ITypeInfo_fnGetRefTypeInfo(), and search_res_tlb().

impl_from_ITypeLib2()

static ITypeLibImpl * impl_from_ITypeLib2 ( ITypeLib2 *  iface )

inlinestatic

Definition at line 1149 of file typelib.c.

{
    return CONTAINING_RECORD(iface, ITypeLibImpl, ITypeLib2_iface);
}

Referenced by ICreateTypeInfo2_fnAddRefTypeInfo(), impl_from_ITypeLib(), ITypeLib2_fnAddRef(), ITypeLib2_fnFindName(), ITypeLib2_fnGetAllCustData(), ITypeLib2_fnGetCustData(), ITypeLib2_fnGetDocumentation(), ITypeLib2_fnGetDocumentation2(), ITypeLib2_fnGetLibAttr(), ITypeLib2_fnGetLibStatistics(), ITypeLib2_fnGetTypeComp(), ITypeLib2_fnGetTypeInfo(), ITypeLib2_fnGetTypeInfoCount(), ITypeLib2_fnGetTypeInfoOfGuid(), ITypeLib2_fnGetTypeInfoType(), ITypeLib2_fnIsName(), ITypeLib2_fnQueryInterface(), ITypeLib2_fnRelease(), ITypeLib2_fnReleaseTLibAttr(), and TLB_ReadTypeLib().

info_impl_from_ICreateTypeInfo2()

static ITypeInfoImpl * info_impl_from_ICreateTypeInfo2 ( ICreateTypeInfo2 *  iface )

inlinestatic

Definition at line 1294 of file typelib.c.

{
    return CONTAINING_RECORD(iface, ITypeInfoImpl, ICreateTypeInfo2_iface);
}

Referenced by ICreateTypeInfo2_fnAddFuncDesc(), ICreateTypeInfo2_fnAddImplType(), ICreateTypeInfo2_fnAddRef(), ICreateTypeInfo2_fnAddRefTypeInfo(), ICreateTypeInfo2_fnAddVarDesc(), ICreateTypeInfo2_fnDefineFuncAsDllEntry(), ICreateTypeInfo2_fnDeleteFuncDesc(), ICreateTypeInfo2_fnDeleteFuncDescByMemId(), ICreateTypeInfo2_fnDeleteImplType(), ICreateTypeInfo2_fnDeleteVarDesc(), ICreateTypeInfo2_fnDeleteVarDescByMemId(), ICreateTypeInfo2_fnInvalidate(), ICreateTypeInfo2_fnLayOut(), ICreateTypeInfo2_fnQueryInterface(), ICreateTypeInfo2_fnRelease(), ICreateTypeInfo2_fnSetAlignment(), ICreateTypeInfo2_fnSetCustData(), ICreateTypeInfo2_fnSetDocString(), ICreateTypeInfo2_fnSetFuncAndParamNames(), ICreateTypeInfo2_fnSetFuncCustData(), ICreateTypeInfo2_fnSetFuncDocString(), ICreateTypeInfo2_fnSetFuncHelpContext(), ICreateTypeInfo2_fnSetFuncHelpStringContext(), ICreateTypeInfo2_fnSetGuid(), ICreateTypeInfo2_fnSetHelpContext(), ICreateTypeInfo2_fnSetHelpStringContext(), ICreateTypeInfo2_fnSetImplTypeCustData(), ICreateTypeInfo2_fnSetImplTypeFlags(), ICreateTypeInfo2_fnSetMops(), ICreateTypeInfo2_fnSetName(), ICreateTypeInfo2_fnSetParamCustData(), ICreateTypeInfo2_fnSetSchema(), ICreateTypeInfo2_fnSetTypeDescAlias(), ICreateTypeInfo2_fnSetTypeFlags(), ICreateTypeInfo2_fnSetTypeIdldesc(), ICreateTypeInfo2_fnSetVarCustData(), ICreateTypeInfo2_fnSetVarDocString(), ICreateTypeInfo2_fnSetVarHelpContext(), ICreateTypeInfo2_fnSetVarHelpStringContext(), ICreateTypeInfo2_fnSetVarName(), and ICreateTypeInfo2_fnSetVersion().

info_impl_from_ITypeComp()

static ITypeInfoImpl * info_impl_from_ITypeComp ( ITypeComp *  iface )

inlinestatic

Definition at line 1279 of file typelib.c.

{
    return CONTAINING_RECORD(iface, ITypeInfoImpl, ITypeComp_iface);
}

Referenced by ITypeComp_fnAddRef(), ITypeComp_fnBind(), ITypeComp_fnQueryInterface(), and ITypeComp_fnRelease().

ITypeComp_fnAddRef()

static ULONG WINAPI ITypeComp_fnAddRef ( ITypeComp *  iface )

static

Definition at line 8908 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
 
    return ITypeInfo2_AddRef(&This->ITypeInfo2_iface);
}

ITypeComp_fnBind()

static HRESULT WINAPI ITypeComp_fnBind ( ITypeComp *  iface, OLECHAR *  szName, ULONG  lHash, WORD  wFlags, ITypeInfo **  ppTInfo, DESCKIND *  pDescKind, BINDPTR *  pBindPtr  )

static

Definition at line 8922 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
    const TLBFuncDesc *pFDesc;
    const TLBVarDesc *pVDesc;
    HRESULT hr = DISP_E_MEMBERNOTFOUND;
    UINT fdc;
 
    TRACE("(%p)->(%s, %x, 0x%x, %p, %p, %p)\n", This, debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
 
    *pDescKind = DESCKIND_NONE;
    pBindPtr->lpfuncdesc = NULL;
    *ppTInfo = NULL;
 
    for(fdc = 0; fdc < This->typeattr.cFuncs; ++fdc){
        pFDesc = &This->funcdescs[fdc];
        if (!lstrcmpiW(TLB_get_bstr(pFDesc->Name), szName)) {
            if (!wFlags || (pFDesc->funcdesc.invkind & wFlags))
                break;
            else
                /* name found, but wrong flags */
                hr = TYPE_E_TYPEMISMATCH;
        }
    }
 
    if (fdc < This->typeattr.cFuncs)
    {
        HRESULT hr = TLB_AllocAndInitFuncDesc(
            &pFDesc->funcdesc,
            &pBindPtr->lpfuncdesc,
            This->typeattr.typekind == TKIND_DISPATCH);
        if (FAILED(hr))
            return hr;
        *pDescKind = DESCKIND_FUNCDESC;
        *ppTInfo = (ITypeInfo *)&This->ITypeInfo2_iface;
        ITypeInfo_AddRef(*ppTInfo);
        return S_OK;
    } else {
        pVDesc = TLB_get_vardesc_by_name(This->vardescs, This->typeattr.cVars, szName);
        if(pVDesc){
            HRESULT hr = TLB_AllocAndInitVarDesc(&pVDesc->vardesc, &pBindPtr->lpvardesc);
            if (FAILED(hr))
                return hr;
            *pDescKind = DESCKIND_VARDESC;
            *ppTInfo = (ITypeInfo *)&This->ITypeInfo2_iface;
            ITypeInfo_AddRef(*ppTInfo);
            return S_OK;
        }
    }
 
    if (hr == DISP_E_MEMBERNOTFOUND && This->impltypes) {
        /* recursive search */
        ITypeInfo *pTInfo;
        ITypeComp *pTComp;
        HRESULT hr;
        hr=ITypeInfo2_GetRefTypeInfo(&This->ITypeInfo2_iface, This->impltypes[0].hRef, &pTInfo);
        if (SUCCEEDED(hr))
        {
            hr = ITypeInfo_GetTypeComp(pTInfo,&pTComp);
            ITypeInfo_Release(pTInfo);
        }
        if (SUCCEEDED(hr))
        {
            hr = ITypeComp_Bind(pTComp, szName, lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
            ITypeComp_Release(pTComp);
            if (SUCCEEDED(hr) && *pDescKind == DESCKIND_FUNCDESC &&
                    This->typeattr.typekind == TKIND_DISPATCH)
            {
                FUNCDESC *tmp = pBindPtr->lpfuncdesc;
                hr = TLB_AllocAndInitFuncDesc(tmp, &pBindPtr->lpfuncdesc, TRUE);
                SysFreeString((BSTR)tmp);
            }
            return hr;
        }
        WARN("Could not search inherited interface!\n");
    }
    if (hr == DISP_E_MEMBERNOTFOUND)
        hr = S_OK;
    TRACE("did not find member with name %s, flags 0x%x\n", debugstr_w(szName), wFlags);
    return hr;
}

ITypeComp_fnBindType()

static HRESULT WINAPI ITypeComp_fnBindType ( ITypeComp *  iface, OLECHAR *  szName, ULONG  lHash, ITypeInfo **  ppTInfo, ITypeComp **  ppTComp  )

static

Definition at line 9011 of file typelib.c.

{
    TRACE("(%s, %x, %p, %p)\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
 
    /* strange behaviour (does nothing) but like the
     * original */
 
    if (!ppTInfo || !ppTComp)
        return E_POINTER;
 
    *ppTInfo = NULL;
    *ppTComp = NULL;
 
    return S_OK;
}

ITypeComp_fnQueryInterface()

static HRESULT WINAPI ITypeComp_fnQueryInterface ( ITypeComp *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 8901 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
 
    return ITypeInfo2_QueryInterface(&This->ITypeInfo2_iface, riid, ppv);
}

ITypeComp_fnRelease()

static ULONG WINAPI ITypeComp_fnRelease ( ITypeComp *  iface )

static

Definition at line 8915 of file typelib.c.

{
    ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
 
    return ITypeInfo2_Release(&This->ITypeInfo2_iface);
}

ITypeInfo2_fnGetAllCustData()

static HRESULT WINAPI ITypeInfo2_fnGetAllCustData ( ITypeInfo2 *  iface, CUSTDATA *  pCustData  )

static

Definition at line 8640 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
 
    TRACE("%p %p\n", This, pCustData);
 
    return TLB_copy_all_custdata(This->pcustdata_list, pCustData);
}

ITypeInfo2_fnGetAllFuncCustData()

static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData ( ITypeInfo2 *  iface, UINT  index, CUSTDATA *  pCustData  )

static

Definition at line 8656 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    TLBFuncDesc *pFDesc = &This->funcdescs[index];
 
    TRACE("%p %u %p\n", This, index, pCustData);
 
    if(index >= This->typeattr.cFuncs)
        return TYPE_E_ELEMENTNOTFOUND;
 
    return TLB_copy_all_custdata(&pFDesc->custdata_list, pCustData);
}

ITypeInfo2_fnGetAllImplTypeCustData()

static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData ( ITypeInfo2 *  iface, UINT  index, CUSTDATA *  pCustData  )

static

Definition at line 8718 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    TLBImplType *pRDesc = &This->impltypes[index];
 
    TRACE("%p %u %p\n", This, index, pCustData);
 
    if(index >= This->typeattr.cImplTypes)
        return TYPE_E_ELEMENTNOTFOUND;
 
    return TLB_copy_all_custdata(&pRDesc->custdata_list, pCustData);
}

ITypeInfo2_fnGetAllParamCustData()

static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData ( ITypeInfo2 *  iface, UINT  indexFunc, UINT  indexParam, CUSTDATA *  pCustData  )

static

Definition at line 8677 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    TLBFuncDesc *pFDesc = &This->funcdescs[indexFunc];
 
    TRACE("%p %u %u %p\n", This, indexFunc, indexParam, pCustData);
 
    if(indexFunc >= This->typeattr.cFuncs)
        return TYPE_E_ELEMENTNOTFOUND;
 
    if(indexParam >= pFDesc->funcdesc.cParams)
        return TYPE_E_ELEMENTNOTFOUND;
 
    return TLB_copy_all_custdata(&pFDesc->pParamDesc[indexParam].custdata_list, pCustData);
}

ITypeInfo2_fnGetAllVarCustData()

static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData ( ITypeInfo2 *  iface, UINT  index, CUSTDATA *  pCustData  )

static

Definition at line 8699 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    TLBVarDesc * pVDesc = &This->vardescs[index];
 
    TRACE("%p %u %p\n", This, index, pCustData);
 
    if(index >= This->typeattr.cVars)
        return TYPE_E_ELEMENTNOTFOUND;
 
    return TLB_copy_all_custdata(&pVDesc->custdata_list, pCustData);
}

ITypeInfo2_fnGetCustData()

static HRESULT WINAPI ITypeInfo2_fnGetCustData ( ITypeInfo2 *  iface, REFGUID  guid, VARIANT *  pVarVal  )

static

Definition at line 8429 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    TLBCustData *pCData;
 
    TRACE("%p %s %p\n", This, debugstr_guid(guid), pVarVal);
 
    if(!guid || !pVarVal)
        return E_INVALIDARG;
 
    pCData = TLB_get_custdata_by_guid(This->pcustdata_list, guid);
 
    VariantInit( pVarVal);
    if (pCData)
        VariantCopy( pVarVal, &pCData->data);
    else
        VariantClear( pVarVal );
    return S_OK;
}

ITypeInfo2_fnGetDocumentation2()

static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2 ( ITypeInfo2 *  iface, MEMBERID  memid, LCID  lcid, BSTR *  pbstrHelpString, DWORD *  pdwHelpStringContext, BSTR *  pbstrHelpStringDll  )

static

Definition at line 8580 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    const TLBFuncDesc *pFDesc;
    const TLBVarDesc *pVDesc;
    TRACE("(%p) memid %d lcid(0x%x)  HelpString(%p) "
          "HelpStringContext(%p) HelpStringDll(%p)\n",
          This, memid, lcid, pbstrHelpString, pdwHelpStringContext,
          pbstrHelpStringDll );
    /* the help string should be obtained from the helpstringdll,
     * using the _DLLGetDocumentation function, based on the supplied
     * lcid. Nice to do sometime...
     */
    if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
        if(pbstrHelpString)
            *pbstrHelpString=SysAllocString(TLB_get_bstr(This->Name));
        if(pdwHelpStringContext)
            *pdwHelpStringContext=This->dwHelpStringContext;
        if(pbstrHelpStringDll)
            *pbstrHelpStringDll=
                SysAllocString(TLB_get_bstr(This->pTypeLib->HelpStringDll));/* FIXME */
        return S_OK;
    }else {/* for a member */
        pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->typeattr.cFuncs, memid);
        if(pFDesc){
            if(pbstrHelpString)
                *pbstrHelpString=SysAllocString(TLB_get_bstr(pFDesc->HelpString));
            if(pdwHelpStringContext)
                *pdwHelpStringContext=pFDesc->HelpStringContext;
            if(pbstrHelpStringDll)
                *pbstrHelpStringDll=
                    SysAllocString(TLB_get_bstr(This->pTypeLib->HelpStringDll));/* FIXME */
            return S_OK;
        }
        pVDesc = TLB_get_vardesc_by_memberid(This->vardescs, This->typeattr.cVars, memid);
        if(pVDesc){
            if(pbstrHelpString)
                *pbstrHelpString=SysAllocString(TLB_get_bstr(pVDesc->HelpString));
            if(pdwHelpStringContext)
                *pdwHelpStringContext=pVDesc->HelpStringContext;
            if(pbstrHelpStringDll)
                *pbstrHelpStringDll=
                    SysAllocString(TLB_get_bstr(This->pTypeLib->HelpStringDll));/* FIXME */
            return S_OK;
        }
    }
    return TYPE_E_ELEMENTNOTFOUND;
}

ITypeInfo2_fnGetFuncCustData()

static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData ( ITypeInfo2 *  iface, UINT  index, REFGUID  guid, VARIANT *  pVarVal  )

static

Definition at line 8456 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    TLBCustData *pCData;
    TLBFuncDesc *pFDesc = &This->funcdescs[index];
 
    TRACE("%p %u %s %p\n", This, index, debugstr_guid(guid), pVarVal);
 
    if(index >= This->typeattr.cFuncs)
        return TYPE_E_ELEMENTNOTFOUND;
 
    pCData = TLB_get_custdata_by_guid(&pFDesc->custdata_list, guid);
    if(!pCData)
        return TYPE_E_ELEMENTNOTFOUND;
 
    VariantInit(pVarVal);
    VariantCopy(pVarVal, &pCData->data);
 
    return S_OK;
}

ITypeInfo2_fnGetFuncIndexOfMemId()

static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId ( ITypeInfo2 *  iface, MEMBERID  memid, INVOKEKIND  invKind, UINT *  pFuncIndex  )

static

Definition at line 8379 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    UINT fdc;
    HRESULT result;
 
    for (fdc = 0; fdc < This->typeattr.cFuncs; ++fdc){
        const TLBFuncDesc *pFuncInfo = &This->funcdescs[fdc];
        if(memid == pFuncInfo->funcdesc.memid && (invKind & pFuncInfo->funcdesc.invkind))
            break;
    }
    if(fdc < This->typeattr.cFuncs) {
        *pFuncIndex = fdc;
        result = S_OK;
    } else
        result = TYPE_E_ELEMENTNOTFOUND;
 
    TRACE("(%p) memid 0x%08x invKind 0x%04x -> %s\n", This,
          memid, invKind, SUCCEEDED(result) ? "SUCCESS" : "FAILED");
    return result;
}

ITypeInfo2_fnGetImplTypeCustData()

static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData ( ITypeInfo2 *  iface, UINT  index, REFGUID  guid, VARIANT *  pVarVal  )

static

Definition at line 8548 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    TLBCustData *pCData;
    TLBImplType *pRDesc = &This->impltypes[index];
 
    TRACE("%p %u %s %p\n", This, index, debugstr_guid(guid), pVarVal);
 
    if(index >= This->typeattr.cImplTypes)
        return TYPE_E_ELEMENTNOTFOUND;
 
    pCData = TLB_get_custdata_by_guid(&pRDesc->custdata_list, guid);
    if(!pCData)
        return TYPE_E_ELEMENTNOTFOUND;
 
    VariantInit(pVarVal);
    VariantCopy(pVarVal, &pCData->data);
 
    return S_OK;
}

ITypeInfo2_fnGetParamCustData()

static HRESULT WINAPI ITypeInfo2_fnGetParamCustData ( ITypeInfo2 *  iface, UINT  indexFunc, UINT  indexParam, REFGUID  guid, VARIANT *  pVarVal  )

static

Definition at line 8485 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    TLBCustData *pCData;
    TLBFuncDesc *pFDesc = &This->funcdescs[indexFunc];
 
    TRACE("%p %u %u %s %p\n", This, indexFunc, indexParam,
            debugstr_guid(guid), pVarVal);
 
    if(indexFunc >= This->typeattr.cFuncs)
        return TYPE_E_ELEMENTNOTFOUND;
 
    if(indexParam >= pFDesc->funcdesc.cParams)
        return TYPE_E_ELEMENTNOTFOUND;
 
    pCData = TLB_get_custdata_by_guid(&pFDesc->pParamDesc[indexParam].custdata_list, guid);
    if(!pCData)
        return TYPE_E_ELEMENTNOTFOUND;
 
    VariantInit(pVarVal);
    VariantCopy(pVarVal, &pCData->data);
 
    return S_OK;
}

ITypeInfo2_fnGetTypeFlags()

static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags ( ITypeInfo2 *  iface, ULONG *  pTypeFlags  )

static

Definition at line 8366 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    *pTypeFlags=This->typeattr.wTypeFlags;
    TRACE("(%p) flags 0x%x\n", This,*pTypeFlags);
    return S_OK;
}

ITypeInfo2_fnGetTypeKind()

static HRESULT WINAPI ITypeInfo2_fnGetTypeKind ( ITypeInfo2 *  iface, TYPEKIND *  pTypeKind  )

static

Definition at line 8350 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    *pTypeKind = This->typeattr.typekind;
    TRACE("(%p) type 0x%0x\n", This,*pTypeKind);
    return S_OK;
}

ITypeInfo2_fnGetVarCustData()

static HRESULT WINAPI ITypeInfo2_fnGetVarCustData ( ITypeInfo2 *  iface, UINT  index, REFGUID  guid, VARIANT *  pVarVal  )

static

Definition at line 8519 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    TLBCustData *pCData;
    TLBVarDesc *pVDesc = &This->vardescs[index];
 
    TRACE("%p %s %p\n", This, debugstr_guid(guid), pVarVal);
 
    if(index >= This->typeattr.cVars)
        return TYPE_E_ELEMENTNOTFOUND;
 
    pCData = TLB_get_custdata_by_guid(&pVDesc->custdata_list, guid);
    if(!pCData)
        return TYPE_E_ELEMENTNOTFOUND;
 
    VariantInit(pVarVal);
    VariantCopy(pVarVal, &pCData->data);
 
    return S_OK;
}

ITypeInfo2_fnGetVarIndexOfMemId()

static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId ( ITypeInfo2 *  iface, MEMBERID  memid, UINT *  pVarIndex  )

static

Definition at line 8408 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    TLBVarDesc *pVarInfo;
 
    TRACE("%p %d %p\n", iface, memid, pVarIndex);
 
    pVarInfo = TLB_get_vardesc_by_memberid(This->vardescs, This->typeattr.cVars, memid);
    if(!pVarInfo)
        return TYPE_E_ELEMENTNOTFOUND;
 
    *pVarIndex = (pVarInfo - This->vardescs);
 
    return S_OK;
}

ITypeInfo_fnAddRef()

static ULONG WINAPI ITypeInfo_fnAddRef ( ITypeInfo2 *  iface )

static

Definition at line 5677 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p)->ref is %u\n",This, ref);
 
    if (ref == 1 /* incremented from 0 */)
        ITypeLib2_AddRef(&This->pTypeLib->ITypeLib2_iface);
 
    return ref;
}

ITypeInfo_fnAddressOfMember()

static HRESULT WINAPI ITypeInfo_fnAddressOfMember ( ITypeInfo2 *  iface, MEMBERID  memid, INVOKEKIND  invKind, PVOID *  ppv  )

static

Definition at line 8152 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    HRESULT hr;
    BSTR dll, entry;
    WORD ordinal;
    HMODULE module;
 
    TRACE("(%p)->(0x%x, 0x%x, %p)\n", This, memid, invKind, ppv);
 
    hr = ITypeInfo2_GetDllEntry(iface, memid, invKind, &dll, &entry, &ordinal);
    if (FAILED(hr))
        return hr;
 
    module = LoadLibraryW(dll);
    if (!module)
    {
        ERR("couldn't load %s\n", debugstr_w(dll));
        SysFreeString(dll);
        SysFreeString(entry);
        return STG_E_FILENOTFOUND;
    }
    /* FIXME: store library somewhere where we can free it */
 
    if (entry)
    {
        LPSTR entryA;
        INT len = WideCharToMultiByte(CP_ACP, 0, entry, -1, NULL, 0, NULL, NULL);
        entryA = heap_alloc(len);
        WideCharToMultiByte(CP_ACP, 0, entry, -1, entryA, len, NULL, NULL);
 
        *ppv = GetProcAddress(module, entryA);
        if (!*ppv)
            ERR("function not found %s\n", debugstr_a(entryA));
 
        heap_free(entryA);
    }
    else
    {
        *ppv = GetProcAddress(module, MAKEINTRESOURCEA(ordinal));
        if (!*ppv)
            ERR("function not found %d\n", ordinal);
    }
 
    SysFreeString(dll);
    SysFreeString(entry);
 
    if (!*ppv)
        return TYPE_E_DLLFUNCTIONNOTFOUND;
 
    return S_OK;
}

ITypeInfo_fnCreateInstance()

static HRESULT WINAPI ITypeInfo_fnCreateInstance ( ITypeInfo2 *  iface, IUnknown *  pOuterUnk, REFIID  riid, VOID **  ppvObj  )

static

Definition at line 8211 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    HRESULT hr;
    TYPEATTR *pTA;
 
    TRACE("(%p)->(%p, %s, %p)\n", This, pOuterUnk, debugstr_guid(riid), ppvObj);
 
    *ppvObj = NULL;
 
    if(pOuterUnk)
    {
        WARN("Not able to aggregate\n");
        return CLASS_E_NOAGGREGATION;
    }
 
    hr = ITypeInfo2_GetTypeAttr(iface, &pTA);
    if(FAILED(hr)) return hr;
 
    if(pTA->typekind != TKIND_COCLASS)
    {
        WARN("CreateInstance on typeinfo of type %x\n", pTA->typekind);
        hr = E_INVALIDARG;
        goto end;
    }
 
    hr = S_FALSE;
    if(pTA->wTypeFlags & TYPEFLAG_FAPPOBJECT)
    {
        IUnknown *pUnk;
        hr = GetActiveObject(&pTA->guid, NULL, &pUnk);
        TRACE("GetActiveObject rets %08x\n", hr);
        if(hr == S_OK)
        {
            hr = IUnknown_QueryInterface(pUnk, riid, ppvObj);
            IUnknown_Release(pUnk);
        }
    }
 
    if(hr != S_OK)
        hr = CoCreateInstance(&pTA->guid, NULL,
                              CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
                              riid, ppvObj);
 
end:
    ITypeInfo2_ReleaseTypeAttr(iface, pTA);
    return hr;
}

ITypeInfo_fnGetContainingTypeLib()

static HRESULT WINAPI ITypeInfo_fnGetContainingTypeLib ( ITypeInfo2 *  iface, ITypeLib **  ppTLib, UINT *  pIndex  )

static

Definition at line 8279 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
 
    /* If a pointer is null, we simply ignore it, the ATL in particular passes pIndex as 0 */
    if (pIndex) {
      *pIndex=This->index;
      TRACE("returning pIndex=%d\n", *pIndex);
    }
 
    if (ppTLib) {
      *ppTLib = (ITypeLib *)&This->pTypeLib->ITypeLib2_iface;
      ITypeLib_AddRef(*ppTLib);
      TRACE("returning ppTLib=%p\n", *ppTLib);
    }
 
    return S_OK;
}

ITypeInfo_fnGetDllEntry()

static HRESULT WINAPI ITypeInfo_fnGetDllEntry ( ITypeInfo2 *  iface, MEMBERID  memid, INVOKEKIND  invKind, BSTR *  pBstrDllName, BSTR *  pBstrName, WORD *  pwOrdinal  )

static

Definition at line 7892 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    const TLBFuncDesc *pFDesc;
 
    TRACE("(%p)->(memid %x, %d, %p, %p, %p)\n", This, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
 
    if (pBstrDllName) *pBstrDllName = NULL;
    if (pBstrName) *pBstrName = NULL;
    if (pwOrdinal) *pwOrdinal = 0;
 
    if (This->typeattr.typekind != TKIND_MODULE)
        return TYPE_E_BADMODULEKIND;
 
    pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->typeattr.cFuncs, memid);
    if(pFDesc){
        dump_TypeInfo(This);
        if (TRACE_ON(ole))
        dump_TLBFuncDescOne(pFDesc);
 
        if (pBstrDllName)
        *pBstrDllName = SysAllocString(TLB_get_bstr(This->DllName));
 
            if (!IS_INTRESOURCE(pFDesc->Entry) && (pFDesc->Entry != (void*)-1)) {
        if (pBstrName)
            *pBstrName = SysAllocString(TLB_get_bstr(pFDesc->Entry));
        if (pwOrdinal)
            *pwOrdinal = -1;
        return S_OK;
        }
        if (pBstrName)
        *pBstrName = NULL;
        if (pwOrdinal)
        *pwOrdinal = LOWORD(pFDesc->Entry);
        return S_OK;
        }
    return TYPE_E_ELEMENTNOTFOUND;
}

ITypeInfo_fnGetDocumentation()

static HRESULT WINAPI ITypeInfo_fnGetDocumentation ( ITypeInfo2 *  iface, MEMBERID  memid, BSTR *  pBstrName, BSTR *  pBstrDocString, DWORD *  pdwHelpContext, BSTR *  pBstrHelpFile  )

static

Definition at line 7821 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    const TLBFuncDesc *pFDesc;
    const TLBVarDesc *pVDesc;
    TRACE("(%p) memid %d Name(%p) DocString(%p)"
          " HelpContext(%p) HelpFile(%p)\n",
        This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
    if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
        if(pBstrName)
            *pBstrName=SysAllocString(TLB_get_bstr(This->Name));
        if(pBstrDocString)
            *pBstrDocString=SysAllocString(TLB_get_bstr(This->DocString));
        if(pdwHelpContext)
            *pdwHelpContext=This->dwHelpContext;
        if(pBstrHelpFile)
            *pBstrHelpFile=SysAllocString(TLB_get_bstr(This->pTypeLib->HelpFile));
        return S_OK;
    }else {/* for a member */
        pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->typeattr.cFuncs, memid);
        if(pFDesc){
            if(pBstrName)
              *pBstrName = SysAllocString(TLB_get_bstr(pFDesc->Name));
            if(pBstrDocString)
              *pBstrDocString=SysAllocString(TLB_get_bstr(pFDesc->HelpString));
            if(pdwHelpContext)
              *pdwHelpContext=pFDesc->helpcontext;
            if(pBstrHelpFile)
              *pBstrHelpFile = SysAllocString(TLB_get_bstr(This->pTypeLib->HelpFile));
            return S_OK;
        }
        pVDesc = TLB_get_vardesc_by_memberid(This->vardescs, This->typeattr.cVars, memid);
        if(pVDesc){
            if(pBstrName)
              *pBstrName = SysAllocString(TLB_get_bstr(pVDesc->Name));
            if(pBstrDocString)
              *pBstrDocString=SysAllocString(TLB_get_bstr(pVDesc->HelpString));
            if(pdwHelpContext)
              *pdwHelpContext=pVDesc->HelpContext;
            if(pBstrHelpFile)
              *pBstrHelpFile = SysAllocString(TLB_get_bstr(This->pTypeLib->HelpFile));
            return S_OK;
        }
    }
 
    if(This->impltypes &&
       (This->typeattr.typekind == TKIND_INTERFACE || This->typeattr.typekind == TKIND_DISPATCH)) {
        /* recursive search */
        ITypeInfo *pTInfo;
        HRESULT result;
        result = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
        if(SUCCEEDED(result)) {
            result = ITypeInfo_GetDocumentation(pTInfo, memid, pBstrName,
                pBstrDocString, pdwHelpContext, pBstrHelpFile);
            ITypeInfo_Release(pTInfo);
            return result;
        }
        WARN("Could not search inherited interface!\n");
    }
 
    WARN("member %d not found\n", memid);
    return TYPE_E_ELEMENTNOTFOUND;
}

ITypeInfo_fnGetFuncDesc()

static HRESULT WINAPI ITypeInfo_fnGetFuncDesc ( ITypeInfo2 *  iface, UINT  index, LPFUNCDESC *  ppFuncDesc  )

static

Definition at line 6069 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    const FUNCDESC *internal_funcdesc;
    HRESULT hr;
    UINT hrefoffset = 0;
 
    TRACE("(%p) index %d\n", This, index);
 
    if (!ppFuncDesc)
        return E_INVALIDARG;
 
    if (This->needs_layout)
        ICreateTypeInfo2_LayOut(&This->ICreateTypeInfo2_iface);
 
    if (This->typeattr.typekind == TKIND_DISPATCH)
        hr = ITypeInfoImpl_GetInternalDispatchFuncDesc((ITypeInfo *)iface, index,
                                                       &internal_funcdesc, NULL,
                                                       &hrefoffset);
    else
        hr = ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo *)iface, index,
                                               &internal_funcdesc);
    if (FAILED(hr))
    {
        WARN("description for function %d not found\n", index);
        return hr;
    }
 
    hr = TLB_AllocAndInitFuncDesc(
        internal_funcdesc,
        ppFuncDesc,
        This->typeattr.typekind == TKIND_DISPATCH);
 
    if ((This->typeattr.typekind == TKIND_DISPATCH) && hrefoffset)
        ITypeInfoImpl_FuncDescAddHrefOffset(*ppFuncDesc, hrefoffset);
 
    TRACE("-- 0x%08x\n", hr);
    return hr;
}

ITypeInfo_fnGetIDsOfNames()

static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames ( ITypeInfo2 *  iface, LPOLESTR *  rgszNames, UINT  cNames, MEMBERID *  pMemId  )

static

Definition at line 6349 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    const TLBVarDesc *pVDesc;
    HRESULT ret=S_OK;
    UINT i, fdc;
 
    TRACE("(%p) Name %s cNames %d\n", This, debugstr_w(*rgszNames),
            cNames);
 
    /* init out parameters in case of failure */
    for (i = 0; i < cNames; i++)
        pMemId[i] = MEMBERID_NIL;
 
    for (fdc = 0; fdc < This->typeattr.cFuncs; ++fdc) {
        int j;
        const TLBFuncDesc *pFDesc = &This->funcdescs[fdc];
        if(!lstrcmpiW(*rgszNames, TLB_get_bstr(pFDesc->Name))) {
            if(cNames) *pMemId=pFDesc->funcdesc.memid;
            for(i=1; i < cNames; i++){
                for(j=0; j<pFDesc->funcdesc.cParams; j++)
                    if(!lstrcmpiW(rgszNames[i],TLB_get_bstr(pFDesc->pParamDesc[j].Name)))
                            break;
                if( j<pFDesc->funcdesc.cParams)
                    pMemId[i]=j;
                else
                   ret=DISP_E_UNKNOWNNAME;
            };
            TRACE("-- 0x%08x\n", ret);
            return ret;
        }
    }
    pVDesc = TLB_get_vardesc_by_name(This->vardescs, This->typeattr.cVars, *rgszNames);
    if(pVDesc){
        if(cNames)
            *pMemId = pVDesc->vardesc.memid;
        return ret;
    }
    /* not found, see if it can be found in an inherited interface */
    if(This->impltypes) {
        /* recursive search */
        ITypeInfo *pTInfo;
        ret = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
        if(SUCCEEDED(ret)){
            ret=ITypeInfo_GetIDsOfNames(pTInfo, rgszNames, cNames, pMemId );
            ITypeInfo_Release(pTInfo);
            return ret;
        }
        WARN("Could not search inherited interface!\n");
    } else
        WARN("no names found\n");
    return DISP_E_UNKNOWNNAME;
}

ITypeInfo_fnGetImplTypeFlags()

static HRESULT WINAPI ITypeInfo_fnGetImplTypeFlags ( ITypeInfo2 *  iface, UINT  index, INT *  pImplTypeFlags  )

static

Definition at line 6322 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
 
    TRACE("(%p) index %d\n", This, index);
 
    if(!pImplTypeFlags)
        return E_INVALIDARG;
 
    if(This->typeattr.typekind == TKIND_DISPATCH && index == 0){
        *pImplTypeFlags = 0;
        return S_OK;
    }
 
    if(index >= This->typeattr.cImplTypes)
        return TYPE_E_ELEMENTNOTFOUND;
 
    *pImplTypeFlags = This->impltypes[index].implflags;
 
    return S_OK;
}

ITypeInfo_fnGetMops()

static HRESULT WINAPI ITypeInfo_fnGetMops ( ITypeInfo2 *  iface, MEMBERID  memid, BSTR *  pBstrMops  )

static

Definition at line 8265 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    FIXME("(%p %d) stub!\n", This, memid);
    *pBstrMops = NULL;
    return S_OK;
}

ITypeInfo_fnGetNames()

static HRESULT WINAPI ITypeInfo_fnGetNames ( ITypeInfo2 *  iface, MEMBERID  memid, BSTR *  rgBstrNames, UINT  cMaxNames, UINT *  pcNames  )

static

Definition at line 6191 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    const TLBFuncDesc *pFDesc;
    const TLBVarDesc *pVDesc;
    int i;
    TRACE("(%p) memid=0x%08x Maxname=%d\n", This, memid, cMaxNames);
 
    if(!rgBstrNames)
        return E_INVALIDARG;
 
    *pcNames = 0;
 
    pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->typeattr.cFuncs, memid);
    if(pFDesc)
    {
        if(!cMaxNames || !pFDesc->Name)
            return S_OK;
 
        *rgBstrNames = SysAllocString(TLB_get_bstr(pFDesc->Name));
        ++(*pcNames);
 
        for(i = 0; i < pFDesc->funcdesc.cParams; ++i){
            if(*pcNames >= cMaxNames || !pFDesc->pParamDesc[i].Name)
                return S_OK;
            rgBstrNames[*pcNames] = SysAllocString(TLB_get_bstr(pFDesc->pParamDesc[i].Name));
            ++(*pcNames);
        }
        return S_OK;
    }
 
    pVDesc = TLB_get_vardesc_by_memberid(This->vardescs, This->typeattr.cVars, memid);
    if(pVDesc)
    {
      *rgBstrNames=SysAllocString(TLB_get_bstr(pVDesc->Name));
      *pcNames=1;
    }
    else
    {
        if(This->impltypes &&
       (This->typeattr.typekind == TKIND_INTERFACE || This->typeattr.typekind == TKIND_DISPATCH)) {
          /* recursive search */
          ITypeInfo *pTInfo;
          HRESULT result;
          result = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
          if(SUCCEEDED(result))
      {
            result=ITypeInfo_GetNames(pTInfo, memid, rgBstrNames, cMaxNames, pcNames);
            ITypeInfo_Release(pTInfo);
            return result;
          }
          WARN("Could not search inherited interface!\n");
        }
        else
    {
          WARN("no names found\n");
    }
        *pcNames=0;
        return TYPE_E_ELEMENTNOTFOUND;
    }
    return S_OK;
}

ITypeInfo_fnGetRefTypeInfo()

static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo ( ITypeInfo2 *  iface, HREFTYPE  hRefType, ITypeInfo **  ppTInfo  )

static

Definition at line 8009 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    HRESULT result = E_FAIL;
 
    if(!ppTInfo)
        return E_INVALIDARG;
 
    if ((INT)hRefType < 0) {
        ITypeInfoImpl *pTypeInfoImpl;
 
        if (!(This->typeattr.wTypeFlags & TYPEFLAG_FDUAL) ||
                !(This->typeattr.typekind == TKIND_INTERFACE ||
                    This->typeattr.typekind == TKIND_DISPATCH))
            return TYPE_E_ELEMENTNOTFOUND;
 
        /* when we meet a DUAL typeinfo, we must create the alternate
        * version of it.
        */
        pTypeInfoImpl = ITypeInfoImpl_Constructor();
 
        *pTypeInfoImpl = *This;
        pTypeInfoImpl->ref = 0;
        list_init(&pTypeInfoImpl->custdata_list);
 
        if (This->typeattr.typekind == TKIND_INTERFACE)
            pTypeInfoImpl->typeattr.typekind = TKIND_DISPATCH;
        else
            pTypeInfoImpl->typeattr.typekind = TKIND_INTERFACE;
 
        *ppTInfo = (ITypeInfo *)&pTypeInfoImpl->ITypeInfo2_iface;
        /* the AddRef implicitly adds a reference to the parent typelib, which
         * stops the copied data from being destroyed until the new typeinfo's
         * refcount goes to zero, but we need to signal to the new instance to
         * not free its data structures when it is destroyed */
        pTypeInfoImpl->not_attached_to_typelib = TRUE;
 
        ITypeInfo_AddRef(*ppTInfo);
 
        result = S_OK;
    } else if ((hRefType & DISPATCH_HREF_MASK) &&
        (This->typeattr.typekind == TKIND_DISPATCH))
    {
        HREFTYPE href_dispatch = hRefType;
        result = ITypeInfoImpl_GetDispatchRefTypeInfo((ITypeInfo *)iface, &href_dispatch, ppTInfo);
    } else {
        TLBRefType *ref_type;
        ITypeLib *pTLib = NULL;
        UINT i;
 
        if(!(hRefType & 0x1)){
            for(i = 0; i < This->pTypeLib->TypeInfoCount; ++i)
            {
                if (This->pTypeLib->typeinfos[i]->hreftype == (hRefType&(~0x3)))
                {
                    result = S_OK;
                    *ppTInfo = (ITypeInfo*)&This->pTypeLib->typeinfos[i]->ITypeInfo2_iface;
                    ITypeInfo_AddRef(*ppTInfo);
                    goto end;
                }
            }
        }
 
        LIST_FOR_EACH_ENTRY(ref_type, &This->pTypeLib->ref_list, TLBRefType, entry)
        {
            if(ref_type->reference == (hRefType & (~0x3)))
                break;
        }
        if(&ref_type->entry == &This->pTypeLib->ref_list)
        {
            FIXME("Can't find pRefType for ref %x\n", hRefType);
            goto end;
        }
 
        if(ref_type->pImpTLInfo == TLB_REF_INTERNAL) {
            UINT Index;
            TRACE("internal reference\n");
            result = ITypeInfo2_GetContainingTypeLib(iface, &pTLib, &Index);
        } else {
            if(ref_type->pImpTLInfo->pImpTypeLib) {
                TRACE("typeinfo in imported typelib that is already loaded\n");
                pTLib = (ITypeLib*)&ref_type->pImpTLInfo->pImpTypeLib->ITypeLib2_iface;
                ITypeLib_AddRef(pTLib);
                result = S_OK;
            } else {
                static const WCHAR TYPELIBW[] = {'T','Y','P','E','L','I','B',0};
                struct search_res_tlb_params params;
                BSTR libnam;
 
                TRACE("typeinfo in imported typelib that isn't already loaded\n");
 
                /* Search in resource table */
                params.guid  = TLB_get_guid_null(ref_type->pImpTLInfo->guid);
                params.pTLib = NULL;
                EnumResourceNamesW(NULL, TYPELIBW, search_res_tlb, (LONG_PTR)&params);
                pTLib  = params.pTLib;
                result = S_OK;
 
                if (!pTLib)
                {
                    /* Search on disk */
                    result = query_typelib_path(TLB_get_guid_null(ref_type->pImpTLInfo->guid),
                            ref_type->pImpTLInfo->wVersionMajor,
                            ref_type->pImpTLInfo->wVersionMinor,
                            This->pTypeLib->syskind,
                            ref_type->pImpTLInfo->lcid, &libnam, TRUE);
                    if (FAILED(result))
                        libnam = SysAllocString(ref_type->pImpTLInfo->name);
 
                    result = LoadTypeLib(libnam, &pTLib);
                    SysFreeString(libnam);
                }
 
                if(SUCCEEDED(result)) {
                    ref_type->pImpTLInfo->pImpTypeLib = impl_from_ITypeLib(pTLib);
                    ITypeLib_AddRef(pTLib);
                }
            }
        }
        if(SUCCEEDED(result)) {
            if(ref_type->index == TLB_REF_USE_GUID)
                result = ITypeLib_GetTypeInfoOfGuid(pTLib, TLB_get_guid_null(ref_type->guid), ppTInfo);
            else
                result = ITypeLib_GetTypeInfo(pTLib, ref_type->index, ppTInfo);
        }
        if (pTLib != NULL)
            ITypeLib_Release(pTLib);
    }
 
end:
    TRACE("(%p) hreftype 0x%04x loaded %s (%p)\n", This, hRefType,
          SUCCEEDED(result)? "SUCCESS":"FAILURE", *ppTInfo);
    return result;
}

ITypeInfo_fnGetRefTypeOfImplType()

static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType ( ITypeInfo2 *  iface, UINT  index, HREFTYPE *  pRefType  )

static

Definition at line 6264 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    HRESULT hr = S_OK;
 
    TRACE("(%p) index %d\n", This, index);
    if (TRACE_ON(ole)) dump_TypeInfo(This);
 
    if(index==(UINT)-1)
    {
      /* only valid on dual interfaces;
         retrieve the associated TKIND_INTERFACE handle for the current TKIND_DISPATCH
      */
 
      if (This->typeattr.wTypeFlags & TYPEFLAG_FDUAL)
      {
          *pRefType = -2;
      }
      else
      {
        hr = TYPE_E_ELEMENTNOTFOUND;
      }
    }
    else if(index == 0 && This->typeattr.typekind == TKIND_DISPATCH)
    {
      /* All TKIND_DISPATCHs are made to look like they inherit from IDispatch */
      *pRefType = This->pTypeLib->dispatch_href;
    }
    else
    {
        if(index >= This->typeattr.cImplTypes)
            hr = TYPE_E_ELEMENTNOTFOUND;
        else{
            *pRefType = This->impltypes[index].hRef;
            if (This->typeattr.typekind == TKIND_INTERFACE)
                *pRefType |= 0x2;
        }
    }
 
    if(TRACE_ON(ole))
    {
        if(SUCCEEDED(hr))
            TRACE("SUCCESS -- hRef = 0x%08x\n", *pRefType );
        else
            TRACE("FAILURE -- hresult = 0x%08x\n", hr);
    }
 
    return hr;
}

ITypeInfo_fnGetTypeAttr()

static HRESULT WINAPI ITypeInfo_fnGetTypeAttr ( ITypeInfo2 *  iface, LPTYPEATTR *  ppTypeAttr  )

static

Definition at line 5766 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    SIZE_T size;
 
    TRACE("(%p)\n",This);
 
    size = sizeof(**ppTypeAttr);
    if (This->typeattr.typekind == TKIND_ALIAS && This->tdescAlias)
        size += TLB_SizeTypeDesc(This->tdescAlias, FALSE);
 
    *ppTypeAttr = heap_alloc(size);
    if (!*ppTypeAttr)
        return E_OUTOFMEMORY;
 
    **ppTypeAttr = This->typeattr;
    (*ppTypeAttr)->guid = *TLB_get_guid_null(This->guid);
 
    if (This->tdescAlias)
        TLB_CopyTypeDesc(&(*ppTypeAttr)->tdescAlias, This->tdescAlias, *ppTypeAttr + 1);
 
    if((*ppTypeAttr)->typekind == TKIND_DISPATCH) {
        /* This should include all the inherited funcs */
        (*ppTypeAttr)->cFuncs = (*ppTypeAttr)->cbSizeVft / This->pTypeLib->ptr_size;
        /* This is always the size of IDispatch's vtbl */
        (*ppTypeAttr)->cbSizeVft = sizeof(IDispatchVtbl);
        (*ppTypeAttr)->wTypeFlags &= ~TYPEFLAG_FOLEAUTOMATION;
    }
    return S_OK;
}

ITypeInfo_fnGetTypeComp()

static HRESULT WINAPI ITypeInfo_fnGetTypeComp ( ITypeInfo2 *  iface, ITypeComp **  ppTComp  )

static

Definition at line 5804 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
 
    TRACE("(%p)->(%p)\n", This, ppTComp);
 
    *ppTComp = &This->ITypeComp_iface;
    ITypeComp_AddRef(*ppTComp);
    return S_OK;
}

ITypeInfo_fnGetVarDesc()

static HRESULT WINAPI ITypeInfo_fnGetVarDesc ( ITypeInfo2 *  iface, UINT  index, LPVARDESC *  ppVarDesc  )

static

Definition at line 6168 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    const TLBVarDesc *pVDesc = &This->vardescs[index];
 
    TRACE("(%p) index %d\n", This, index);
 
    if(index >= This->typeattr.cVars)
        return TYPE_E_ELEMENTNOTFOUND;
 
    if (This->needs_layout)
        ICreateTypeInfo2_LayOut(&This->ICreateTypeInfo2_iface);
 
    return TLB_AllocAndInitVarDesc(&pVDesc->vardesc, ppVarDesc);
}

ITypeInfo_fnInvoke()

static HRESULT WINAPI ITypeInfo_fnInvoke ( ITypeInfo2 *  iface, VOID *  pIUnk, MEMBERID  memid, UINT16  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  pArgErr  )

static

Definition at line 7283 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    int i;
    unsigned int var_index;
    TYPEKIND type_kind;
    HRESULT hres;
    const TLBFuncDesc *pFuncInfo;
    UINT fdc;
 
    TRACE("(%p)(%p,id=%d,flags=0x%08x,%p,%p,%p,%p)\n",
      This,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr
    );
 
    if( This->typeattr.wTypeFlags & TYPEFLAG_FRESTRICTED )
        return DISP_E_MEMBERNOTFOUND;
 
    if (!pDispParams)
    {
        ERR("NULL pDispParams not allowed\n");
        return E_INVALIDARG;
    }
 
    dump_DispParms(pDispParams);
 
    if (pDispParams->cNamedArgs > pDispParams->cArgs)
    {
        ERR("named argument array cannot be bigger than argument array (%d/%d)\n",
            pDispParams->cNamedArgs, pDispParams->cArgs);
        return E_INVALIDARG;
    }
 
    /* we do this instead of using GetFuncDesc since it will return a fake
     * FUNCDESC for dispinterfaces and we want the real function description */
    for (fdc = 0; fdc < This->typeattr.cFuncs; ++fdc){
        pFuncInfo = &This->funcdescs[fdc];
        if ((memid == pFuncInfo->funcdesc.memid) &&
            (wFlags & pFuncInfo->funcdesc.invkind) &&
            !func_restricted( &pFuncInfo->funcdesc ))
            break;
    }
 
    if (fdc < This->typeattr.cFuncs) {
        const FUNCDESC *func_desc = &pFuncInfo->funcdesc;
 
        if (TRACE_ON(ole))
        {
            TRACE("invoking:\n");
            dump_TLBFuncDescOne(pFuncInfo);
        }
        
    switch (func_desc->funckind) {
    case FUNC_PUREVIRTUAL:
    case FUNC_VIRTUAL: {
            void *buffer = heap_alloc_zero(INVBUF_ELEMENT_SIZE * func_desc->cParams);
            VARIANT varresult;
            VARIANT retval; /* pointer for storing byref retvals in */
            VARIANTARG **prgpvarg = INVBUF_GET_ARG_PTR_ARRAY(buffer, func_desc->cParams);
            VARIANTARG *rgvarg = INVBUF_GET_ARG_ARRAY(buffer, func_desc->cParams);
            VARTYPE *rgvt = INVBUF_GET_ARG_TYPE_ARRAY(buffer, func_desc->cParams);
            UINT cNamedArgs = pDispParams->cNamedArgs;
            DISPID *rgdispidNamedArgs = pDispParams->rgdispidNamedArgs;
            UINT vargs_converted=0;
 
            hres = S_OK;
 
            if (func_desc->invkind & (INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF))
            {
                if (!cNamedArgs || (rgdispidNamedArgs[0] != DISPID_PROPERTYPUT))
                {
                    ERR("first named arg for property put invocation must be DISPID_PROPERTYPUT\n");
                    hres = DISP_E_PARAMNOTFOUND;
                    goto func_fail;
                }
            }
 
            if (func_desc->cParamsOpt < 0 && cNamedArgs)
            {
                ERR("functions with the vararg attribute do not support named arguments\n");
                hres = DISP_E_NONAMEDARGS;
                goto func_fail;
            }
 
            for (i = 0; i < func_desc->cParams; i++)
            {
                TYPEDESC *tdesc = &func_desc->lprgelemdescParam[i].tdesc;
                hres = typedescvt_to_variantvt((ITypeInfo *)iface, tdesc, &rgvt[i]);
                if (FAILED(hres))
                    goto func_fail;
            }
 
            TRACE("changing args\n");
            for (i = 0; i < func_desc->cParams; i++)
            {
                USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
                TYPEDESC *tdesc = &func_desc->lprgelemdescParam[i].tdesc;
                VARIANTARG *src_arg;
 
                if (wParamFlags & PARAMFLAG_FLCID)
                {
                    VARIANTARG *arg;
                    arg = prgpvarg[i] = &rgvarg[i];
                    V_VT(arg) = VT_I4;
                    V_I4(arg) = This->pTypeLib->lcid;
                    continue;
                }
 
                src_arg = NULL;
 
                if (cNamedArgs)
                {
                    USHORT j;
                    for (j = 0; j < cNamedArgs; j++)
                        if (rgdispidNamedArgs[j] == i || (i == func_desc->cParams-1 && rgdispidNamedArgs[j] == DISPID_PROPERTYPUT))
                        {
                            src_arg = &pDispParams->rgvarg[j];
                            break;
                        }
                }
 
                if (!src_arg && vargs_converted + cNamedArgs < pDispParams->cArgs)
                {
                    src_arg = &pDispParams->rgvarg[pDispParams->cArgs - 1 - vargs_converted];
                    vargs_converted++;
                }
 
                if (wParamFlags & PARAMFLAG_FRETVAL)
                {
                    /* under most conditions the caller is not allowed to
                     * pass in a dispparam arg in the index of what would be
                     * the retval parameter. however, there is an exception
                     * where the extra parameter is used in an extra
                     * IDispatch::Invoke below */
                    if ((i < pDispParams->cArgs) &&
                        ((func_desc->cParams != 1) || !pVarResult ||
                         !(func_desc->invkind & INVOKE_PROPERTYGET)))
                    {
                        hres = DISP_E_BADPARAMCOUNT;
                        break;
                    }
 
                    /* note: this check is placed so that if the caller passes
                     * in a VARIANTARG for the retval we just ignore it, like
                     * native does */
                    if (i == func_desc->cParams - 1)
                    {
                        VARIANTARG *arg;
                        arg = prgpvarg[i] = &rgvarg[i];
                        memset(arg, 0, sizeof(*arg));
                        V_VT(arg) = rgvt[i];
                        memset(&retval, 0, sizeof(retval));
                        V_BYREF(arg) = &retval;
                    }
                    else
                    {
                        ERR("[retval] parameter must be the last parameter of the method (%d/%d)\n", i, func_desc->cParams);
                        hres = E_UNEXPECTED;
                        break;
                    }
                }
                else if (src_arg && !((wParamFlags & PARAMFLAG_FOPT) &&
                         V_VT(src_arg) == VT_ERROR && V_ERROR(src_arg) == DISP_E_PARAMNOTFOUND))
                {
                    TRACE("%s\n", debugstr_variant(src_arg));
 
                    if(rgvt[i]!=V_VT(src_arg))
                    {
                        if (rgvt[i] == VT_VARIANT)
                            hres = VariantCopy(&rgvarg[i], src_arg);
                        else if (rgvt[i] == (VT_VARIANT | VT_BYREF))
                        {
                            if (rgvt[i] == V_VT(src_arg))
                                V_VARIANTREF(&rgvarg[i]) = V_VARIANTREF(src_arg);
                            else
                            {
                                VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
                                if (wParamFlags & PARAMFLAG_FIN)
                                    hres = VariantCopy(&missing_arg[i], src_arg);
                                V_VARIANTREF(&rgvarg[i]) = &missing_arg[i];
                            }
                            V_VT(&rgvarg[i]) = rgvt[i];
                        }
                        else if ((rgvt[i] == (VT_VARIANT | VT_ARRAY) || rgvt[i] == (VT_VARIANT | VT_ARRAY | VT_BYREF)) && func_desc->cParamsOpt < 0)
                        {
                            SAFEARRAY *a;
                            SAFEARRAYBOUND bound;
                            VARIANT *v;
                            LONG j;
                            bound.lLbound = 0;
                            bound.cElements = pDispParams->cArgs-i;
                            if (!(a = SafeArrayCreate(VT_VARIANT, 1, &bound)))
                            {
                                ERR("SafeArrayCreate failed\n");
                                break;
                            }
                            hres = SafeArrayAccessData(a, (LPVOID)&v);
                            if (hres != S_OK)
                            {
                                ERR("SafeArrayAccessData failed with %x\n", hres);
                                SafeArrayDestroy(a);
                                break;
                            }
                            for (j = 0; j < bound.cElements; j++)
                                VariantCopy(&v[j], &pDispParams->rgvarg[pDispParams->cArgs - 1 - i - j]);
                            hres = SafeArrayUnaccessData(a);
                            if (hres != S_OK)
                            {
                                ERR("SafeArrayUnaccessData failed with %x\n", hres);
                                SafeArrayDestroy(a);
                                break;
                            }
                            if (rgvt[i] & VT_BYREF)
                                V_BYREF(&rgvarg[i]) = &a;
                            else
                                V_ARRAY(&rgvarg[i]) = a;
                            V_VT(&rgvarg[i]) = rgvt[i];
                        }
                        else if ((rgvt[i] & VT_BYREF) && !V_ISBYREF(src_arg))
                        {
                            VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
                            if (wParamFlags & PARAMFLAG_FIN)
                                hres = VariantChangeType(&missing_arg[i], src_arg, 0, rgvt[i] & ~VT_BYREF);
                            else
                                V_VT(&missing_arg[i]) = rgvt[i] & ~VT_BYREF;
                            V_BYREF(&rgvarg[i]) = &V_NONE(&missing_arg[i]);
                            V_VT(&rgvarg[i]) = rgvt[i];
                        }
                        else if ((rgvt[i] & VT_BYREF) && (rgvt[i] == V_VT(src_arg)))
                        {
                            V_BYREF(&rgvarg[i]) = V_BYREF(src_arg);
                            V_VT(&rgvarg[i]) = rgvt[i];
                        }
                        else
                        {
                            /* FIXME: this doesn't work for VT_BYREF arguments if
                             * they are not the same type as in the paramdesc */
                            V_VT(&rgvarg[i]) = V_VT(src_arg);
                            hres = VariantChangeType(&rgvarg[i], src_arg, 0, rgvt[i]);
                            V_VT(&rgvarg[i]) = rgvt[i];
                        }
 
                        if (FAILED(hres))
                        {
                            ERR("failed to convert param %d to %s from %s\n", i,
                                debugstr_vt(rgvt[i]), debugstr_variant(src_arg));
                            break;
                        }
                        prgpvarg[i] = &rgvarg[i];
                    }
                    else
                    {
                        prgpvarg[i] = src_arg;
                    }
 
                    if((tdesc->vt == VT_USERDEFINED || (tdesc->vt == VT_PTR && tdesc->u.lptdesc->vt == VT_USERDEFINED))
                       && (V_VT(prgpvarg[i]) == VT_DISPATCH || V_VT(prgpvarg[i]) == VT_UNKNOWN)
                       && V_UNKNOWN(prgpvarg[i])) {
                        IUnknown *userdefined_iface;
                        GUID guid;
 
                        if (tdesc->vt == VT_PTR)
                            tdesc = tdesc->u.lptdesc;
 
                        hres = get_iface_guid((ITypeInfo*)iface, tdesc->u.hreftype, &guid);
                        if(FAILED(hres))
                            break;
 
                        hres = IUnknown_QueryInterface(V_UNKNOWN(prgpvarg[i]), &guid, (void**)&userdefined_iface);
                        if(FAILED(hres)) {
                            ERR("argument does not support %s interface\n", debugstr_guid(&guid));
                            break;
                        }
 
                        IUnknown_Release(V_UNKNOWN(prgpvarg[i]));
                        V_UNKNOWN(prgpvarg[i]) = userdefined_iface;
                    }
                }
                else if (wParamFlags & PARAMFLAG_FOPT)
                {
                    VARIANTARG *arg;
                    arg = prgpvarg[i] = &rgvarg[i];
                    if (wParamFlags & PARAMFLAG_FHASDEFAULT)
                    {
                        hres = VariantCopy(arg, &func_desc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
                        if (FAILED(hres))
                            break;
                    }
                    else
                    {
                        VARIANTARG *missing_arg;
                        /* if the function wants a pointer to a variant then
                         * set that up, otherwise just pass the VT_ERROR in
                         * the argument by value */
                        if (rgvt[i] & VT_BYREF)
                        {
                            missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams) + i;
                            V_VT(arg) = VT_VARIANT | VT_BYREF;
                            V_VARIANTREF(arg) = missing_arg;
                        }
                        else
                            missing_arg = arg;
                        V_VT(missing_arg) = VT_ERROR;
                        V_ERROR(missing_arg) = DISP_E_PARAMNOTFOUND;
                    }
                }
                else
                {
                    hres = DISP_E_BADPARAMCOUNT;
                    break;
                }
            }
            if (FAILED(hres)) goto func_fail; /* FIXME: we don't free changed types here */
 
            /* VT_VOID is a special case for return types, so it is not
             * handled in the general function */
            if (func_desc->elemdescFunc.tdesc.vt == VT_VOID)
                V_VT(&varresult) = VT_EMPTY;
            else
            {
                V_VT(&varresult) = 0;
                hres = typedescvt_to_variantvt((ITypeInfo *)iface, &func_desc->elemdescFunc.tdesc, &V_VT(&varresult));
                if (FAILED(hres)) goto func_fail; /* FIXME: we don't free changed types here */
            }
 
            hres = DispCallFunc(pIUnk, func_desc->oVft & 0xFFFC, func_desc->callconv,
                                V_VT(&varresult), func_desc->cParams, rgvt,
                                prgpvarg, &varresult);
 
            vargs_converted = 0;
 
            for (i = 0; i < func_desc->cParams; i++)
            {
                USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
                VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
 
                if (wParamFlags & PARAMFLAG_FLCID)
                    continue;
                else if (wParamFlags & PARAMFLAG_FRETVAL)
                {
                    TRACE("[retval] value: %s\n", debugstr_variant(prgpvarg[i]));
 
                    if (pVarResult)
                    {
                        VariantInit(pVarResult);
                        /* deref return value */
                        hres = VariantCopyInd(pVarResult, prgpvarg[i]);
                    }
 
                    VARIANT_ClearInd(prgpvarg[i]);
                }
                else if (vargs_converted < pDispParams->cArgs)
                {
                    VARIANTARG *arg = &pDispParams->rgvarg[pDispParams->cArgs - 1 - vargs_converted];
                    if (wParamFlags & PARAMFLAG_FOUT)
                    {
                        if ((rgvt[i] & VT_BYREF) && !(V_VT(arg) & VT_BYREF))
                        {
                            hres = VariantChangeType(arg, &rgvarg[i], 0, V_VT(arg));
 
                            if (FAILED(hres))
                            {
                                ERR("failed to convert param %d to vt %d\n", i,
                                    V_VT(&pDispParams->rgvarg[pDispParams->cArgs - 1 - vargs_converted]));
                                break;
                            }
                        }
                    }
                    else if (V_VT(prgpvarg[i]) == (VT_VARIANT | VT_ARRAY) &&
                             func_desc->cParamsOpt < 0 &&
                             i == func_desc->cParams-1)
                    {
                        SAFEARRAY *a = V_ARRAY(prgpvarg[i]);
                        LONG j, ubound;
                        VARIANT *v;
                        hres = SafeArrayGetUBound(a, 1, &ubound);
                        if (hres != S_OK)
                        {
                            ERR("SafeArrayGetUBound failed with %x\n", hres);
                            break;
                        }
                        hres = SafeArrayAccessData(a, (LPVOID)&v);
                        if (hres != S_OK)
                        {
                            ERR("SafeArrayAccessData failed with %x\n", hres);
                            break;
                        }
                        for (j = 0; j <= ubound; j++)
                            VariantClear(&v[j]);
                        hres = SafeArrayUnaccessData(a);
                        if (hres != S_OK)
                        {
                            ERR("SafeArrayUnaccessData failed with %x\n", hres);
                            break;
                        }
                    }
                    VariantClear(&rgvarg[i]);
                    vargs_converted++;
                }
                else if (wParamFlags & PARAMFLAG_FOPT)
                {
                    if (wParamFlags & PARAMFLAG_FHASDEFAULT)
                        VariantClear(&rgvarg[i]);
                }
 
                VariantClear(&missing_arg[i]);
            }
 
            if ((V_VT(&varresult) == VT_ERROR) && FAILED(V_ERROR(&varresult)))
            {
                WARN("invoked function failed with error 0x%08x\n", V_ERROR(&varresult));
                hres = DISP_E_EXCEPTION;
                if (pExcepInfo)
                {
                    IErrorInfo *pErrorInfo;
                    pExcepInfo->scode = V_ERROR(&varresult);
                    if (GetErrorInfo(0, &pErrorInfo) == S_OK)
                    {
                        IErrorInfo_GetDescription(pErrorInfo, &pExcepInfo->bstrDescription);
                        IErrorInfo_GetHelpFile(pErrorInfo, &pExcepInfo->bstrHelpFile);
                        IErrorInfo_GetSource(pErrorInfo, &pExcepInfo->bstrSource);
                        IErrorInfo_GetHelpContext(pErrorInfo, &pExcepInfo->dwHelpContext);
 
                        IErrorInfo_Release(pErrorInfo);
                    }
                }
            }
            if (V_VT(&varresult) != VT_ERROR)
            {
                TRACE("varresult value: %s\n", debugstr_variant(&varresult));
 
                if (pVarResult)
                {
                    VariantClear(pVarResult);
                    *pVarResult = varresult;
                }
                else
                    VariantClear(&varresult);
            }
 
            if (SUCCEEDED(hres) && pVarResult && (func_desc->cParams == 1) &&
                (func_desc->invkind & INVOKE_PROPERTYGET) &&
                (func_desc->lprgelemdescParam[0].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL) &&
                (pDispParams->cArgs != 0))
            {
                if (V_VT(pVarResult) == VT_DISPATCH)
                {
                    IDispatch *pDispatch = V_DISPATCH(pVarResult);
                    /* Note: not VariantClear; we still need the dispatch
                     * pointer to be valid */
                    VariantInit(pVarResult);
                    hres = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL,
                        GetSystemDefaultLCID(), wFlags,
                        pDispParams, pVarResult, pExcepInfo, pArgErr);
                    IDispatch_Release(pDispatch);
                }
                else
                {
                    VariantClear(pVarResult);
                    hres = DISP_E_NOTACOLLECTION;
                }
            }
 
func_fail:
            heap_free(buffer);
            break;
        }
    case FUNC_DISPATCH:  {
       IDispatch *disp;
 
       hres = IUnknown_QueryInterface((LPUNKNOWN)pIUnk,&IID_IDispatch,(LPVOID*)&disp);
       if (SUCCEEDED(hres)) {
               FIXME("Calling Invoke in IDispatch iface. untested!\n");
               hres = IDispatch_Invoke(
                                     disp,memid,&IID_NULL,LOCALE_USER_DEFAULT,wFlags,pDispParams,
                                     pVarResult,pExcepInfo,pArgErr
                                     );
               if (FAILED(hres))
                   FIXME("IDispatch::Invoke failed with %08x. (Could be not a real error?)\n", hres);
               IDispatch_Release(disp);
           } else
           FIXME("FUNC_DISPATCH used on object without IDispatch iface?\n");
           break;
    }
    default:
            FIXME("Unknown function invocation type %d\n", func_desc->funckind);
            hres = E_FAIL;
            break;
        }
 
        TRACE("-- 0x%08x\n", hres);
        return hres;
 
    } else if(SUCCEEDED(hres = ITypeInfo2_GetVarIndexOfMemId(iface, memid, &var_index))) {
        VARDESC *var_desc;
 
        hres = ITypeInfo2_GetVarDesc(iface, var_index, &var_desc);
        if(FAILED(hres)) return hres;
        
        FIXME("varseek: Found memid, but variable-based invoking not supported\n");
        dump_VARDESC(var_desc);
        ITypeInfo2_ReleaseVarDesc(iface, var_desc);
        return E_NOTIMPL;
    }
 
    /* not found, look for it in inherited interfaces */
    ITypeInfo2_GetTypeKind(iface, &type_kind);
    if(type_kind == TKIND_INTERFACE || type_kind == TKIND_DISPATCH) {
        if(This->impltypes) {
            /* recursive search */
            ITypeInfo *pTInfo;
            hres = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
            if(SUCCEEDED(hres)){
                hres = ITypeInfo_Invoke(pTInfo,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr);
                ITypeInfo_Release(pTInfo);
                return hres;
            }
            WARN("Could not search inherited interface!\n");
        }
    }
    WARN("did not find member id %d, flags 0x%x!\n", memid, wFlags);
    return DISP_E_MEMBERNOTFOUND;
}

ITypeInfo_fnQueryInterface()

static HRESULT WINAPI ITypeInfo_fnQueryInterface ( ITypeInfo2 *  iface, REFIID  riid, VOID **  ppvObject  )

static

Definition at line 5646 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
 
    TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
 
    *ppvObject=NULL;
    if(IsEqualIID(riid, &IID_IUnknown) ||
            IsEqualIID(riid,&IID_ITypeInfo)||
            IsEqualIID(riid,&IID_ITypeInfo2))
        *ppvObject = &This->ITypeInfo2_iface;
    else if(IsEqualIID(riid, &IID_ICreateTypeInfo) ||
             IsEqualIID(riid, &IID_ICreateTypeInfo2))
        *ppvObject = &This->ICreateTypeInfo2_iface;
    else if(IsEqualIID(riid, &IID_ITypeComp))
        *ppvObject = &This->ITypeComp_iface;
 
    if(*ppvObject){
        IUnknown_AddRef((IUnknown*)*ppvObject);
        TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
        return S_OK;
    }
    TRACE("-- Interface: E_NOINTERFACE\n");
    return E_NOINTERFACE;
}

ITypeInfo_fnRelease()

static ULONG WINAPI ITypeInfo_fnRelease ( ITypeInfo2 *  iface )

static

Definition at line 5741 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p)->(%u)\n",This, ref);
 
    if (!ref)
    {
        BOOL not_attached_to_typelib = This->not_attached_to_typelib;
        ITypeLib2_Release(&This->pTypeLib->ITypeLib2_iface);
        if (not_attached_to_typelib)
            heap_free(This);
        /* otherwise This will be freed when typelib is freed */
    }
 
    return ref;
}

ITypeInfo_fnReleaseFuncDesc()

static void WINAPI ITypeInfo_fnReleaseFuncDesc ( ITypeInfo2 *  iface, FUNCDESC *  pFuncDesc  )

static

Definition at line 8316 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    SHORT i;
 
    TRACE("(%p)->(%p)\n", This, pFuncDesc);
 
    for (i = 0; i < pFuncDesc->cParams; i++)
        TLB_FreeElemDesc(&pFuncDesc->lprgelemdescParam[i]);
    TLB_FreeElemDesc(&pFuncDesc->elemdescFunc);
 
    SysFreeString((BSTR)pFuncDesc);
}

ITypeInfo_fnReleaseTypeAttr()

static void WINAPI ITypeInfo_fnReleaseTypeAttr ( ITypeInfo2 *  iface, TYPEATTR *  pTypeAttr  )

static

Definition at line 8304 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    TRACE("(%p)->(%p)\n", This, pTypeAttr);
    heap_free(pTypeAttr);
}

ITypeInfo_fnReleaseVarDesc()

static void WINAPI ITypeInfo_fnReleaseVarDesc ( ITypeInfo2 *  iface, VARDESC *  pVarDesc  )

static

Definition at line 8336 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo2(iface);
    TRACE("(%p)->(%p)\n", This, pVarDesc);
 
    TLB_FreeVarDesc(pVarDesc);
}

ITypeInfoImpl_Constructor()

static ITypeInfoImpl * ITypeInfoImpl_Constructor ( void  )

static

Definition at line 5623 of file typelib.c.

{
    ITypeInfoImpl *pTypeInfoImpl;
 
    pTypeInfoImpl = heap_alloc_zero(sizeof(ITypeInfoImpl));
    if (pTypeInfoImpl)
    {
      pTypeInfoImpl->ITypeInfo2_iface.lpVtbl = &tinfvt;
      pTypeInfoImpl->ITypeComp_iface.lpVtbl = &tcompvt;
      pTypeInfoImpl->ICreateTypeInfo2_iface.lpVtbl = &CreateTypeInfo2Vtbl;
      pTypeInfoImpl->ref = 0;
      pTypeInfoImpl->hreftype = -1;
      pTypeInfoImpl->typeattr.memidConstructor = MEMBERID_NIL;
      pTypeInfoImpl->typeattr.memidDestructor = MEMBERID_NIL;
      pTypeInfoImpl->pcustdata_list = &pTypeInfoImpl->custdata_list;
      list_init(pTypeInfoImpl->pcustdata_list);
    }
    TRACE("(%p)\n", pTypeInfoImpl);
    return pTypeInfoImpl;
}

Referenced by CreateDispTypeInfo(), ICreateTypeLib2_fnCreateTypeInfo(), ITypeInfo_fnGetRefTypeInfo(), ITypeLib2_Constructor_SLTG(), and MSFT_DoTypeInfo().

ITypeInfoImpl_Destroy()

static void ITypeInfoImpl_Destroy ( ITypeInfoImpl *  This )

static

Definition at line 5690 of file typelib.c.

{
    UINT i;
 
    TRACE("destroying ITypeInfo(%p)\n",This);
 
    for (i = 0; i < This->typeattr.cFuncs; ++i)
    {
        int j;
        TLBFuncDesc *pFInfo = &This->funcdescs[i];
        for(j = 0; j < pFInfo->funcdesc.cParams; j++)
        {
            ELEMDESC *elemdesc = &pFInfo->funcdesc.lprgelemdescParam[j];
            if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
                VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
            TLB_FreeCustData(&pFInfo->pParamDesc[j].custdata_list);
        }
        heap_free(pFInfo->funcdesc.lprgelemdescParam);
        heap_free(pFInfo->pParamDesc);
        TLB_FreeCustData(&pFInfo->custdata_list);
    }
    heap_free(This->funcdescs);
 
    for(i = 0; i < This->typeattr.cVars; ++i)
    {
        TLBVarDesc *pVInfo = &This->vardescs[i];
        if (pVInfo->vardesc_create) {
            TLB_FreeVarDesc(pVInfo->vardesc_create);
        } else if (pVInfo->vardesc.varkind == VAR_CONST) {
            VariantClear(pVInfo->vardesc.u.lpvarValue);
            heap_free(pVInfo->vardesc.u.lpvarValue);
        }
        TLB_FreeCustData(&pVInfo->custdata_list);
    }
    heap_free(This->vardescs);
 
    if(This->impltypes){
        for (i = 0; i < This->typeattr.cImplTypes; ++i){
            TLBImplType *pImpl = &This->impltypes[i];
            TLB_FreeCustData(&pImpl->custdata_list);
        }
        heap_free(This->impltypes);
    }
 
    TLB_FreeCustData(&This->custdata_list);
 
    heap_free(This);
}

Referenced by ITypeLib2_fnRelease().

ITypeInfoImpl_ElemDescAddHrefOffset()

static void ITypeInfoImpl_ElemDescAddHrefOffset ( LPELEMDESC  pElemDesc, UINT  hrefoffset  )

inlinestatic

Definition at line 6032 of file typelib.c.

{
    TYPEDESC *pTypeDesc = &pElemDesc->tdesc;
    while (TRUE)
    {
        switch (pTypeDesc->vt)
        {
        case VT_USERDEFINED:
            pTypeDesc->u.hreftype += hrefoffset;
            return;
        case VT_PTR:
        case VT_SAFEARRAY:
            pTypeDesc = pTypeDesc->u.lptdesc;
            break;
        case VT_CARRAY:
            pTypeDesc = &pTypeDesc->u.lpadesc->tdescElem;
            break;
        default:
            return;
        }
    }
}

Referenced by ITypeInfoImpl_FuncDescAddHrefOffset().

ITypeInfoImpl_FuncDescAddHrefOffset()

static void ITypeInfoImpl_FuncDescAddHrefOffset ( LPFUNCDESC  pFuncDesc, UINT  hrefoffset  )

inlinestatic

Definition at line 6055 of file typelib.c.

{
    SHORT i;
    for (i = 0; i < pFuncDesc->cParams; i++)
        ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc->lprgelemdescParam[i], hrefoffset);
    ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc->elemdescFunc, hrefoffset);
}

Referenced by ITypeInfo_fnGetFuncDesc().

ITypeInfoImpl_GetDispatchRefTypeInfo()

static HRESULT ITypeInfoImpl_GetDispatchRefTypeInfo ( ITypeInfo *  iface, HREFTYPE *  hRefType, ITypeInfo **  ppTInfo  )

static

Definition at line 7935 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo(iface);
    HRESULT hr;
 
    TRACE("%p, 0x%x\n", iface, *hRefType);
 
    if (This->impltypes && (*hRefType & DISPATCH_HREF_MASK))
    {
        ITypeInfo *pSubTypeInfo;
 
        hr = ITypeInfo_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pSubTypeInfo);
        if (FAILED(hr))
            return hr;
 
        hr = ITypeInfoImpl_GetDispatchRefTypeInfo(pSubTypeInfo,
                                                  hRefType, ppTInfo);
        ITypeInfo_Release(pSubTypeInfo);
        if (SUCCEEDED(hr))
            return hr;
    }
    *hRefType -= DISPATCH_HREF_OFFSET;
 
    if (!(*hRefType & DISPATCH_HREF_MASK))
        return ITypeInfo_GetRefTypeInfo(iface, *hRefType, ppTInfo);
    else
        return E_FAIL;
}

Referenced by ITypeInfo_fnGetRefTypeInfo(), and ITypeInfoImpl_GetDispatchRefTypeInfo().

ITypeInfoImpl_GetInternalDispatchFuncDesc()

static HRESULT ITypeInfoImpl_GetInternalDispatchFuncDesc ( ITypeInfo *  iface, UINT  index, const FUNCDESC **  ppFuncDesc, UINT *  funcs, UINT *  hrefoffset  )

static

Definition at line 5989 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo(iface);
    HRESULT hr;
    UINT implemented_funcs = 0;
 
    if (funcs)
        *funcs = 0;
    else
        *hrefoffset = DISPATCH_HREF_OFFSET;
 
    if(This->impltypes)
    {
        ITypeInfo *pSubTypeInfo;
        UINT sub_funcs;
 
        hr = ITypeInfo_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pSubTypeInfo);
        if (FAILED(hr))
            return hr;
 
        hr = ITypeInfoImpl_GetInternalDispatchFuncDesc(pSubTypeInfo,
                                                       index,
                                                       ppFuncDesc,
                                                       &sub_funcs, hrefoffset);
        implemented_funcs += sub_funcs;
        ITypeInfo_Release(pSubTypeInfo);
        if (SUCCEEDED(hr))
            return hr;
        *hrefoffset += DISPATCH_HREF_OFFSET;
    }
 
    if (funcs)
        *funcs = implemented_funcs + This->typeattr.cFuncs;
    else
        *hrefoffset = 0;
    
    if (index < implemented_funcs)
        return E_INVALIDARG;
    return ITypeInfoImpl_GetInternalFuncDesc(iface, index - implemented_funcs,
                                             ppFuncDesc);
}

Referenced by ITypeInfo_fnGetFuncDesc(), and ITypeInfoImpl_GetInternalDispatchFuncDesc().

ITypeInfoImpl_GetInternalFuncDesc()

HRESULT ITypeInfoImpl_GetInternalFuncDesc	(	ITypeInfo *	iface,
		UINT	index,
		const FUNCDESC **	ppFuncDesc
	)

Definition at line 5976 of file typelib.c.

{
    ITypeInfoImpl *This = impl_from_ITypeInfo(iface);
 
    if (index >= This->typeattr.cFuncs)
        return TYPE_E_ELEMENTNOTFOUND;
 
    *ppFuncDesc = &This->funcdescs[index].funcdesc;
    return S_OK;
}

Referenced by ITypeInfo_fnGetFuncDesc(), and ITypeInfoImpl_GetInternalDispatchFuncDesc().

ITypeLib2_Constructor_MSFT()

static ITypeLib2 * ITypeLib2_Constructor_MSFT ( LPVOID  pLib, DWORD  dwTLBLength  )

static

Definition at line 3457 of file typelib.c.

{
    TLBContext cx;
    LONG lPSegDir;
    MSFT_Header tlbHeader;
    MSFT_SegDir tlbSegDir;
    ITypeLibImpl * pTypeLibImpl;
    int i;
 
    TRACE("%p, TLB length = %d\n", pLib, dwTLBLength);
 
    pTypeLibImpl = TypeLibImpl_Constructor();
    if (!pTypeLibImpl) return NULL;
 
    /* get pointer to beginning of typelib data */
    cx.pos = 0;
    cx.oStart=0;
    cx.mapping = pLib;
    cx.pLibInfo = pTypeLibImpl;
    cx.length = dwTLBLength;
 
    /* read header */
    MSFT_ReadLEDWords(&tlbHeader, sizeof(tlbHeader), &cx, 0);
    TRACE_(typelib)("header:\n");
    TRACE_(typelib)("\tmagic1=0x%08x ,magic2=0x%08x\n",tlbHeader.magic1,tlbHeader.magic2 );
    if (tlbHeader.magic1 != MSFT_SIGNATURE) {
    FIXME("Header type magic 0x%08x not supported.\n",tlbHeader.magic1);
    return NULL;
    }
    TRACE_(typelib)("\tdispatchpos = 0x%x\n", tlbHeader.dispatchpos);
 
    /* there is a small amount of information here until the next important
     * part:
     * the segment directory . Try to calculate the amount of data */
    lPSegDir = sizeof(tlbHeader) + (tlbHeader.nrtypeinfos)*4 + ((tlbHeader.varflags & HELPDLLFLAG)? 4 :0);
 
    /* now read the segment directory */
    TRACE("read segment directory (at %d)\n",lPSegDir);
    MSFT_ReadLEDWords(&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);
    cx.pTblDir = &tlbSegDir;
 
    /* just check two entries */
    if ( tlbSegDir.pTypeInfoTab.res0c != 0x0F || tlbSegDir.pImpInfo.res0c != 0x0F)
    {
        ERR("cannot find the table directory, ptr=0x%x\n",lPSegDir);
    heap_free(pTypeLibImpl);
    return NULL;
    }
 
    MSFT_ReadAllNames(&cx);
    MSFT_ReadAllStrings(&cx);
    MSFT_ReadAllGuids(&cx);
 
    /* now fill our internal data */
    /* TLIBATTR fields */
    pTypeLibImpl->guid = MSFT_ReadGuid(tlbHeader.posguid, &cx);
 
    pTypeLibImpl->syskind = tlbHeader.varflags & 0x0f; /* check the mask */
    pTypeLibImpl->ptr_size = get_ptr_size(pTypeLibImpl->syskind);
    pTypeLibImpl->ver_major = LOWORD(tlbHeader.version);
    pTypeLibImpl->ver_minor = HIWORD(tlbHeader.version);
    pTypeLibImpl->libflags = ((WORD) tlbHeader.flags & 0xffff) /* check mask */ | LIBFLAG_FHASDISKIMAGE;
 
    pTypeLibImpl->set_lcid = tlbHeader.lcid2;
    pTypeLibImpl->lcid = tlbHeader.lcid;
 
    /* name, eventually add to a hash table */
    pTypeLibImpl->Name = MSFT_ReadName(&cx, tlbHeader.NameOffset);
 
    /* help info */
    pTypeLibImpl->DocString = MSFT_ReadString(&cx, tlbHeader.helpstring);
    pTypeLibImpl->HelpFile = MSFT_ReadString(&cx, tlbHeader.helpfile);
 
    if( tlbHeader.varflags & HELPDLLFLAG)
    {
            int offset;
            MSFT_ReadLEDWords(&offset, sizeof(offset), &cx, sizeof(tlbHeader));
            pTypeLibImpl->HelpStringDll = MSFT_ReadString(&cx, offset);
    }
 
    pTypeLibImpl->dwHelpContext = tlbHeader.helpstringcontext;
 
    /* custom data */
    if(tlbHeader.CustomDataOffset >= 0)
    {
        MSFT_CustData(&cx, tlbHeader.CustomDataOffset, &pTypeLibImpl->custdata_list);
    }
 
    /* fill in type descriptions */
    if(tlbSegDir.pTypdescTab.length > 0)
    {
        int i, j, cTD = tlbSegDir.pTypdescTab.length / (2*sizeof(INT));
        INT16 td[4];
        pTypeLibImpl->ctTypeDesc = cTD;
        pTypeLibImpl->pTypeDesc = heap_alloc_zero( cTD * sizeof(TYPEDESC));
        MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
        for(i=0; i<cTD; )
    {
            /* FIXME: add several sanity checks here */
            pTypeLibImpl->pTypeDesc[i].vt = td[0] & VT_TYPEMASK;
            if(td[0] == VT_PTR || td[0] == VT_SAFEARRAY)
        {
            /* FIXME: check safearray */
                if(td[3] < 0)
                    pTypeLibImpl->pTypeDesc[i].u.lptdesc = &std_typedesc[td[2]];
                else
                    pTypeLibImpl->pTypeDesc[i].u.lptdesc = &pTypeLibImpl->pTypeDesc[td[2]/8];
            }
        else if(td[0] == VT_CARRAY)
            {
            /* array descr table here */
            pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)(INT_PTR)td[2];  /* temp store offset in*/
            }
            else if(td[0] == VT_USERDEFINED)
        {
                pTypeLibImpl->pTypeDesc[i].u.hreftype = MAKELONG(td[2],td[3]);
            }
        if(++i<cTD) MSFT_ReadLEWords(td, sizeof(td), &cx, DO_NOT_SEEK);
        }
 
        /* second time around to fill the array subscript info */
        for(i=0;i<cTD;i++)
    {
            if(pTypeLibImpl->pTypeDesc[i].vt != VT_CARRAY) continue;
            if(tlbSegDir.pArrayDescriptions.offset>0)
        {
                MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (INT_PTR)pTypeLibImpl->pTypeDesc[i].u.lpadesc);
                pTypeLibImpl->pTypeDesc[i].u.lpadesc = heap_alloc_zero(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
 
                if(td[1]<0)
                    pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem.vt = td[0] & VT_TYPEMASK;
                else
                    pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem = cx.pLibInfo->pTypeDesc[td[0]/(2*sizeof(INT))];
 
                pTypeLibImpl->pTypeDesc[i].u.lpadesc->cDims = td[2];
 
                for(j = 0; j<td[2]; j++)
        {
                    MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements,
                                      sizeof(INT), &cx, DO_NOT_SEEK);
                    MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound,
                                      sizeof(INT), &cx, DO_NOT_SEEK);
                }
            }
        else
        {
                pTypeLibImpl->pTypeDesc[i].u.lpadesc = NULL;
                ERR("didn't find array description data\n");
            }
        }
    }
 
    /* imported type libs */
    if(tlbSegDir.pImpFiles.offset>0)
    {
        TLBImpLib *pImpLib;
        int oGuid, offset = tlbSegDir.pImpFiles.offset;
        UINT16 size;
 
        while(offset < tlbSegDir.pImpFiles.offset +tlbSegDir.pImpFiles.length)
    {
            char *name;
 
            pImpLib = heap_alloc_zero(sizeof(TLBImpLib));
            pImpLib->offset = offset - tlbSegDir.pImpFiles.offset;
            MSFT_ReadLEDWords(&oGuid, sizeof(INT), &cx, offset);
 
            MSFT_ReadLEDWords(&pImpLib->lcid,         sizeof(LCID),   &cx, DO_NOT_SEEK);
            MSFT_ReadLEWords(&pImpLib->wVersionMajor, sizeof(WORD),   &cx, DO_NOT_SEEK);
            MSFT_ReadLEWords(&pImpLib->wVersionMinor, sizeof(WORD),   &cx, DO_NOT_SEEK);
            MSFT_ReadLEWords(& size,                      sizeof(UINT16), &cx, DO_NOT_SEEK);
 
            size >>= 2;
            name = heap_alloc_zero(size+1);
            MSFT_Read(name, size, &cx, DO_NOT_SEEK);
            pImpLib->name = TLB_MultiByteToBSTR(name);
            heap_free(name);
 
            pImpLib->guid = MSFT_ReadGuid(oGuid, &cx);
            offset = (offset + sizeof(INT) + sizeof(DWORD) + sizeof(LCID) + sizeof(UINT16) + size + 3) & ~3;
 
            list_add_tail(&pTypeLibImpl->implib_list, &pImpLib->entry);
        }
    }
 
    MSFT_ReadAllRefs(&cx);
 
    pTypeLibImpl->dispatch_href = tlbHeader.dispatchpos;
 
    /* type infos */
    if(tlbHeader.nrtypeinfos >= 0 )
    {
        ITypeInfoImpl **ppTI;
 
        ppTI = pTypeLibImpl->typeinfos = heap_alloc_zero(sizeof(ITypeInfoImpl*) * tlbHeader.nrtypeinfos);
 
        for(i = 0; i < tlbHeader.nrtypeinfos; i++)
        {
            *ppTI = MSFT_DoTypeInfo(&cx, i, pTypeLibImpl);
 
            ++ppTI;
            (pTypeLibImpl->TypeInfoCount)++;
        }
    }
 
#ifdef _WIN64
    if(pTypeLibImpl->syskind == SYS_WIN32){
        for(i = 0; i < pTypeLibImpl->TypeInfoCount; ++i)
            TLB_fix_32on64_typeinfo(pTypeLibImpl->typeinfos[i]);
    }
#endif
 
    TRACE("(%p)\n", pTypeLibImpl);
    return &pTypeLibImpl->ITypeLib2_iface;
}

Referenced by TLB_ReadTypeLib().

ITypeLib2_Constructor_SLTG()

static ITypeLib2 * ITypeLib2_Constructor_SLTG ( LPVOID  pLib, DWORD  dwTLBLength  )

static

Definition at line 4487 of file typelib.c.

{
    ITypeLibImpl *pTypeLibImpl;
    SLTG_Header *pHeader;
    SLTG_BlkEntry *pBlkEntry;
    SLTG_Magic *pMagic;
    SLTG_Index *pIndex;
    SLTG_Pad9 *pPad9;
    LPVOID pBlk, pFirstBlk;
    SLTG_LibBlk *pLibBlk;
    SLTG_InternalOtherTypeInfo *pOtherTypeInfoBlks;
    char *pNameTable, *ptr;
    const BYTE *hlp_strings;
    int i;
    DWORD len, order;
    ITypeInfoImpl **ppTypeInfoImpl;
 
    TRACE_(typelib)("%p, TLB length = %d\n", pLib, dwTLBLength);
 
 
    pTypeLibImpl = TypeLibImpl_Constructor();
    if (!pTypeLibImpl) return NULL;
 
    pHeader = pLib;
 
    TRACE_(typelib)("header:\n");
    TRACE_(typelib)("\tmagic=0x%08x, file blocks = %d\n", pHeader->SLTG_magic,
      pHeader->nrOfFileBlks );
    if (pHeader->SLTG_magic != SLTG_SIGNATURE) {
    FIXME_(typelib)("Header type magic 0x%08x not supported.\n",
          pHeader->SLTG_magic);
    return NULL;
    }
 
    /* There are pHeader->nrOfFileBlks - 2 TypeInfo records in this typelib */
    pTypeLibImpl->TypeInfoCount = pHeader->nrOfFileBlks - 2;
 
    /* This points to pHeader->nrOfFileBlks - 1 of SLTG_BlkEntry */
    pBlkEntry = (SLTG_BlkEntry*)(pHeader + 1);
 
    /* Next we have a magic block */
    pMagic = (SLTG_Magic*)(pBlkEntry + pHeader->nrOfFileBlks - 1);
 
    /* Let's see if we're still in sync */
    if(memcmp(pMagic->CompObj_magic, SLTG_COMPOBJ_MAGIC,
          sizeof(SLTG_COMPOBJ_MAGIC))) {
        FIXME_(typelib)("CompObj magic = %s\n", pMagic->CompObj_magic);
    return NULL;
    }
    if(memcmp(pMagic->dir_magic, SLTG_DIR_MAGIC,
          sizeof(SLTG_DIR_MAGIC))) {
        FIXME_(typelib)("dir magic = %s\n", pMagic->dir_magic);
    return NULL;
    }
 
    pIndex = (SLTG_Index*)(pMagic+1);
 
    pPad9 = (SLTG_Pad9*)(pIndex + pTypeLibImpl->TypeInfoCount);
 
    pFirstBlk = pPad9 + 1;
 
    /* We'll set up a ptr to the main library block, which is the last one. */
 
    for(pBlk = pFirstBlk, order = pHeader->first_blk - 1;
      pBlkEntry[order].next != 0;
      order = pBlkEntry[order].next - 1) {
       pBlk = (char*)pBlk + pBlkEntry[order].len;
    }
    pLibBlk = pBlk;
 
    len = SLTG_ReadLibBlk(pLibBlk, pTypeLibImpl);
 
    /* Now there are 0x40 bytes of 0xffff with the numbers 0 to TypeInfoCount
       interspersed */
 
    len += 0x40;
 
    /* And now TypeInfoCount of SLTG_OtherTypeInfo */
    pTypeLibImpl->TypeInfoCount = *(WORD *)((char *)pLibBlk + len);
    len += sizeof(WORD);
 
    pOtherTypeInfoBlks = heap_alloc_zero(sizeof(*pOtherTypeInfoBlks) * pTypeLibImpl->TypeInfoCount);
 
    ptr = (char*)pLibBlk + len;
 
    for(i = 0; i < pTypeLibImpl->TypeInfoCount; i++) {
    WORD w, extra;
    len = 0;
 
    w = *(WORD*)ptr;
    if(w != 0xffff) {
        len += w;
        pOtherTypeInfoBlks[i].index_name = heap_alloc(w+1);
        memcpy(pOtherTypeInfoBlks[i].index_name, ptr + 2, w);
        pOtherTypeInfoBlks[i].index_name[w] = '\0';
    }
    w = *(WORD*)(ptr + 2 + len);
    if(w != 0xffff) {
        TRACE_(typelib)("\twith %s\n", debugstr_an(ptr + 4 + len, w));
        pOtherTypeInfoBlks[i].other_name = heap_alloc(w+1);
        memcpy(pOtherTypeInfoBlks[i].other_name, ptr + 4 + len, w);
        pOtherTypeInfoBlks[i].other_name[w] = '\0';
        len += w;
    }
    pOtherTypeInfoBlks[i].res1a = *(WORD*)(ptr + 4 + len);
    pOtherTypeInfoBlks[i].name_offs = *(WORD*)(ptr + 6 + len);
    extra = pOtherTypeInfoBlks[i].hlpstr_len = *(WORD*)(ptr + 8 + len);
    if(extra) {
        pOtherTypeInfoBlks[i].extra = heap_alloc(extra);
        memcpy(pOtherTypeInfoBlks[i].extra, ptr + 10 + len, extra);
        len += extra;
    }
    pOtherTypeInfoBlks[i].res20 = *(WORD*)(ptr + 10 + len);
    pOtherTypeInfoBlks[i].helpcontext = *(DWORD*)(ptr + 12 + len);
    pOtherTypeInfoBlks[i].res26 = *(WORD*)(ptr + 16 + len);
    memcpy(&pOtherTypeInfoBlks[i].uuid, ptr + 18 + len, sizeof(GUID));
    pOtherTypeInfoBlks[i].typekind = *(WORD*)(ptr + 18 + sizeof(GUID) + len);
    len += sizeof(SLTG_OtherTypeInfo);
    ptr += len;
    }
 
    /* Get the next DWORD */
    len = *(DWORD*)ptr;
 
    hlp_strings = (const BYTE *)ptr + sizeof(DWORD);
    TRACE("max help string length %#x, help strings length %#x\n",
        *(WORD *)hlp_strings, *(DWORD *)(hlp_strings + 2));
 
    /* Now add this to pLibBLk look at what we're pointing at and
       possibly add 0x20, then add 0x216, sprinkle a bit a magic
       dust and we should be pointing at the beginning of the name
       table */
 
    pNameTable = (char*)pLibBlk + len;
 
   switch(*(WORD*)pNameTable) {
   case 0xffff:
       break;
   case 0x0200:
       pNameTable += 0x20;
       break;
   default:
       FIXME_(typelib)("pNameTable jump = %x\n", *(WORD*)pNameTable);
       break;
   }
 
    pNameTable += 0x216;
 
    pNameTable += 2;
 
    TRACE_(typelib)("Library name is %s\n", pNameTable + pLibBlk->name);
 
    pTypeLibImpl->Name = SLTG_ReadName(pNameTable, pLibBlk->name, pTypeLibImpl);
 
 
    /* Hopefully we now have enough ptrs set up to actually read in
       some TypeInfos.  It's not clear which order to do them in, so
       I'll just follow the links along the BlkEntry chain and read
       them in the order in which they are in the file */
 
    pTypeLibImpl->typeinfos = heap_alloc_zero(pTypeLibImpl->TypeInfoCount * sizeof(ITypeInfoImpl*));
    ppTypeInfoImpl = pTypeLibImpl->typeinfos;
 
    for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
    pBlkEntry[order].next != 0;
    order = pBlkEntry[order].next - 1, i++) {
 
      SLTG_TypeInfoHeader *pTIHeader;
      SLTG_TypeInfoTail *pTITail;
      SLTG_MemberHeader *pMemHeader;
 
      if(strcmp(pBlkEntry[order].index_string + (char*)pMagic, pOtherTypeInfoBlks[i].index_name)) {
        FIXME_(typelib)("Index strings don't match\n");
        heap_free(pOtherTypeInfoBlks);
        return NULL;
      }
 
      pTIHeader = pBlk;
      if(pTIHeader->magic != SLTG_TIHEADER_MAGIC) {
    FIXME_(typelib)("TypeInfoHeader magic = %04x\n", pTIHeader->magic);
       heap_free(pOtherTypeInfoBlks);
    return NULL;
      }
      TRACE_(typelib)("pTIHeader->res06 = %x, pTIHeader->res0e = %x, "
        "pTIHeader->res16 = %x, pTIHeader->res1e = %x\n",
        pTIHeader->res06, pTIHeader->res0e, pTIHeader->res16, pTIHeader->res1e);
 
      *ppTypeInfoImpl = ITypeInfoImpl_Constructor();
      (*ppTypeInfoImpl)->pTypeLib = pTypeLibImpl;
      (*ppTypeInfoImpl)->index = i;
      (*ppTypeInfoImpl)->Name = SLTG_ReadName(pNameTable, pOtherTypeInfoBlks[i].name_offs, pTypeLibImpl);
      (*ppTypeInfoImpl)->dwHelpContext = pOtherTypeInfoBlks[i].helpcontext;
      (*ppTypeInfoImpl)->DocString = decode_string(hlp_strings, pOtherTypeInfoBlks[i].extra, pOtherTypeInfoBlks[i].hlpstr_len, pTypeLibImpl);
      (*ppTypeInfoImpl)->guid = TLB_append_guid(&pTypeLibImpl->guid_list, &pOtherTypeInfoBlks[i].uuid, 2);
      (*ppTypeInfoImpl)->typeattr.typekind = pTIHeader->typekind;
      (*ppTypeInfoImpl)->typeattr.wMajorVerNum = pTIHeader->major_version;
      (*ppTypeInfoImpl)->typeattr.wMinorVerNum = pTIHeader->minor_version;
      (*ppTypeInfoImpl)->typeattr.wTypeFlags =
    (pTIHeader->typeflags1 >> 3) | (pTIHeader->typeflags2 << 5);
 
      if((*ppTypeInfoImpl)->typeattr.wTypeFlags & TYPEFLAG_FDUAL)
    (*ppTypeInfoImpl)->typeattr.typekind = TKIND_DISPATCH;
 
      if((pTIHeader->typeflags1 & 7) != 2)
    FIXME_(typelib)("typeflags1 = %02x\n", pTIHeader->typeflags1);
      if(pTIHeader->typeflags3 != 2)
    FIXME_(typelib)("typeflags3 = %02x\n", pTIHeader->typeflags3);
 
      TRACE_(typelib)("TypeInfo %s of kind %s guid %s typeflags %04x\n",
        debugstr_w(TLB_get_bstr((*ppTypeInfoImpl)->Name)),
        typekind_desc[pTIHeader->typekind],
        debugstr_guid(TLB_get_guidref((*ppTypeInfoImpl)->guid)),
        (*ppTypeInfoImpl)->typeattr.wTypeFlags);
 
      pMemHeader = (SLTG_MemberHeader*)((char *)pBlk + pTIHeader->elem_table);
 
      pTITail = (SLTG_TypeInfoTail*)((char *)(pMemHeader + 1) + pMemHeader->cbExtra);
 
      (*ppTypeInfoImpl)->typeattr.cbAlignment = pTITail->cbAlignment;
      (*ppTypeInfoImpl)->typeattr.cbSizeInstance = pTITail->cbSizeInstance;
      (*ppTypeInfoImpl)->typeattr.cbSizeVft = pTITail->cbSizeVft;
 
      switch(pTIHeader->typekind) {
      case TKIND_ENUM:
    SLTG_ProcessEnum((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
                         pTIHeader, pTITail, hlp_strings);
    break;
 
      case TKIND_RECORD:
    SLTG_ProcessRecord((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
                           pTIHeader, pTITail, hlp_strings);
    break;
 
      case TKIND_INTERFACE:
    SLTG_ProcessInterface((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
                              pTIHeader, pTITail, hlp_strings);
    break;
 
      case TKIND_COCLASS:
    SLTG_ProcessCoClass((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
                            pTIHeader, pTITail);
    break;
 
      case TKIND_ALIAS:
    SLTG_ProcessAlias((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
                          pTIHeader, pTITail);
    break;
 
      case TKIND_DISPATCH:
    SLTG_ProcessDispatch((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
                             pTIHeader, pTITail, hlp_strings);
    break;
 
      case TKIND_MODULE:
    SLTG_ProcessModule((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
                           pTIHeader, pTITail, hlp_strings);
    break;
 
      default:
    FIXME("Not processing typekind %d\n", pTIHeader->typekind);
    break;
 
      }
 
      /* could get cFuncs, cVars and cImplTypes from here
               but we've already set those */
#define X(x) TRACE_(typelib)("tt "#x": %x\n",pTITail->res##x);
      X(06);
      X(16);
      X(18);
      X(1a);
      X(1e);
      X(24);
      X(26);
      X(2a);
      X(2c);
      X(2e);
      X(30);
      X(32);
      X(34);
#undef X
      ++ppTypeInfoImpl;
      pBlk = (char*)pBlk + pBlkEntry[order].len;
    }
 
    if(i != pTypeLibImpl->TypeInfoCount) {
      FIXME("Somehow processed %d TypeInfos\n", i);
      heap_free(pOtherTypeInfoBlks);
      return NULL;
    }
 
    heap_free(pOtherTypeInfoBlks);
    return &pTypeLibImpl->ITypeLib2_iface;
}

Referenced by TLB_ReadTypeLib().

ITypeLib2_fnAddRef()

static ULONG WINAPI ITypeLib2_fnAddRef ( ITypeLib2 *  iface )

static

Definition at line 4810 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) ref=%u\n", This, ref);
 
    return ref;
}

ITypeLib2_fnFindName()

static HRESULT WINAPI ITypeLib2_fnFindName ( ITypeLib2 *  iface, LPOLESTR  name, ULONG  hash, ITypeInfo **  ppTInfo, MEMBERID *  memid, UINT16 *  found  )

static

Definition at line 5178 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
    int tic;
    UINT count = 0;
    UINT len;
 
    TRACE("(%p)->(%s %u %p %p %p)\n", This, debugstr_w(name), hash, ppTInfo, memid, found);
 
    if ((!name && hash == 0) || !ppTInfo || !memid || !found)
        return E_INVALIDARG;
 
    len = (lstrlenW(name) + 1)*sizeof(WCHAR);
    for(tic = 0; count < *found && tic < This->TypeInfoCount; ++tic) {
        ITypeInfoImpl *pTInfo = This->typeinfos[tic];
        TLBVarDesc *var;
        UINT fdc;
 
        if(!TLB_str_memcmp(name, pTInfo->Name, len)) {
            memid[count] = MEMBERID_NIL;
            goto ITypeLib2_fnFindName_exit;
        }
 
        for(fdc = 0; fdc < pTInfo->typeattr.cFuncs; ++fdc) {
            TLBFuncDesc *func = &pTInfo->funcdescs[fdc];
 
            if(!TLB_str_memcmp(name, func->Name, len)) {
                memid[count] = func->funcdesc.memid;
                goto ITypeLib2_fnFindName_exit;
            }
        }
 
        var = TLB_get_vardesc_by_name(pTInfo->vardescs, pTInfo->typeattr.cVars, name);
        if (var) {
            memid[count] = var->vardesc.memid;
            goto ITypeLib2_fnFindName_exit;
        }
 
        continue;
ITypeLib2_fnFindName_exit:
        ITypeInfo2_AddRef(&pTInfo->ITypeInfo2_iface);
        ppTInfo[count] = (ITypeInfo *)&pTInfo->ITypeInfo2_iface;
        count++;
    }
    TRACE("found %d typeinfos\n", count);
 
    *found = count;
 
    return S_OK;
}

ITypeLib2_fnGetAllCustData()

static HRESULT WINAPI ITypeLib2_fnGetAllCustData ( ITypeLib2 *  iface, CUSTDATA *  pCustData  )

static

Definition at line 5390 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
    TRACE("(%p)->(%p)\n", This, pCustData);
    return TLB_copy_all_custdata(&This->custdata_list, pCustData);
}

ITypeLib2_fnGetCustData()

static HRESULT WINAPI ITypeLib2_fnGetCustData ( ITypeLib2 *  iface, REFGUID  guid, VARIANT *  pVarVal  )

static

Definition at line 5253 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
    TLBCustData *pCData;
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(guid), pVarVal);
 
    pCData = TLB_get_custdata_by_guid(&This->custdata_list, guid);
    if(!pCData)
        return TYPE_E_ELEMENTNOTFOUND;
 
    VariantInit(pVarVal);
    VariantCopy(pVarVal, &pCData->data);
 
    return S_OK;
}

ITypeLib2_fnGetDocumentation()

static HRESULT WINAPI ITypeLib2_fnGetDocumentation ( ITypeLib2 *  iface, INT  index, BSTR *  pBstrName, BSTR *  pBstrDocString, DWORD *  pdwHelpContext, BSTR *  pBstrHelpFile  )

static

Definition at line 5043 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
    HRESULT result = E_INVALIDARG;
    ITypeInfo *pTInfo;
 
    TRACE("(%p) index %d Name(%p) DocString(%p) HelpContext(%p) HelpFile(%p)\n",
        This, index,
        pBstrName, pBstrDocString,
        pdwHelpContext, pBstrHelpFile);
 
    if(index<0)
    {
        /* documentation for the typelib */
        if(pBstrName)
        {
            if (This->Name)
            {
                if(!(*pBstrName = SysAllocString(TLB_get_bstr(This->Name))))
                    goto memerr1;
            }
            else
                *pBstrName = NULL;
        }
        if(pBstrDocString)
        {
            if (This->DocString)
            {
                if(!(*pBstrDocString = SysAllocString(TLB_get_bstr(This->DocString))))
                    goto memerr2;
            }
            else
                *pBstrDocString = NULL;
        }
        if(pdwHelpContext)
        {
            *pdwHelpContext = This->dwHelpContext;
        }
        if(pBstrHelpFile)
        {
            if (This->HelpFile)
            {
                if(!(*pBstrHelpFile = SysAllocString(TLB_get_bstr(This->HelpFile))))
                    goto memerr3;
            }
            else
                *pBstrHelpFile = NULL;
        }
 
        result = S_OK;
    }
    else
    {
        /* for a typeinfo */
        result = ITypeLib2_fnGetTypeInfo(iface, index, &pTInfo);
 
        if(SUCCEEDED(result))
        {
            result = ITypeInfo_GetDocumentation(pTInfo,
                                          MEMBERID_NIL,
                                          pBstrName,
                                          pBstrDocString,
                                          pdwHelpContext, pBstrHelpFile);
 
            ITypeInfo_Release(pTInfo);
        }
    }
    return result;
memerr3:
    if (pBstrDocString) SysFreeString (*pBstrDocString);
memerr2:
    if (pBstrName) SysFreeString (*pBstrName);
memerr1:
    return STG_E_INSUFFICIENTMEMORY;
}

ITypeLib2_fnGetDocumentation2()

static HRESULT WINAPI ITypeLib2_fnGetDocumentation2 ( ITypeLib2 *  iface, INT  index, LCID  lcid, BSTR *  pbstrHelpString, DWORD *  pdwHelpStringContext, BSTR *  pbstrHelpStringDll  )

static

Definition at line 5300 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
    HRESULT result;
    ITypeInfo *pTInfo;
 
    FIXME("(%p) index %d lcid %d half implemented stub!\n", This, index, lcid);
 
    /* the help string should be obtained from the helpstringdll,
     * using the _DLLGetDocumentation function, based on the supplied
     * lcid. Nice to do sometime...
     */
    if(index<0)
    {
      /* documentation for the typelib */
      if(pbstrHelpString)
        *pbstrHelpString=SysAllocString(TLB_get_bstr(This->DocString));
      if(pdwHelpStringContext)
        *pdwHelpStringContext=This->dwHelpContext;
      if(pbstrHelpStringDll)
        *pbstrHelpStringDll=SysAllocString(TLB_get_bstr(This->HelpStringDll));
 
      result = S_OK;
    }
    else
    {
      /* for a typeinfo */
      result=ITypeLib2_GetTypeInfo(iface, index, &pTInfo);
 
      if(SUCCEEDED(result))
      {
        ITypeInfo2 * pTInfo2;
        result = ITypeInfo_QueryInterface(pTInfo,
                                          &IID_ITypeInfo2,
                                          (LPVOID*) &pTInfo2);
 
        if(SUCCEEDED(result))
        {
          result = ITypeInfo2_GetDocumentation2(pTInfo2,
                                           MEMBERID_NIL,
                                           lcid,
                                           pbstrHelpString,
                                           pdwHelpStringContext,
                                           pbstrHelpStringDll);
 
          ITypeInfo2_Release(pTInfo2);
        }
 
        ITypeInfo_Release(pTInfo);
      }
    }
    return result;
}

ITypeLib2_fnGetLibAttr()

static HRESULT WINAPI ITypeLib2_fnGetLibAttr ( ITypeLib2 *  iface, LPTLIBATTR *  attr  )

static

Definition at line 4992 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
 
    TRACE("(%p, %p)\n", This, attr);
 
    if (!attr) return E_INVALIDARG;
 
    *attr = heap_alloc(sizeof(**attr));
    if (!*attr) return E_OUTOFMEMORY;
 
    (*attr)->guid = *TLB_get_guid_null(This->guid);
    (*attr)->lcid = This->set_lcid;
    (*attr)->syskind = This->syskind;
    (*attr)->wMajorVerNum = This->ver_major;
    (*attr)->wMinorVerNum = This->ver_minor;
    (*attr)->wLibFlags = This->libflags;
 
    return S_OK;
}

ITypeLib2_fnGetLibStatistics()

static HRESULT WINAPI ITypeLib2_fnGetLibStatistics ( ITypeLib2 *  iface, ULONG *  pcUniqueNames, ULONG *  pcchUniqueNames  )

static

Definition at line 5279 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
 
    FIXME("(%p): stub!\n", This);
 
    if(pcUniqueNames) *pcUniqueNames=1;
    if(pcchUniqueNames) *pcchUniqueNames=1;
    return S_OK;
}

ITypeLib2_fnGetTypeComp()

static HRESULT WINAPI ITypeLib2_fnGetTypeComp ( ITypeLib2 *  iface, ITypeComp **  ppTComp  )

static

Definition at line 5021 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
 
    TRACE("(%p)->(%p)\n",This,ppTComp);
    *ppTComp = &This->ITypeComp_iface;
    ITypeComp_AddRef(*ppTComp);
 
    return S_OK;
}

ITypeLib2_fnGetTypeInfo()

static HRESULT WINAPI ITypeLib2_fnGetTypeInfo ( ITypeLib2 *  iface, UINT  index, ITypeInfo **  ppTInfo  )

static

Definition at line 4915 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
 
    TRACE("%p %u %p\n", This, index, ppTInfo);
 
    if(!ppTInfo)
        return E_INVALIDARG;
 
    if(index >= This->TypeInfoCount)
        return TYPE_E_ELEMENTNOTFOUND;
 
    *ppTInfo = (ITypeInfo *)&This->typeinfos[index]->ITypeInfo2_iface;
    ITypeInfo_AddRef(*ppTInfo);
 
    return S_OK;
}

Referenced by ITypeLib2_fnGetDocumentation().

ITypeLib2_fnGetTypeInfoCount()

static UINT WINAPI ITypeLib2_fnGetTypeInfoCount ( ITypeLib2 *  iface )

static

Definition at line 4904 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
    TRACE("(%p)->count is %d\n",This, This->TypeInfoCount);
    return This->TypeInfoCount;
}

ITypeLib2_fnGetTypeInfoOfGuid()

static HRESULT WINAPI ITypeLib2_fnGetTypeInfoOfGuid ( ITypeLib2 *  iface, REFGUID  guid, ITypeInfo **  ppTInfo  )

static

Definition at line 4966 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
    int i;
 
    TRACE("%p %s %p\n", This, debugstr_guid(guid), ppTInfo);
 
    for(i = 0; i < This->TypeInfoCount; ++i){
        if(IsEqualIID(TLB_get_guid_null(This->typeinfos[i]->guid), guid)){
            *ppTInfo = (ITypeInfo *)&This->typeinfos[i]->ITypeInfo2_iface;
            ITypeInfo_AddRef(*ppTInfo);
            return S_OK;
        }
    }
 
    return TYPE_E_ELEMENTNOTFOUND;
}

ITypeLib2_fnGetTypeInfoType()

static HRESULT WINAPI ITypeLib2_fnGetTypeInfoType ( ITypeLib2 *  iface, UINT  index, TYPEKIND *  pTKind  )

static

Definition at line 4941 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
 
    TRACE("(%p, %d, %p)\n", This, index, pTKind);
 
    if(!pTKind)
        return E_INVALIDARG;
 
    if(index >= This->TypeInfoCount)
        return TYPE_E_ELEMENTNOTFOUND;
 
    *pTKind = This->typeinfos[index]->typeattr.typekind;
 
    return S_OK;
}

ITypeLib2_fnIsName()

static HRESULT WINAPI ITypeLib2_fnIsName ( ITypeLib2 *  iface, LPOLESTR  szNameBuf, ULONG  lHashVal, BOOL *  pfName  )

static

Definition at line 5131 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
    int tic;
    UINT nNameBufLen = (lstrlenW(szNameBuf)+1)*sizeof(WCHAR), fdc, vrc;
 
    TRACE("(%p)->(%s,%08x,%p)\n", This, debugstr_w(szNameBuf), lHashVal,
      pfName);
 
    *pfName=TRUE;
    for(tic = 0; tic < This->TypeInfoCount; ++tic){
        ITypeInfoImpl *pTInfo = This->typeinfos[tic];
        if(!TLB_str_memcmp(szNameBuf, pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
        for(fdc = 0; fdc < pTInfo->typeattr.cFuncs; ++fdc) {
            TLBFuncDesc *pFInfo = &pTInfo->funcdescs[fdc];
            int pc;
            if(!TLB_str_memcmp(szNameBuf, pFInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
            for(pc=0; pc < pFInfo->funcdesc.cParams; pc++){
                if(!TLB_str_memcmp(szNameBuf, pFInfo->pParamDesc[pc].Name, nNameBufLen))
                    goto ITypeLib2_fnIsName_exit;
            }
        }
        for(vrc = 0; vrc < pTInfo->typeattr.cVars; ++vrc){
            TLBVarDesc *pVInfo = &pTInfo->vardescs[vrc];
            if(!TLB_str_memcmp(szNameBuf, pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
        }
 
    }
    *pfName=FALSE;
 
ITypeLib2_fnIsName_exit:
    TRACE("(%p)slow! search for %s: %sfound!\n", This,
          debugstr_w(szNameBuf), *pfName ? "" : "NOT ");
 
    return S_OK;
}

ITypeLib2_fnQueryInterface()

static HRESULT WINAPI ITypeLib2_fnQueryInterface ( ITypeLib2 *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 4782 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
 
    TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
 
    if(IsEqualIID(riid, &IID_IUnknown) ||
       IsEqualIID(riid,&IID_ITypeLib)||
       IsEqualIID(riid,&IID_ITypeLib2))
    {
        *ppv = &This->ITypeLib2_iface;
    }
    else if(IsEqualIID(riid, &IID_ICreateTypeLib) ||
             IsEqualIID(riid, &IID_ICreateTypeLib2))
    {
        *ppv = &This->ICreateTypeLib2_iface;
    }
    else
    {
        *ppv = NULL;
        TRACE("-- Interface: E_NOINTERFACE\n");
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

ITypeLib2_fnRelease()

static ULONG WINAPI ITypeLib2_fnRelease ( ITypeLib2 *  iface )

static

Definition at line 4820 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) ref=%u\n",This, ref);
 
    if (!ref)
    {
      TLBImpLib *pImpLib, *pImpLibNext;
      TLBRefType *ref_type, *ref_type_next;
      TLBString *tlbstr, *tlbstr_next;
      TLBGuid *tlbguid, *tlbguid_next;
      int i;
 
      /* remove cache entry */
      if(This->path)
      {
          TRACE("removing from cache list\n");
          EnterCriticalSection(&cache_section);
          if(This->entry.next)
              list_remove(&This->entry);
          LeaveCriticalSection(&cache_section);
          heap_free(This->path);
      }
      TRACE(" destroying ITypeLib(%p)\n",This);
 
      LIST_FOR_EACH_ENTRY_SAFE(tlbstr, tlbstr_next, &This->string_list, TLBString, entry) {
          list_remove(&tlbstr->entry);
          SysFreeString(tlbstr->str);
          heap_free(tlbstr);
      }
 
      LIST_FOR_EACH_ENTRY_SAFE(tlbstr, tlbstr_next, &This->name_list, TLBString, entry) {
          list_remove(&tlbstr->entry);
          SysFreeString(tlbstr->str);
          heap_free(tlbstr);
      }
 
      LIST_FOR_EACH_ENTRY_SAFE(tlbguid, tlbguid_next, &This->guid_list, TLBGuid, entry) {
          list_remove(&tlbguid->entry);
          heap_free(tlbguid);
      }
 
      TLB_FreeCustData(&This->custdata_list);
 
      for (i = 0; i < This->ctTypeDesc; i++)
          if (This->pTypeDesc[i].vt == VT_CARRAY)
              heap_free(This->pTypeDesc[i].u.lpadesc);
 
      heap_free(This->pTypeDesc);
 
      LIST_FOR_EACH_ENTRY_SAFE(pImpLib, pImpLibNext, &This->implib_list, TLBImpLib, entry)
      {
          if (pImpLib->pImpTypeLib)
              ITypeLib2_Release(&pImpLib->pImpTypeLib->ITypeLib2_iface);
          SysFreeString(pImpLib->name);
 
          list_remove(&pImpLib->entry);
          heap_free(pImpLib);
      }
 
      LIST_FOR_EACH_ENTRY_SAFE(ref_type, ref_type_next, &This->ref_list, TLBRefType, entry)
      {
          list_remove(&ref_type->entry);
          heap_free(ref_type);
      }
 
      for (i = 0; i < This->TypeInfoCount; ++i){
          heap_free(This->typeinfos[i]->tdescAlias);
          ITypeInfoImpl_Destroy(This->typeinfos[i]);
      }
      heap_free(This->typeinfos);
      heap_free(This);
      return 0;
    }
 
    return ref;
}

ITypeLib2_fnReleaseTLibAttr()

static VOID WINAPI ITypeLib2_fnReleaseTLibAttr ( ITypeLib2 *  iface, TLIBATTR *  pTLibAttr  )

static

Definition at line 5240 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeLib2(iface);
    TRACE("(%p)->(%p)\n", This, pTLibAttr);
    heap_free(pTLibAttr);
}

ITypeLibComp_fnAddRef()

static ULONG WINAPI ITypeLibComp_fnAddRef ( ITypeComp *  iface )

static

Definition at line 5428 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeComp(iface);
 
    return ITypeLib2_AddRef(&This->ITypeLib2_iface);
}

ITypeLibComp_fnBind()

static HRESULT WINAPI ITypeLibComp_fnBind ( ITypeComp *  iface, OLECHAR *  szName, ULONG  lHash, WORD  wFlags, ITypeInfo **  ppTInfo, DESCKIND *  pDescKind, BINDPTR *  pBindPtr  )

static

Definition at line 5442 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeComp(iface);
    BOOL typemismatch = FALSE;
    int i;
 
    TRACE("(%p)->(%s, 0x%x, 0x%x, %p, %p, %p)\n", This, debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
 
    *pDescKind = DESCKIND_NONE;
    pBindPtr->lptcomp = NULL;
    *ppTInfo = NULL;
 
    for(i = 0; i < This->TypeInfoCount; ++i){
        ITypeInfoImpl *pTypeInfo = This->typeinfos[i];
        TRACE("testing %s\n", debugstr_w(TLB_get_bstr(pTypeInfo->Name)));
 
        /* FIXME: check wFlags here? */
        /* FIXME: we should use a hash table to look this info up using lHash
         * instead of an O(n) search */
        if ((pTypeInfo->typeattr.typekind == TKIND_ENUM) ||
            (pTypeInfo->typeattr.typekind == TKIND_MODULE))
        {
            if (pTypeInfo->Name && !wcscmp(pTypeInfo->Name->str, szName))
            {
                *pDescKind = DESCKIND_TYPECOMP;
                pBindPtr->lptcomp = &pTypeInfo->ITypeComp_iface;
                ITypeComp_AddRef(pBindPtr->lptcomp);
                TRACE("module or enum: %s\n", debugstr_w(szName));
                return S_OK;
            }
        }
 
        if ((pTypeInfo->typeattr.typekind == TKIND_MODULE) ||
            (pTypeInfo->typeattr.typekind == TKIND_ENUM))
        {
            ITypeComp *pSubTypeComp = &pTypeInfo->ITypeComp_iface;
            HRESULT hr;
 
            hr = ITypeComp_Bind(pSubTypeComp, szName, lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
            if (SUCCEEDED(hr) && (*pDescKind != DESCKIND_NONE))
            {
                TRACE("found in module or in enum: %s\n", debugstr_w(szName));
                return S_OK;
            }
            else if (hr == TYPE_E_TYPEMISMATCH)
                typemismatch = TRUE;
        }
 
        if ((pTypeInfo->typeattr.typekind == TKIND_COCLASS) &&
            (pTypeInfo->typeattr.wTypeFlags & TYPEFLAG_FAPPOBJECT))
        {
            ITypeComp *pSubTypeComp = &pTypeInfo->ITypeComp_iface;
            HRESULT hr;
            ITypeInfo *subtypeinfo;
            BINDPTR subbindptr;
            DESCKIND subdesckind;
 
            hr = ITypeComp_Bind(pSubTypeComp, szName, lHash, wFlags,
                &subtypeinfo, &subdesckind, &subbindptr);
            if (SUCCEEDED(hr) && (subdesckind != DESCKIND_NONE))
            {
                TYPEDESC tdesc_appobject;
                const VARDESC vardesc_appobject =
                {
                    -2,         /* memid */
                    NULL,       /* lpstrSchema */
                    {
                        0       /* oInst */
                    },
                    {
                                /* ELEMDESC */
                        {
                                /* TYPEDESC */
                                {
                                    &tdesc_appobject
                                },
                                VT_PTR
                        },
                    },
                    0,          /* wVarFlags */
                    VAR_STATIC  /* varkind */
                };
 
                tdesc_appobject.u.hreftype = pTypeInfo->hreftype;
                tdesc_appobject.vt = VT_USERDEFINED;
 
                TRACE("found in implicit app object: %s\n", debugstr_w(szName));
 
                /* cleanup things filled in by Bind call so we can put our
                 * application object data in there instead */
                switch (subdesckind)
                {
                case DESCKIND_FUNCDESC:
                    ITypeInfo_ReleaseFuncDesc(subtypeinfo, subbindptr.lpfuncdesc);
                    break;
                case DESCKIND_VARDESC:
                    ITypeInfo_ReleaseVarDesc(subtypeinfo, subbindptr.lpvardesc);
                    break;
                default:
                    break;
                }
                if (subtypeinfo) ITypeInfo_Release(subtypeinfo);
 
                if (pTypeInfo->hreftype == -1)
                    FIXME("no hreftype for interface %p\n", pTypeInfo);
 
                hr = TLB_AllocAndInitVarDesc(&vardesc_appobject, &pBindPtr->lpvardesc);
                if (FAILED(hr))
                    return hr;
 
                *pDescKind = DESCKIND_IMPLICITAPPOBJ;
                *ppTInfo = (ITypeInfo *)&pTypeInfo->ITypeInfo2_iface;
                ITypeInfo_AddRef(*ppTInfo);
                return S_OK;
            }
            else if (hr == TYPE_E_TYPEMISMATCH)
                typemismatch = TRUE;
        }
    }
 
    if (typemismatch)
    {
        TRACE("type mismatch %s\n", debugstr_w(szName));
        return TYPE_E_TYPEMISMATCH;
    }
    else
    {
        TRACE("name not found %s\n", debugstr_w(szName));
        return S_OK;
    }
}

ITypeLibComp_fnBindType()

static HRESULT WINAPI ITypeLibComp_fnBindType ( ITypeComp *  iface, OLECHAR *  szName, ULONG  lHash, ITypeInfo **  ppTInfo, ITypeComp **  ppTComp  )

static

Definition at line 5581 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeComp(iface);
    ITypeInfoImpl *info;
 
    TRACE("(%s, %x, %p, %p)\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
 
    if(!szName || !ppTInfo || !ppTComp)
        return E_INVALIDARG;
 
    info = TLB_get_typeinfo_by_name(This->typeinfos, This->TypeInfoCount, szName);
    if(!info){
        *ppTInfo = NULL;
        *ppTComp = NULL;
        return S_OK;
    }
 
    *ppTInfo = (ITypeInfo *)&info->ITypeInfo2_iface;
    ITypeInfo_AddRef(*ppTInfo);
    *ppTComp = &info->ITypeComp_iface;
    ITypeComp_AddRef(*ppTComp);
 
    return S_OK;
}

ITypeLibComp_fnQueryInterface()

static HRESULT WINAPI ITypeLibComp_fnQueryInterface ( ITypeComp *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 5421 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeComp(iface);
 
    return ITypeLib2_QueryInterface(&This->ITypeLib2_iface, riid, ppv);
}

ITypeLibComp_fnRelease()

static ULONG WINAPI ITypeLibComp_fnRelease ( ITypeComp *  iface )

static

Definition at line 5435 of file typelib.c.

{
    ITypeLibImpl *This = impl_from_ITypeComp(iface);
 
    return ITypeLib2_Release(&This->ITypeLib2_iface);
}

LoadRegTypeLib()

HRESULT WINAPI LoadRegTypeLib	(	REFGUID	rguid,
		WORD	wVerMajor,
		WORD	wVerMinor,
		LCID	lcid,
		ITypeLib **	ppTLib
	)

Definition at line 531 of file typelib.c.

{
    BSTR bstr=NULL;
    HRESULT res;
 
    *ppTLib = NULL;
 
    res = QueryPathOfRegTypeLib( rguid, wVerMajor, wVerMinor, lcid, &bstr);
 
    if(SUCCEEDED(res))
    {
        res= LoadTypeLib(bstr, ppTLib);
        SysFreeString(bstr);
 
        if ((wVerMajor!=0xffff || wVerMinor!=0xffff) && *ppTLib)
        {
            TLIBATTR *attr;
 
            res = ITypeLib_GetLibAttr(*ppTLib, &attr);
            if (res == S_OK)
            {
                BOOL mismatch = attr->wMajorVerNum != wVerMajor || attr->wMinorVerNum < wVerMinor;
                ITypeLib_ReleaseTLibAttr(*ppTLib, attr);
 
                if (mismatch)
                {
                    ITypeLib_Release(*ppTLib);
                    *ppTLib = NULL;
                    res = TYPE_E_LIBNOTREGISTERED;
                }
            }
        }
    }
 
    TRACE("(IID: %s) load %s (%p)\n",debugstr_guid(rguid), SUCCEEDED(res)? "SUCCESS":"FAILED", *ppTLib);
 
    return res;
}

Referenced by BaseDispatch_Init(), ATL::IDispatchImpl< T, piid, plibid, wMajor, wMinor >::EnsureTILoaded(), get_type_info(), get_typeinfo(), get_typelib(), GetRecordInfoFromGuids(), CTipbarAccessible::Initialize(), load_typelib(), NonOleAutomation_GetTypeInfo(), test_libattr(), test_LoadRegTypeLib(), test_register_typelib(), tl_absent(), and tl_present().

LoadTypeLib()

HRESULT WINAPI LoadTypeLib	(	const OLECHAR *	szFile,
		ITypeLib **	pptLib
	)

Definition at line 458 of file typelib.c.

{
    TRACE("(%s,%p)\n",debugstr_w(szFile), pptLib);
    return LoadTypeLibEx(szFile, REGKIND_DEFAULT, pptLib);
}

Referenced by AtlLoadTypeLib(), ATL::AtlLoadTypeLib(), Dispatch_GetTypeInfo(), get_typeinfo(), get_typeinfo_for_iid(), ICreateTypeInfo2_fnSetTypeFlags(), init_regexp_typeinfo(), CTipbarAccessible::Initialize(), ITypeInfo_fnGetRefTypeInfo(), load_typelib(), LoadRegTypeLib(), OLEFontImpl_GetTypeInfo(), OLEPictureImpl_GetTypeInfo(), ref_count_test(), register_current_module_typelib(), test_create_typelib_lcid(), test_CreateStdDispatch(), test_CreateTypeLib(), test_FindName(), test_GetLibAttr(), test_inheritance(), test_LoadTypeLib(), test_SetDocString(), test_SetVarHelpContext(), test_stub(), test_TypeComp(), test_TypeInfo(), and Typelib_EnumResNameProc().

LoadTypeLibEx()

HRESULT WINAPI LoadTypeLibEx	(	LPCOLESTR	szFile,
		REGKIND	regkind,
		ITypeLib **	pptLib
	)

Definition at line 473 of file typelib.c.

{
    WCHAR szPath[MAX_PATH+1];
    HRESULT res;
 
    TRACE("(%s,%d,%p)\n",debugstr_w(szFile), regkind, pptLib);
 
    if (!szFile || !pptLib)
        return E_INVALIDARG;
 
    *pptLib = NULL;
 
    res = TLB_ReadTypeLib(szFile, szPath, MAX_PATH + 1, (ITypeLib2**)pptLib);
 
    if (SUCCEEDED(res))
        switch(regkind)
        {
            case REGKIND_DEFAULT:
                /* don't register typelibs supplied with full path. Experimentation confirms the following */
                if (((szFile[0] == '\\') && (szFile[1] == '\\')) ||
                    (szFile[0] && (szFile[1] == ':'))) break;
                /* else fall-through */
 
            case REGKIND_REGISTER:
                if (FAILED(res = RegisterTypeLib(*pptLib, szPath, NULL)))
                {
                    ITypeLib_Release(*pptLib);
                    *pptLib = 0;
                }
                break;
            case REGKIND_NONE:
                break;
        }
 
    TRACE(" returns %08x\n",res);
    return res;
}

Referenced by LoadTypeLib(), SEALED_::LoadTypeLibrary(), msi_load_typelib(), register_server(), search_res_tlb(), test_CreateTypeLib(), test_dep(), test_dump_typelib(), test_LoadTypeLib(), test_recinfo(), test_register_typelib(), test_SetTypeDescAlias(), and UnRegisterTypeLib().

lookup_code()

static const char * lookup_code ( const BYTE *  table, DWORD  table_size, struct bitstream *  bits  )

static

Definition at line 3703 of file typelib.c.

{
    const BYTE *p = table;
 
    while (p < table + table_size && *p == 0x80)
    {
        if (p + 2 >= table + table_size) return NULL;
 
        if (!(bits->current & 0xff))
        {
            if (!bits->length) return NULL;
            bits->current = (*bits->buffer << 8) | 1;
            bits->buffer++;
            bits->length--;
        }
 
        if (bits->current & 0x8000)
        {
            p += 3;
        }
        else
        {
            p = table + (*(p + 2) | (*(p + 1) << 8));
        }
 
        bits->current <<= 1;
    }
 
    if (p + 1 < table + table_size && *(p + 1))
    {
        /* FIXME: Whats the meaning of *p? */
        const BYTE *q = p + 1;
        while (q < table + table_size && *q) q++;
        return (q < table + table_size) ? (const char *)(p + 1) : NULL;
    }
 
    return NULL;
}

Referenced by decode_string().

mapping_impl_from_IUnknown()

static TLB_Mapping * mapping_impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 3195 of file typelib.c.

{
    return CONTAINING_RECORD(iface, TLB_Mapping, IUnknown_iface);
}

Referenced by TLB_Mapping_AddRef(), and TLB_Mapping_Release().

MSFT_CustData()

static int MSFT_CustData ( TLBContext *  pcx, int  offset, struct list *  custdata_list  )

static

Definition at line 2300 of file typelib.c.

{
    MSFT_CDGuid entry;
    TLBCustData* pNew;
    int count=0;
 
    TRACE_(typelib)("\n");
 
    if (pcx->pTblDir->pCDGuids.offset < 0) return 0;
 
    while(offset >=0){
        count++;
        pNew=heap_alloc_zero(sizeof(TLBCustData));
        MSFT_ReadLEDWords(&entry, sizeof(entry), pcx, pcx->pTblDir->pCDGuids.offset+offset);
        pNew->guid = MSFT_ReadGuid(entry.GuidOffset, pcx);
        MSFT_ReadValue(&(pNew->data), entry.DataOffset, pcx);
        list_add_head(custdata_list, &pNew->entry);
        offset = entry.next;
    }
    return count;
}

Referenced by ITypeLib2_Constructor_MSFT(), MSFT_DoFuncs(), MSFT_DoImplTypes(), and MSFT_DoTypeInfo().

MSFT_DoFuncs()

static void MSFT_DoFuncs ( TLBContext *  pcx, ITypeInfoImpl *  pTI, int  cFuncs, int  cVars, int  offset, TLBFuncDesc **  pptfd  )

static

Definition at line 2340 of file typelib.c.

{
    /*
     * member information is stored in a data structure at offset
     * indicated by the memoffset field of the typeinfo structure
     * There are several distinctive parts.
     * The first part starts with a field that holds the total length
     * of this (first) part excluding this field. Then follow the records,
     * for each member there is one record.
     *
     * The first entry is always the length of the record (including this
     * length word).
     * The rest of the record depends on the type of the member. If there is
     * a field indicating the member type (function, variable, interface, etc)
     * I have not found it yet. At this time we depend on the information
     * in the type info and the usual order how things are stored.
     *
     * Second follows an array sized nrMEM*sizeof(INT) with a member id
     * for each member;
     *
     * Third is an equal sized array with file offsets to the name entry
     * of each member.
     *
     * The fourth and last (?) part is an array with offsets to the records
     * in the first part of this file segment.
     */
 
    int infolen, nameoffset, reclength, i;
    int recoffset = offset + sizeof(INT);
 
    char *recbuf = heap_alloc(0xffff);
    MSFT_FuncRecord *pFuncRec = (MSFT_FuncRecord*)recbuf;
    TLBFuncDesc *ptfd_prev = NULL, *ptfd;
 
    TRACE_(typelib)("\n");
 
    MSFT_ReadLEDWords(&infolen, sizeof(INT), pcx, offset);
 
    *pptfd = TLBFuncDesc_Alloc(cFuncs);
    ptfd = *pptfd;
    for ( i = 0; i < cFuncs ; i++ )
    {
        int optional;
 
        /* name, eventually add to a hash table */
        MSFT_ReadLEDWords(&nameoffset, sizeof(INT), pcx,
                          offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
 
        /* read the function information record */
        MSFT_ReadLEDWords(&reclength, sizeof(pFuncRec->Info), pcx, recoffset);
 
        reclength &= 0xffff;
 
        MSFT_ReadLEDWords(&pFuncRec->DataType, reclength - FIELD_OFFSET(MSFT_FuncRecord, DataType), pcx, DO_NOT_SEEK);
 
        /* size without argument data */
        optional = reclength - pFuncRec->nrargs*sizeof(MSFT_ParameterInfo);
        if (pFuncRec->FKCCIC & 0x1000)
            optional -= pFuncRec->nrargs * sizeof(INT);
 
        if (optional > FIELD_OFFSET(MSFT_FuncRecord, HelpContext))
            ptfd->helpcontext = pFuncRec->HelpContext;
 
        if (optional > FIELD_OFFSET(MSFT_FuncRecord, oHelpString))
            ptfd->HelpString = MSFT_ReadString(pcx, pFuncRec->oHelpString);
 
        if (optional > FIELD_OFFSET(MSFT_FuncRecord, oEntry))
        {
            if (pFuncRec->FKCCIC & 0x2000 )
            {
                if (!IS_INTRESOURCE(pFuncRec->oEntry))
                    ERR("ordinal 0x%08x invalid, IS_INTRESOURCE is false\n", pFuncRec->oEntry);
                ptfd->Entry = (TLBString*)(DWORD_PTR)LOWORD(pFuncRec->oEntry);
            }
            else
                ptfd->Entry = MSFT_ReadString(pcx, pFuncRec->oEntry);
        }
        else
            ptfd->Entry = (TLBString*)-1;
 
        if (optional > FIELD_OFFSET(MSFT_FuncRecord, HelpStringContext))
            ptfd->HelpStringContext = pFuncRec->HelpStringContext;
 
        if (optional > FIELD_OFFSET(MSFT_FuncRecord, oCustData) && pFuncRec->FKCCIC & 0x80)
            MSFT_CustData(pcx, pFuncRec->oCustData, &ptfd->custdata_list);
 
        /* fill the FuncDesc Structure */
        MSFT_ReadLEDWords( & ptfd->funcdesc.memid, sizeof(INT), pcx,
                           offset + infolen + ( i + 1) * sizeof(INT));
 
        ptfd->funcdesc.funckind   =  (pFuncRec->FKCCIC)      & 0x7;
        ptfd->funcdesc.invkind    =  (pFuncRec->FKCCIC) >> 3 & 0xF;
        ptfd->funcdesc.callconv   =  (pFuncRec->FKCCIC) >> 8 & 0xF;
        ptfd->funcdesc.cParams    =   pFuncRec->nrargs  ;
        ptfd->funcdesc.cParamsOpt =   pFuncRec->nroargs ;
        ptfd->funcdesc.oVft       =   (pFuncRec->VtableOffset & ~1) * sizeof(void *) / pTI->pTypeLib->ptr_size;
        ptfd->funcdesc.wFuncFlags =   LOWORD(pFuncRec->Flags) ;
 
        /* nameoffset is sometimes -1 on the second half of a propget/propput
         * pair of functions */
        if ((nameoffset == -1) && (i > 0) &&
                TLB_is_propgetput(ptfd_prev->funcdesc.invkind) &&
                TLB_is_propgetput(ptfd->funcdesc.invkind))
            ptfd->Name = ptfd_prev->Name;
        else
            ptfd->Name = MSFT_ReadName(pcx, nameoffset);
 
        MSFT_GetTdesc(pcx,
              pFuncRec->DataType,
              &ptfd->funcdesc.elemdescFunc.tdesc);
 
        /* do the parameters/arguments */
        if(pFuncRec->nrargs)
        {
            int j = 0;
            MSFT_ParameterInfo paraminfo;
 
            ptfd->funcdesc.lprgelemdescParam =
                heap_alloc_zero(pFuncRec->nrargs * (sizeof(ELEMDESC) + sizeof(PARAMDESCEX)));
 
            ptfd->pParamDesc = TLBParDesc_Constructor(pFuncRec->nrargs);
 
            MSFT_ReadLEDWords(&paraminfo, sizeof(paraminfo), pcx,
                              recoffset + reclength - pFuncRec->nrargs * sizeof(MSFT_ParameterInfo));
 
            for ( j = 0 ; j < pFuncRec->nrargs ; j++ )
            {
                ELEMDESC *elemdesc = &ptfd->funcdesc.lprgelemdescParam[j];
 
                MSFT_GetTdesc(pcx,
                  paraminfo.DataType,
                  &elemdesc->tdesc);
 
                elemdesc->u.paramdesc.wParamFlags = paraminfo.Flags;
 
                /* name */
                if (paraminfo.oName != -1)
                    ptfd->pParamDesc[j].Name =
                        MSFT_ReadName( pcx, paraminfo.oName );
                TRACE_(typelib)("param[%d] = %s\n", j, debugstr_w(TLB_get_bstr(ptfd->pParamDesc[j].Name)));
 
                /* default value */
                if ( (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) &&
                     (pFuncRec->FKCCIC & 0x1000) )
                {
                    INT* pInt = (INT *)((char *)pFuncRec +
                                   reclength -
                                   (pFuncRec->nrargs * 4) * sizeof(INT) );
 
                    PARAMDESC* pParamDesc = &elemdesc->u.paramdesc;
 
                    pParamDesc->pparamdescex = (PARAMDESCEX*)(ptfd->funcdesc.lprgelemdescParam+pFuncRec->nrargs)+j;
                    pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
 
            MSFT_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue),
                        pInt[j], pcx);
                }
                else
                    elemdesc->u.paramdesc.pparamdescex = NULL;
 
                /* custom info */
                if (optional > (FIELD_OFFSET(MSFT_FuncRecord, oArgCustData) +
                                j*sizeof(pFuncRec->oArgCustData[0])) &&
                    pFuncRec->FKCCIC & 0x80 )
                {
                    MSFT_CustData(pcx,
                  pFuncRec->oArgCustData[j],
                  &ptfd->pParamDesc[j].custdata_list);
                }
 
                /* SEEK value = jump to offset,
                 * from there jump to the end of record,
                 * go back by (j-1) arguments
                 */
                MSFT_ReadLEDWords( &paraminfo ,
               sizeof(MSFT_ParameterInfo), pcx,
               recoffset + reclength - ((pFuncRec->nrargs - j - 1)
                           * sizeof(MSFT_ParameterInfo)));
            }
        }
 
        /* scode is not used: archaic win16 stuff FIXME: right? */
        ptfd->funcdesc.cScodes   = 0 ;
        ptfd->funcdesc.lprgscode = NULL ;
 
        ptfd_prev = ptfd;
        ++ptfd;
        recoffset += reclength;
    }
    heap_free(recbuf);
}

Referenced by MSFT_DoTypeInfo().

MSFT_DoImplTypes()

static void MSFT_DoImplTypes ( TLBContext *  pcx, ITypeInfoImpl *  pTI, int  count, int  offset  )

static

Definition at line 2593 of file typelib.c.

{
    int i;
    MSFT_RefRecord refrec;
    TLBImplType *pImpl;
 
    TRACE_(typelib)("\n");
 
    pTI->impltypes = TLBImplType_Alloc(count);
    pImpl = pTI->impltypes;
    for(i=0;i<count;i++){
        if(offset<0) break; /* paranoia */
        MSFT_ReadLEDWords(&refrec,sizeof(refrec),pcx,offset+pcx->pTblDir->pRefTab.offset);
        pImpl->hRef = refrec.reftype;
        pImpl->implflags=refrec.flags;
        MSFT_CustData(pcx, refrec.oCustData, &pImpl->custdata_list);
        offset=refrec.onext;
        ++pImpl;
    }
}

Referenced by MSFT_DoTypeInfo().

MSFT_DoTypeInfo()

static ITypeInfoImpl * MSFT_DoTypeInfo ( TLBContext *  pcx, int  count, ITypeLibImpl *  pLibInfo  )

static

Definition at line 2658 of file typelib.c.

{
    MSFT_TypeInfoBase tiBase;
    ITypeInfoImpl *ptiRet;
 
    TRACE_(typelib)("count=%u\n", count);
 
    ptiRet = ITypeInfoImpl_Constructor();
    MSFT_ReadLEDWords(&tiBase, sizeof(tiBase) ,pcx ,
                      pcx->pTblDir->pTypeInfoTab.offset+count*sizeof(tiBase));
 
/* this is where we are coming from */
    ptiRet->pTypeLib = pLibInfo;
    ptiRet->index=count;
 
    ptiRet->guid = MSFT_ReadGuid(tiBase.posguid, pcx);
    ptiRet->typeattr.lcid = pLibInfo->set_lcid;   /* FIXME: correct? */
    ptiRet->typeattr.lpstrSchema = NULL;              /* reserved */
    ptiRet->typeattr.cbSizeInstance = tiBase.size;
    ptiRet->typeattr.typekind = tiBase.typekind & 0xF;
    ptiRet->typeattr.cFuncs = LOWORD(tiBase.cElement);
    ptiRet->typeattr.cVars = HIWORD(tiBase.cElement);
    ptiRet->typeattr.cbAlignment = (tiBase.typekind >> 11 )& 0x1F; /* there are more flags there */
    ptiRet->typeattr.wTypeFlags = tiBase.flags;
    ptiRet->typeattr.wMajorVerNum = LOWORD(tiBase.version);
    ptiRet->typeattr.wMinorVerNum = HIWORD(tiBase.version);
    ptiRet->typeattr.cImplTypes = tiBase.cImplTypes;
    ptiRet->typeattr.cbSizeVft = tiBase.cbSizeVft;
    if (ptiRet->typeattr.typekind == TKIND_ALIAS) {
        TYPEDESC tmp;
        MSFT_GetTdesc(pcx, tiBase.datatype1, &tmp);
        ptiRet->tdescAlias = heap_alloc(TLB_SizeTypeDesc(&tmp, TRUE));
        TLB_CopyTypeDesc(NULL, &tmp, ptiRet->tdescAlias);
    }
 
/*  FIXME: */
/*    IDLDESC  idldescType; *//* never saw this one != zero  */
 
/* name, eventually add to a hash table */
    ptiRet->Name=MSFT_ReadName(pcx, tiBase.NameOffset);
    ptiRet->hreftype = MSFT_ReadHreftype(pcx, tiBase.NameOffset);
    TRACE_(typelib)("reading %s\n", debugstr_w(TLB_get_bstr(ptiRet->Name)));
    /* help info */
    ptiRet->DocString=MSFT_ReadString(pcx, tiBase.docstringoffs);
    ptiRet->dwHelpStringContext=tiBase.helpstringcontext;
    ptiRet->dwHelpContext=tiBase.helpcontext;
 
    if (ptiRet->typeattr.typekind == TKIND_MODULE)
        ptiRet->DllName = MSFT_ReadString(pcx, tiBase.datatype1);
 
/* note: InfoType's Help file and HelpStringDll come from the containing
 * library. Further HelpString and Docstring appear to be the same thing :(
 */
    /* functions */
    if(ptiRet->typeattr.cFuncs >0 )
        MSFT_DoFuncs(pcx, ptiRet, ptiRet->typeattr.cFuncs,
            ptiRet->typeattr.cVars,
            tiBase.memoffset, &ptiRet->funcdescs);
    /* variables */
    if(ptiRet->typeattr.cVars >0 )
        MSFT_DoVars(pcx, ptiRet, ptiRet->typeattr.cFuncs,
           ptiRet->typeattr.cVars,
           tiBase.memoffset, &ptiRet->vardescs);
    if(ptiRet->typeattr.cImplTypes >0 ) {
        switch(ptiRet->typeattr.typekind)
        {
        case TKIND_COCLASS:
            MSFT_DoImplTypes(pcx, ptiRet, ptiRet->typeattr.cImplTypes,
                tiBase.datatype1);
            break;
        case TKIND_DISPATCH:
            /* This is not -1 when the interface is a non-base dual interface or
               when a dispinterface wraps an interface, i.e., the idl 'dispinterface x {interface y;};'.
               Note however that GetRefTypeOfImplType(0) always returns a ref to IDispatch and
               not this interface.
            */
 
            if (tiBase.datatype1 != -1)
            {
                ptiRet->impltypes = TLBImplType_Alloc(1);
                ptiRet->impltypes[0].hRef = tiBase.datatype1;
            }
            break;
        default:
            ptiRet->impltypes = TLBImplType_Alloc(1);
            ptiRet->impltypes[0].hRef = tiBase.datatype1;
            break;
       }
    }
    MSFT_CustData(pcx, tiBase.oCustData, ptiRet->pcustdata_list);
 
    TRACE_(typelib)("%s guid: %s kind:%s\n",
       debugstr_w(TLB_get_bstr(ptiRet->Name)),
       debugstr_guid(TLB_get_guidref(ptiRet->guid)),
       typekind_desc[ptiRet->typeattr.typekind]);
    if (TRACE_ON(typelib))
      dump_TypeInfo(ptiRet);
 
    return ptiRet;
}

Referenced by ITypeLib2_Constructor_MSFT().

MSFT_DoVars()

static void MSFT_DoVars ( TLBContext *  pcx, ITypeInfoImpl *  pTI, int  cFuncs, int  cVars, int  offset, TLBVarDesc **  pptvd  )

static

Definition at line 2537 of file typelib.c.

{
    int infolen, nameoffset, reclength;
    char recbuf[256];
    MSFT_VarRecord *pVarRec = (MSFT_VarRecord*)recbuf;
    TLBVarDesc *ptvd;
    int i;
    int recoffset;
 
    TRACE_(typelib)("\n");
 
    ptvd = *pptvd = TLBVarDesc_Alloc(cVars);
    MSFT_ReadLEDWords(&infolen,sizeof(INT), pcx, offset);
    MSFT_ReadLEDWords(&recoffset,sizeof(INT), pcx, offset + infolen +
                      ((cFuncs+cVars)*2+cFuncs + 1)*sizeof(INT));
    recoffset += offset+sizeof(INT);
    for(i=0;i<cVars;i++, ++ptvd){
    /* name, eventually add to a hash table */
        MSFT_ReadLEDWords(&nameoffset, sizeof(INT), pcx,
                          offset + infolen + (2*cFuncs + cVars + i + 1) * sizeof(INT));
        ptvd->Name=MSFT_ReadName(pcx, nameoffset);
    /* read the variable information record */
        MSFT_ReadLEDWords(&reclength, sizeof(pVarRec->Info), pcx, recoffset);
        reclength &= 0xff;
        MSFT_ReadLEDWords(&pVarRec->DataType, reclength - FIELD_OFFSET(MSFT_VarRecord, DataType), pcx, DO_NOT_SEEK);
 
        /* optional data */
        if(reclength > FIELD_OFFSET(MSFT_VarRecord, HelpContext))
            ptvd->HelpContext = pVarRec->HelpContext;
 
        if(reclength > FIELD_OFFSET(MSFT_VarRecord, HelpString))
            ptvd->HelpString = MSFT_ReadString(pcx, pVarRec->HelpString);
 
        if(reclength > FIELD_OFFSET(MSFT_VarRecord, HelpStringContext))
            ptvd->HelpStringContext = pVarRec->HelpStringContext;
 
    /* fill the VarDesc Structure */
        MSFT_ReadLEDWords(&ptvd->vardesc.memid, sizeof(INT), pcx,
                          offset + infolen + (cFuncs + i + 1) * sizeof(INT));
        ptvd->vardesc.varkind = pVarRec->VarKind;
        ptvd->vardesc.wVarFlags = pVarRec->Flags;
        MSFT_GetTdesc(pcx, pVarRec->DataType,
            &ptvd->vardesc.elemdescVar.tdesc);
/*   ptvd->vardesc.lpstrSchema; is reserved (SDK) FIXME?? */
        if(pVarRec->VarKind == VAR_CONST ){
            ptvd->vardesc.u.lpvarValue = heap_alloc_zero(sizeof(VARIANT));
            MSFT_ReadValue(ptvd->vardesc.u.lpvarValue,
                pVarRec->OffsValue, pcx);
        } else
            ptvd->vardesc.u.oInst=pVarRec->OffsValue;
        recoffset += reclength;
    }
}

Referenced by MSFT_DoTypeInfo().

MSFT_GetTdesc()

static void MSFT_GetTdesc ( TLBContext *  pcx, INT  type, TYPEDESC *  pTd  )

static

Definition at line 2322 of file typelib.c.

{
    if(type <0)
        pTd->vt=type & VT_TYPEMASK;
    else
        *pTd=pcx->pLibInfo->pTypeDesc[type/(2*sizeof(INT))];
 
    TRACE_(typelib)("vt type = %X\n", pTd->vt);
}

Referenced by MSFT_DoFuncs(), MSFT_DoTypeInfo(), and MSFT_DoVars().

MSFT_Read()

static DWORD MSFT_Read ( void *  buffer, DWORD  count, TLBContext *  pcx, LONG  where  )

static

Definition at line 2046 of file typelib.c.

{
    TRACE_(typelib)("pos=0x%08x len=0x%08x 0x%08x 0x%08x 0x%08x\n",
       pcx->pos, count, pcx->oStart, pcx->length, where);
 
    MSFT_Seek(pcx, where);
    if (pcx->pos + count > pcx->length) count = pcx->length - pcx->pos;
    memcpy( buffer, (char *)pcx->mapping + pcx->pos, count );
    pcx->pos += count;
    return count;
}

Referenced by ITypeLib2_Constructor_MSFT(), MSFT_ReadAllNames(), MSFT_ReadAllStrings(), MSFT_ReadLEDWords(), MSFT_ReadLEWords(), and MSFT_ReadValue().

MSFT_ReadAllGuids()

static HRESULT MSFT_ReadAllGuids ( TLBContext *  pcx )

static

Definition at line 2080 of file typelib.c.

{
    TLBGuid *guid;
    MSFT_GuidEntry entry;
    int offs = 0;
 
    MSFT_Seek(pcx, pcx->pTblDir->pGuidTab.offset);
    while (1) {
        if (offs >= pcx->pTblDir->pGuidTab.length)
            return S_OK;
 
        MSFT_ReadLEWords(&entry, sizeof(MSFT_GuidEntry), pcx, DO_NOT_SEEK);
 
        guid = heap_alloc(sizeof(TLBGuid));
 
        guid->offset = offs;
        guid->guid = entry.guid;
        guid->hreftype = entry.hreftype;
 
        list_add_tail(&pcx->pLibInfo->guid_list, &guid->entry);
 
        offs += sizeof(MSFT_GuidEntry);
    }
}

Referenced by ITypeLib2_Constructor_MSFT().

MSFT_ReadAllNames()

static HRESULT MSFT_ReadAllNames ( TLBContext *  pcx )

static

Definition at line 2135 of file typelib.c.

{
    char *string;
    MSFT_NameIntro intro;
    INT16 len_piece;
    int offs = 0, lengthInChars;
 
    MSFT_Seek(pcx, pcx->pTblDir->pNametab.offset);
    while (1) {
        TLBString *tlbstr;
 
        if (offs >= pcx->pTblDir->pNametab.length)
            return S_OK;
 
        MSFT_ReadLEWords(&intro, sizeof(MSFT_NameIntro), pcx, DO_NOT_SEEK);
        intro.namelen &= 0xFF;
        len_piece = intro.namelen + sizeof(MSFT_NameIntro);
        if(len_piece % 4)
            len_piece = (len_piece + 4) & ~0x3;
        if(len_piece < 8)
            len_piece = 8;
 
        string = heap_alloc(len_piece + 1);
        MSFT_Read(string, len_piece - sizeof(MSFT_NameIntro), pcx, DO_NOT_SEEK);
        string[intro.namelen] = '\0';
 
        lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
                                            string, -1, NULL, 0);
        if (!lengthInChars) {
            heap_free(string);
            return E_UNEXPECTED;
        }
 
        tlbstr = heap_alloc(sizeof(TLBString));
 
        tlbstr->offset = offs;
        tlbstr->str = SysAllocStringByteLen(NULL, lengthInChars * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, string, -1, tlbstr->str, lengthInChars);
 
        heap_free(string);
 
        list_add_tail(&pcx->pLibInfo->name_list, &tlbstr->entry);
 
        offs += len_piece;
    }
}

Referenced by ITypeLib2_Constructor_MSFT().

MSFT_ReadAllRefs()

static HRESULT MSFT_ReadAllRefs ( TLBContext *  pcx )

static

Definition at line 2807 of file typelib.c.

{
    TLBRefType *ref;
    int offs = 0;
 
    MSFT_Seek(pcx, pcx->pTblDir->pImpInfo.offset);
    while (offs < pcx->pTblDir->pImpInfo.length) {
        MSFT_ImpInfo impinfo;
        TLBImpLib *pImpLib;
 
        MSFT_ReadLEDWords(&impinfo, sizeof(impinfo), pcx, DO_NOT_SEEK);
 
        ref = heap_alloc_zero(sizeof(TLBRefType));
        list_add_tail(&pcx->pLibInfo->ref_list, &ref->entry);
 
        LIST_FOR_EACH_ENTRY(pImpLib, &pcx->pLibInfo->implib_list, TLBImpLib, entry)
            if(pImpLib->offset==impinfo.oImpFile)
                break;
 
        if(&pImpLib->entry != &pcx->pLibInfo->implib_list){
            ref->reference = offs;
            ref->pImpTLInfo = pImpLib;
            if(impinfo.flags & MSFT_IMPINFO_OFFSET_IS_GUID) {
                ref->guid = MSFT_ReadGuid(impinfo.oGuid, pcx);
                TRACE("importing by guid %s\n", debugstr_guid(TLB_get_guidref(ref->guid)));
                ref->index = TLB_REF_USE_GUID;
            } else
                ref->index = impinfo.oGuid;
        }else{
            ERR("Cannot find a reference\n");
            ref->reference = -1;
            ref->pImpTLInfo = TLB_REF_NOT_FOUND;
        }
 
        offs += sizeof(impinfo);
    }
 
    return S_OK;
}

Referenced by ITypeLib2_Constructor_MSFT().

MSFT_ReadAllStrings()

static HRESULT MSFT_ReadAllStrings ( TLBContext *  pcx )

static

Definition at line 2762 of file typelib.c.

{
    char *string;
    INT16 len_str, len_piece;
    int offs = 0, lengthInChars;
 
    MSFT_Seek(pcx, pcx->pTblDir->pStringtab.offset);
    while (1) {
        TLBString *tlbstr;
 
        if (offs >= pcx->pTblDir->pStringtab.length)
            return S_OK;
 
        MSFT_ReadLEWords(&len_str, sizeof(INT16), pcx, DO_NOT_SEEK);
        len_piece = len_str + sizeof(INT16);
        if(len_piece % 4)
            len_piece = (len_piece + 4) & ~0x3;
        if(len_piece < 8)
            len_piece = 8;
 
        string = heap_alloc(len_piece + 1);
        MSFT_Read(string, len_piece - sizeof(INT16), pcx, DO_NOT_SEEK);
        string[len_str] = '\0';
 
        lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
                                            string, -1, NULL, 0);
        if (!lengthInChars) {
            heap_free(string);
            return E_UNEXPECTED;
        }
 
        tlbstr = heap_alloc(sizeof(TLBString));
 
        tlbstr->offset = offs;
        tlbstr->str = SysAllocStringByteLen(NULL, lengthInChars * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, string, -1, tlbstr->str, lengthInChars);
 
        heap_free(string);
 
        list_add_tail(&pcx->pLibInfo->string_list, &tlbstr->entry);
 
        offs += len_piece;
    }
}

Referenced by ITypeLib2_Constructor_MSFT().

MSFT_ReadGuid()

static TLBGuid * MSFT_ReadGuid ( int  offset, TLBContext *  pcx  )

static

Definition at line 2105 of file typelib.c.

{
    TLBGuid *ret;
 
    LIST_FOR_EACH_ENTRY(ret, &pcx->pLibInfo->guid_list, TLBGuid, entry){
        if(ret->offset == offset){
            TRACE_(typelib)("%s\n", debugstr_guid(&ret->guid));
            return ret;
        }
    }
 
    return NULL;
}

Referenced by ITypeLib2_Constructor_MSFT(), MSFT_CustData(), MSFT_DoTypeInfo(), and MSFT_ReadAllRefs().

MSFT_ReadHreftype()

static HREFTYPE MSFT_ReadHreftype ( TLBContext *  pcx, int  offset  )

static

Definition at line 2119 of file typelib.c.

{
    MSFT_NameIntro niName;
 
    if (offset < 0)
    {
        ERR_(typelib)("bad offset %d\n", offset);
        return -1;
    }
 
    MSFT_ReadLEDWords(&niName, sizeof(niName), pcx,
              pcx->pTblDir->pNametab.offset+offset);
 
    return niName.hreftype;
}

Referenced by MSFT_DoTypeInfo().

MSFT_ReadLEDWords()

static DWORD MSFT_ReadLEDWords ( void *  buffer, DWORD  count, TLBContext *  pcx, LONG  where  )

static

Definition at line 2058 of file typelib.c.

{
  DWORD ret;
 
  ret = MSFT_Read(buffer, count, pcx, where);
  FromLEDWords(buffer, ret);
 
  return ret;
}

Referenced by ITypeLib2_Constructor_MSFT(), MSFT_CustData(), MSFT_DoFuncs(), MSFT_DoImplTypes(), MSFT_DoTypeInfo(), MSFT_DoVars(), MSFT_ReadAllRefs(), MSFT_ReadHreftype(), and MSFT_ReadValue().

MSFT_ReadLEWords()

static DWORD MSFT_ReadLEWords ( void *  buffer, DWORD  count, TLBContext *  pcx, LONG  where  )

static

Definition at line 2069 of file typelib.c.

{
  DWORD ret;
 
  ret = MSFT_Read(buffer, count, pcx, where);
  FromLEWords(buffer, ret);
 
  return ret;
}

Referenced by ITypeLib2_Constructor_MSFT(), MSFT_ReadAllGuids(), MSFT_ReadAllNames(), MSFT_ReadAllStrings(), and MSFT_ReadValue().

MSFT_ReadName()

static TLBString * MSFT_ReadName ( TLBContext *  pcx, int  offset  )

static

Definition at line 2182 of file typelib.c.

{
    TLBString *tlbstr;
 
    LIST_FOR_EACH_ENTRY(tlbstr, &pcx->pLibInfo->name_list, TLBString, entry) {
        if (tlbstr->offset == offset) {
            TRACE_(typelib)("%s\n", debugstr_w(tlbstr->str));
            return tlbstr;
        }
    }
 
    return NULL;
}

Referenced by ITypeLib2_Constructor_MSFT(), MSFT_DoFuncs(), MSFT_DoTypeInfo(), and MSFT_DoVars().

MSFT_ReadString()

static TLBString * MSFT_ReadString ( TLBContext *  pcx, int  offset  )

static

Definition at line 2196 of file typelib.c.

{
    TLBString *tlbstr;
 
    LIST_FOR_EACH_ENTRY(tlbstr, &pcx->pLibInfo->string_list, TLBString, entry) {
        if (tlbstr->offset == offset) {
            TRACE_(typelib)("%s\n", debugstr_w(tlbstr->str));
            return tlbstr;
        }
    }
 
    return NULL;
}

Referenced by ITypeLib2_Constructor_MSFT(), MSFT_DoFuncs(), MSFT_DoTypeInfo(), and MSFT_DoVars().

MSFT_ReadValue()

static void MSFT_ReadValue ( VARIANT *  pVar, int  offset, TLBContext *  pcx  )

static

Definition at line 2213 of file typelib.c.

{
    int size;
 
    TRACE_(typelib)("\n");
 
    if(offset <0) { /* data are packed in here */
        V_VT(pVar) = (offset & 0x7c000000 )>> 26;
        V_I4(pVar) = offset & 0x3ffffff;
        return;
    }
    MSFT_ReadLEWords(&(V_VT(pVar)), sizeof(VARTYPE), pcx,
                     pcx->pTblDir->pCustData.offset + offset );
    TRACE_(typelib)("Vartype = %x\n", V_VT(pVar));
    switch (V_VT(pVar)){
        case VT_EMPTY:  /* FIXME: is this right? */
        case VT_NULL:   /* FIXME: is this right? */
        case VT_I2  :   /* this should not happen */
        case VT_I4  :
        case VT_R4  :
        case VT_ERROR   :
        case VT_BOOL    :
        case VT_I1  :
        case VT_UI1 :
        case VT_UI2 :
        case VT_UI4 :
        case VT_INT :
        case VT_UINT    :
        case VT_VOID    : /* FIXME: is this right? */
        case VT_HRESULT :
            size=4; break;
        case VT_R8  :
        case VT_CY  :
        case VT_DATE    :
        case VT_I8  :
        case VT_UI8 :
        case VT_DECIMAL :  /* FIXME: is this right? */
        case VT_FILETIME :
            size=8;break;
            /* pointer types with known behaviour */
        case VT_BSTR    :{
            char * ptr;
            MSFT_ReadLEDWords(&size, sizeof(INT), pcx, DO_NOT_SEEK );
            if(size == -1){
                V_BSTR(pVar) = NULL;
            }else{
                ptr = heap_alloc_zero(size);
                MSFT_Read(ptr, size, pcx, DO_NOT_SEEK);
                V_BSTR(pVar)=SysAllocStringLen(NULL,size);
                /* FIXME: do we need a AtoW conversion here? */
                V_UNION(pVar, bstrVal[size])='\0';
                while(size--) V_UNION(pVar, bstrVal[size])=ptr[size];
                heap_free(ptr);
            }
    }
    size=-4; break;
    /* FIXME: this will not work AT ALL when the variant contains a pointer */
        case VT_DISPATCH :
        case VT_VARIANT :
        case VT_UNKNOWN :
        case VT_PTR :
        case VT_SAFEARRAY :
        case VT_CARRAY  :
        case VT_USERDEFINED :
        case VT_LPSTR   :
        case VT_LPWSTR  :
        case VT_BLOB    :
        case VT_STREAM  :
        case VT_STORAGE :
        case VT_STREAMED_OBJECT :
        case VT_STORED_OBJECT   :
        case VT_BLOB_OBJECT :
        case VT_CF  :
        case VT_CLSID   :
        default:
            size=0;
            FIXME("VARTYPE %d is not supported, setting pointer to NULL\n",
                V_VT(pVar));
    }
 
    if(size>0) /* (big|small) endian correct? */
        MSFT_Read(&(V_I2(pVar)), size, pcx, DO_NOT_SEEK );
    return;
}

Referenced by MSFT_CustData(), MSFT_DoFuncs(), and MSFT_DoVars().

MSFT_Seek()

static void MSFT_Seek ( TLBContext *  pcx, LONG  where  )

inlinestatic

Definition at line 2030 of file typelib.c.

{
    if (where != DO_NOT_SEEK)
    {
        where += pcx->oStart;
        if (where > pcx->length)
        {
            /* FIXME */
            ERR("seek beyond end (%d/%d)\n", where, pcx->length );
            TLB_abort();
        }
        pcx->pos = where;
    }
}

Referenced by MSFT_Read(), MSFT_ReadAllGuids(), MSFT_ReadAllNames(), MSFT_ReadAllRefs(), and MSFT_ReadAllStrings().

nefile_impl_from_IUnknown()

static TLB_NEFile * nefile_impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 2973 of file typelib.c.

{
    return CONTAINING_RECORD(iface, TLB_NEFile, IUnknown_iface);
}

Referenced by TLB_NEFile_AddRef(), and TLB_NEFile_Release().

pefile_impl_from_IUnknown()

static TLB_PEFile * pefile_impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 2873 of file typelib.c.

{
    return CONTAINING_RECORD(iface, TLB_PEFile, IUnknown_iface);
}

Referenced by TLB_PEFile_AddRef(), and TLB_PEFile_Release().

query_typelib_path()

static HRESULT query_typelib_path ( REFGUID  guid, WORD  wMaj, WORD  wMin, SYSKIND  syskind, LCID  lcid, BSTR *  path, BOOL  redir  )

static

Definition at line 301 of file typelib.c.

{
    HRESULT hr = TYPE_E_LIBNOTREGISTERED;
    LCID myLCID = lcid;
    HKEY hkey;
    WCHAR buffer[60];
    WCHAR Path[MAX_PATH];
    LONG res;
 
    TRACE_(typelib)("(%s, %x.%x, 0x%x, %p)\n", debugstr_guid(guid), wMaj, wMin, lcid, path);
 
    if (redir)
    {
        ACTCTX_SECTION_KEYED_DATA data;
 
        data.cbSize = sizeof(data);
        if (FindActCtxSectionGuid( 0, NULL, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION, guid, &data ))
        {
            struct tlibredirect_data *tlib = (struct tlibredirect_data*)data.lpData;
            WCHAR *nameW;
            DWORD len;
 
            if ((wMaj != 0xffff || wMin != 0xffff) && (tlib->major_version != wMaj || tlib->minor_version < wMin))
                return TYPE_E_LIBNOTREGISTERED;
 
            nameW = (WCHAR*)((BYTE*)data.lpSectionBase + tlib->name_offset);
            len = SearchPathW( NULL, nameW, NULL, ARRAY_SIZE( Path ), Path, NULL );
            if (!len) return TYPE_E_LIBNOTREGISTERED;
 
            TRACE_(typelib)("got path from context %s\n", debugstr_w(Path));
            *path = SysAllocString( Path );
            return S_OK;
        }
    }
 
    if (!find_typelib_key( guid, &wMaj, &wMin )) return TYPE_E_LIBNOTREGISTERED;
    get_typelib_key( guid, wMaj, wMin, buffer );
 
    res = RegOpenKeyExW( HKEY_CLASSES_ROOT, buffer, 0, KEY_READ, &hkey );
    if (res == ERROR_FILE_NOT_FOUND)
    {
        TRACE_(typelib)("%s not found\n", debugstr_w(buffer));
        return TYPE_E_LIBNOTREGISTERED;
    }
    else if (res != ERROR_SUCCESS)
    {
        TRACE_(typelib)("failed to open %s for read access\n", debugstr_w(buffer));
        return TYPE_E_REGISTRYACCESS;
    }
 
    while (hr != S_OK)
    {
        LONG dwPathLen = sizeof(Path);
 
        get_lcid_subkey( myLCID, syskind, buffer );
 
        if (RegQueryValueW(hkey, buffer, Path, &dwPathLen))
        {
            if (!lcid)
                break;
            else if (myLCID == lcid)
            {
                /* try with sub-langid */
                myLCID = SUBLANGID(lcid);
            }
            else if ((myLCID == SUBLANGID(lcid)) && myLCID)
            {
                /* try with system langid */
                myLCID = 0;
            }
            else
            {
                break;
            }
        }
        else
        {
            *path = SysAllocString( Path );
            hr = S_OK;
        }
    }
    RegCloseKey( hkey );
    TRACE_(typelib)("-- 0x%08x\n", hr);
    return hr;
}

Referenced by ITypeInfo_fnGetRefTypeInfo(), QueryPathOfRegTypeLib(), and UnRegisterTypeLib().

QueryPathOfRegTypeLib()

HRESULT WINAPI QueryPathOfRegTypeLib	(	REFGUID	guid,
		WORD	wMaj,
		WORD	wMin,
		LCID	lcid,
		LPBSTR	path
	)

Definition at line 406 of file typelib.c.

{
    BOOL redir = TRUE;
#ifdef _WIN64
    HRESULT hres = query_typelib_path( guid, wMaj, wMin, SYS_WIN64, lcid, path, TRUE );
    if(SUCCEEDED(hres))
        return hres;
    redir = FALSE;
#endif
    return query_typelib_path( guid, wMaj, wMin, SYS_WIN32, lcid, path, redir );
}

Referenced by ICreateTypeInfo2_fnAddRefTypeInfo(), LoadRegTypeLib(), test_LoadRegTypeLib(), and test_QueryPathOfRegTypeLib().

read_xx_header()

static int read_xx_header ( HFILE  lzfd )

static

Definition at line 3018 of file typelib.c.

{
    IMAGE_DOS_HEADER mzh;
    char magic[3];
 
    LZSeek( lzfd, 0, SEEK_SET );
    if ( sizeof(mzh) != LZRead( lzfd, (LPSTR)&mzh, sizeof(mzh) ) )
        return 0;
    if ( mzh.e_magic != IMAGE_DOS_SIGNATURE )
        return 0;
 
    LZSeek( lzfd, mzh.e_lfanew, SEEK_SET );
    if ( 2 != LZRead( lzfd, magic, 2 ) )
        return 0;
 
    LZSeek( lzfd, mzh.e_lfanew, SEEK_SET );
 
    if ( magic[0] == 'N' && magic[1] == 'E' )
        return IMAGE_OS2_SIGNATURE;
    if ( magic[0] == 'P' && magic[1] == 'E' )
        return IMAGE_NT_SIGNATURE;
 
    magic[2] = '\0';
    WARN("Can't handle %s files.\n", magic );
    return 0;
}

Referenced by TLB_NEFile_Open().

RegisterTypeLib()

HRESULT WINAPI RegisterTypeLib	(	ITypeLib *	ptlib,
		const WCHAR *	szFullPath,
		const WCHAR *	szHelpDir
	)

Definition at line 656 of file typelib.c.

{
    HRESULT res;
    TLIBATTR *attr;
    WCHAR keyName[60];
    WCHAR tmp[16];
    HKEY key, subKey;
    UINT types, tidx;
    TYPEKIND kind;
    DWORD disposition;
 
    if (ptlib == NULL || szFullPath == NULL)
        return E_INVALIDARG;
 
    if (FAILED(ITypeLib_GetLibAttr(ptlib, &attr)))
        return E_FAIL;
 
#ifndef _WIN64
    if (attr->syskind == SYS_WIN64) return TYPE_E_BADMODULEKIND;
#endif
 
    get_typelib_key( &attr->guid, attr->wMajorVerNum, attr->wMinorVerNum, keyName );
 
    res = S_OK;
    if (RegCreateKeyExW(HKEY_CLASSES_ROOT, keyName, 0, NULL, 0,
        KEY_WRITE, NULL, &key, NULL) == ERROR_SUCCESS)
    {
        LPOLESTR doc;
 
        /* Set the human-readable name of the typelib */
        if (FAILED(ITypeLib_GetDocumentation(ptlib, -1, NULL, &doc, NULL, NULL)))
            res = E_FAIL;
        else if (doc)
        {
            if (RegSetValueExW(key, NULL, 0, REG_SZ,
                (BYTE *)doc, (lstrlenW(doc)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS)
                res = E_FAIL;
 
            SysFreeString(doc);
        }
 
        /* Make up the name of the typelib path subkey */
        if (!get_lcid_subkey( attr->lcid, attr->syskind, tmp )) res = E_FAIL;
 
        /* Create the typelib path subkey */
        if (res == S_OK && RegCreateKeyExW(key, tmp, 0, NULL, 0,
            KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS)
        {
            if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
                (BYTE *)szFullPath, (lstrlenW(szFullPath)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS)
                res = E_FAIL;
 
            RegCloseKey(subKey);
        }
        else
            res = E_FAIL;
 
        /* Create the flags subkey */
        if (res == S_OK && RegCreateKeyExW(key, FLAGSW, 0, NULL, 0,
            KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS)
        {
            /* FIXME: is %u correct? */
            static const WCHAR formatW[] = {'%','u',0};
            WCHAR buf[20];
            swprintf(buf, formatW, attr->wLibFlags);
            if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
                               (BYTE *)buf, (lstrlenW(buf) + 1)*sizeof(WCHAR) ) != ERROR_SUCCESS)
                res = E_FAIL;
 
            RegCloseKey(subKey);
        }
        else
            res = E_FAIL;
 
        /* create the helpdir subkey */
        if (res == S_OK && RegCreateKeyExW(key, HELPDIRW, 0, NULL, 0,
            KEY_WRITE, NULL, &subKey, &disposition) == ERROR_SUCCESS)
        {
            BSTR freeHelpDir = NULL;
            OLECHAR* pIndexStr;
 
            /* if we created a new key, and helpDir was null, set the helpdir
               to the directory which contains the typelib. However,
               if we just opened an existing key, we leave the helpdir alone */
            if ((disposition == REG_CREATED_NEW_KEY) && (szHelpDir == NULL)) {
                szHelpDir = freeHelpDir = SysAllocString(szFullPath);
                pIndexStr = wcsrchr(szHelpDir, '\\');
                if (pIndexStr) {
                    *pIndexStr = 0;
                }
            }
 
            /* if we have an szHelpDir, set it! */
            if (szHelpDir != NULL) {
                if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
                    (BYTE *)szHelpDir, (lstrlenW(szHelpDir)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS) {
                    res = E_FAIL;
                }
            }
 
            SysFreeString(freeHelpDir);
            RegCloseKey(subKey);
        } else {
            res = E_FAIL;
        }
 
        RegCloseKey(key);
    }
    else
        res = E_FAIL;
 
    /* register OLE Automation-compatible interfaces for this typelib */
    types = ITypeLib_GetTypeInfoCount(ptlib);
    for (tidx=0; tidx<types; tidx++) {
    if (SUCCEEDED(ITypeLib_GetTypeInfoType(ptlib, tidx, &kind))) {
        LPOLESTR name = NULL;
        ITypeInfo *tinfo = NULL;
 
        ITypeLib_GetDocumentation(ptlib, tidx, &name, NULL, NULL, NULL);
 
        switch (kind) {
        case TKIND_INTERFACE:
        TRACE_(typelib)("%d: interface %s\n", tidx, debugstr_w(name));
        ITypeLib_GetTypeInfo(ptlib, tidx, &tinfo);
        break;
 
        case TKIND_DISPATCH:
        TRACE_(typelib)("%d: dispinterface %s\n", tidx, debugstr_w(name));
                ITypeLib_GetTypeInfo(ptlib, tidx, &tinfo);
        break;
 
        default:
        TRACE_(typelib)("%d: %s\n", tidx, debugstr_w(name));
        break;
        }
 
        if (tinfo) {
        TYPEATTR *tattr = NULL;
        ITypeInfo_GetTypeAttr(tinfo, &tattr);
 
        if (tattr) {
            TRACE_(typelib)("guid=%s, flags=%04x (",
                    debugstr_guid(&tattr->guid),
                    tattr->wTypeFlags);
 
            if (TRACE_ON(typelib)) {
#define XX(x) if (TYPEFLAG_##x & tattr->wTypeFlags) MESSAGE(#x"|");
            XX(FAPPOBJECT);
            XX(FCANCREATE);
            XX(FLICENSED);
            XX(FPREDECLID);
            XX(FHIDDEN);
            XX(FCONTROL);
            XX(FDUAL);
            XX(FNONEXTENSIBLE);
            XX(FOLEAUTOMATION);
            XX(FRESTRICTED);
            XX(FAGGREGATABLE);
            XX(FREPLACEABLE);
            XX(FDISPATCHABLE);
            XX(FREVERSEBIND);
            XX(FPROXY);
#undef XX
            MESSAGE("\n");
            }
 
                    /* Register all dispinterfaces (which includes dual interfaces) and
                       oleautomation interfaces */
            if ((kind == TKIND_INTERFACE && (tattr->wTypeFlags & TYPEFLAG_FOLEAUTOMATION)) ||
                        kind == TKIND_DISPATCH)
            {
                        BOOL is_wow64;
                        DWORD opposite = (sizeof(void*) == 8 ? KEY_WOW64_32KEY : KEY_WOW64_64KEY);
 
                        /* register interface<->typelib coupling */
                        TLB_register_interface(attr, name, tattr, 0);
 
                        /* register TLBs into the opposite registry view, too */
                        if(opposite == KEY_WOW64_32KEY ||
                                 (IsWow64Process(GetCurrentProcess(), &is_wow64) && is_wow64))
                            TLB_register_interface(attr, name, tattr, opposite);
            }
 
            ITypeInfo_ReleaseTypeAttr(tinfo, tattr);
        }
 
        ITypeInfo_Release(tinfo);
        }
 
        SysFreeString(name);
    }
    }
 
    ITypeLib_ReleaseTLibAttr(ptlib, attr);
 
    return res;
}

Referenced by AtlRegisterTypeLib(), ATL::AtlRegisterTypeLib(), ITERATE_RegisterTypeLibraries(), LoadTypeLibEx(), register_current_module_typelib(), RegisterTypeLibForUser(), test_register_typelib(), and test_stub().

RegisterTypeLibForUser()

HRESULT WINAPI RegisterTypeLibForUser	(	ITypeLib *	ptlib,
		OLECHAR *	szFullPath,
		OLECHAR *	szHelpDir
	)

Definition at line 1026 of file typelib.c.

{
    FIXME("(%p, %s, %s) registering the typelib system-wide\n", ptlib,
          debugstr_w(szFullPath), debugstr_w(szHelpDir));
    return RegisterTypeLib(ptlib, szFullPath, szHelpDir);
}

search_res_tlb()

static BOOL CALLBACK search_res_tlb ( HMODULE  hModule, LPCWSTR  lpszType, LPWSTR  lpszName, LONG_PTR  lParam  )

static

Definition at line 7971 of file typelib.c.

{
    struct search_res_tlb_params *params = (LPVOID)lParam;
    static const WCHAR formatW[] = {'\\','%','d',0};
    WCHAR szPath[MAX_PATH+1];
    ITypeLib *pTLib = NULL;
    HRESULT ret;
    DWORD len;
 
    if (IS_INTRESOURCE(lpszName) == FALSE)
        return TRUE;
 
    if (!(len = GetModuleFileNameW(hModule, szPath, MAX_PATH)))
        return TRUE;
 
    if (swprintf(szPath + len, formatW, LOWORD(lpszName)) < 0)
        return TRUE;
 
    ret = LoadTypeLibEx(szPath, REGKIND_NONE, &pTLib);
    if (SUCCEEDED(ret))
    {
        ITypeLibImpl *impl = impl_from_ITypeLib(pTLib);
        if (IsEqualGUID(params->guid, impl->guid))
        {
            params->pTLib = pTLib;
            return FALSE; /* stop enumeration */
        }
        ITypeLib_Release(pTLib);
    }
 
    return TRUE;
}

Referenced by ITypeInfo_fnGetRefTypeInfo().

SLTG_DoElem()

static WORD * SLTG_DoElem ( WORD *  pType, char *  pBlk, ELEMDESC *  pElem, const sltg_ref_lookup_t *  ref_lookup  )

static

Definition at line 3960 of file typelib.c.

{
    /* Handle [in/out] first */
    if((*pType & 0xc000) == 0xc000)
        pElem->u.paramdesc.wParamFlags = PARAMFLAG_NONE;
    else if(*pType & 0x8000)
        pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN | PARAMFLAG_FOUT;
    else if(*pType & 0x4000)
        pElem->u.paramdesc.wParamFlags = PARAMFLAG_FOUT;
    else
        pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN;
 
    if(*pType & 0x2000)
        pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FLCID;
 
    if(*pType & 0x80)
        pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FRETVAL;
 
    return SLTG_DoType(pType, pBlk, &pElem->tdesc, ref_lookup);
}

Referenced by SLTG_DoFuncs(), and SLTG_DoVars().

SLTG_DoFuncs()

static void SLTG_DoFuncs ( char *  pBlk, char *  pFirstItem, ITypeInfoImpl *  pTI, unsigned short  cFuncs, char *  pNameTable, const sltg_ref_lookup_t *  ref_lookup, const BYTE *  hlp_strings  )

static

Definition at line 4224 of file typelib.c.

{
    SLTG_Function *pFunc;
    unsigned short i;
    TLBFuncDesc *pFuncDesc;
 
    pTI->funcdescs = TLBFuncDesc_Alloc(cFuncs);
 
    pFuncDesc = pTI->funcdescs;
    for(pFunc = (SLTG_Function*)pFirstItem, i = 0; i < cFuncs && pFunc != (SLTG_Function*)0xFFFF;
    pFunc = (SLTG_Function*)(pBlk + pFunc->next), i++, ++pFuncDesc) {
 
        int param;
    WORD *pType, *pArg;
 
        switch (pFunc->magic & ~SLTG_FUNCTION_FLAGS_PRESENT) {
        case SLTG_FUNCTION_MAGIC:
            pFuncDesc->funcdesc.funckind = FUNC_PUREVIRTUAL;
            break;
        case SLTG_DISPATCH_FUNCTION_MAGIC:
            pFuncDesc->funcdesc.funckind = FUNC_DISPATCH;
            break;
        case SLTG_STATIC_FUNCTION_MAGIC:
            pFuncDesc->funcdesc.funckind = FUNC_STATIC;
            break;
        default:
        FIXME("unimplemented func magic = %02x\n", pFunc->magic & ~SLTG_FUNCTION_FLAGS_PRESENT);
        continue;
    }
    pFuncDesc->Name = SLTG_ReadName(pNameTable, pFunc->name, pTI->pTypeLib);
 
    pFuncDesc->funcdesc.memid = pFunc->dispid;
    pFuncDesc->funcdesc.invkind = pFunc->inv >> 4;
    pFuncDesc->funcdesc.callconv = pFunc->nacc & 0x7;
    pFuncDesc->funcdesc.cParams = pFunc->nacc >> 3;
    pFuncDesc->funcdesc.cParamsOpt = (pFunc->retnextopt & 0x7e) >> 1;
    pFuncDesc->funcdesc.oVft = (pFunc->vtblpos & ~1) * sizeof(void *) / pTI->pTypeLib->ptr_size;
        if (pFunc->helpstring != 0xffff)
            pFuncDesc->HelpString = decode_string(hlp_strings, pBlk + pFunc->helpstring, pNameTable - pBlk, pTI->pTypeLib);
 
    if(pFunc->magic & SLTG_FUNCTION_FLAGS_PRESENT)
        pFuncDesc->funcdesc.wFuncFlags = pFunc->funcflags;
 
    if(pFunc->retnextopt & 0x80)
        pType = &pFunc->rettype;
    else
        pType = (WORD*)(pBlk + pFunc->rettype);
 
    SLTG_DoElem(pType, pBlk, &pFuncDesc->funcdesc.elemdescFunc, ref_lookup);
 
    pFuncDesc->funcdesc.lprgelemdescParam =
      heap_alloc_zero(pFuncDesc->funcdesc.cParams * sizeof(ELEMDESC));
    pFuncDesc->pParamDesc = TLBParDesc_Constructor(pFuncDesc->funcdesc.cParams);
 
    pArg = (WORD*)(pBlk + pFunc->arg_off);
 
    for(param = 0; param < pFuncDesc->funcdesc.cParams; param++) {
        char *paramName = pNameTable + (*pArg & ~1);
        BOOL HaveOffs;
        /* If arg type follows then paramName points to the 2nd
           letter of the name, else the next WORD is an offset to
           the arg type and paramName points to the first letter.
           So let's take one char off paramName and see if we're
           pointing at an alpha-numeric char.  However if *pArg is
           0xffff or 0xfffe then the param has no name, the former
           meaning that the next WORD is the type, the latter
           meaning that the next WORD is an offset to the type. */
 
        if(*pArg == 0xffff || *pArg == 0xfffe)
            paramName = NULL;
 
        HaveOffs = !(*pArg & 1);
        pArg++;
 
            TRACE_(typelib)("param %d: paramName %s, *pArg %#x\n",
                param, debugstr_a(paramName), *pArg);
 
        if(HaveOffs) { /* the next word is an offset to type */
            pType = (WORD*)(pBlk + *pArg);
        SLTG_DoElem(pType, pBlk,
                &pFuncDesc->funcdesc.lprgelemdescParam[param], ref_lookup);
        pArg++;
        } else {
        pArg = SLTG_DoElem(pArg, pBlk,
                                   &pFuncDesc->funcdesc.lprgelemdescParam[param], ref_lookup);
        }
 
        /* Are we an optional param ? */
        if(pFuncDesc->funcdesc.cParams - param <=
           pFuncDesc->funcdesc.cParamsOpt)
          pFuncDesc->funcdesc.lprgelemdescParam[param].u.paramdesc.wParamFlags |= PARAMFLAG_FOPT;
 
        if(paramName) {
            pFuncDesc->pParamDesc[param].Name = SLTG_ReadName(pNameTable,
                    paramName - pNameTable, pTI->pTypeLib);
        } else {
            pFuncDesc->pParamDesc[param].Name = pFuncDesc->Name;
        }
    }
    }
    pTI->typeattr.cFuncs = cFuncs;
}

Referenced by SLTG_ProcessDispatch(), SLTG_ProcessInterface(), and SLTG_ProcessModule().

SLTG_DoImpls()

static char * SLTG_DoImpls ( char *  pBlk, ITypeInfoImpl *  pTI, BOOL  OneOnly, const sltg_ref_lookup_t *  ref_lookup  )

static

Definition at line 4069 of file typelib.c.

{
    SLTG_ImplInfo *info;
    TLBImplType *pImplType;
    /* I don't really get this structure, usually it's 0x16 bytes
       long, but iuser.tlb contains some that are 0x18 bytes long.
       That's ok because we can use the next ptr to jump to the next
       one. But how do we know the length of the last one?  The WORD
       at offs 0x8 might be the clue.  For now I'm just assuming that
       the last one is the regular 0x16 bytes. */
 
    info = (SLTG_ImplInfo*)pBlk;
    while(1){
        pTI->typeattr.cImplTypes++;
        if(info->next == 0xffff)
            break;
        info = (SLTG_ImplInfo*)(pBlk + info->next);
    }
 
    info = (SLTG_ImplInfo*)pBlk;
    pTI->impltypes = TLBImplType_Alloc(pTI->typeattr.cImplTypes);
    pImplType = pTI->impltypes;
    while(1) {
    sltg_get_typelib_ref(ref_lookup, info->ref, &pImplType->hRef);
    pImplType->implflags = info->impltypeflags;
    ++pImplType;
 
    if(info->next == 0xffff)
        break;
    if(OneOnly)
        FIXME_(typelib)("Interface inheriting more than one interface\n");
    info = (SLTG_ImplInfo*)(pBlk + info->next);
    }
    info++; /* see comment at top of function */
    return (char*)info;
}

Referenced by SLTG_ProcessCoClass(), SLTG_ProcessDispatch(), and SLTG_ProcessInterface().

SLTG_DoRefs()

static sltg_ref_lookup_t * SLTG_DoRefs ( SLTG_RefInfo *  pRef, ITypeLibImpl *  pTL, char *  pNameTable  )

static

Definition at line 3983 of file typelib.c.

{
    unsigned int ref;
    char *name;
    TLBRefType *ref_type;
    sltg_ref_lookup_t *table;
    HREFTYPE typelib_ref;
 
    if(pRef->magic != SLTG_REF_MAGIC) {
        FIXME("Ref magic = %x\n", pRef->magic);
    return NULL;
    }
    name = ( (char*)pRef->names + pRef->number);
 
    table = heap_alloc(sizeof(*table) + ((pRef->number >> 3) - 1) * sizeof(table->refs[0]));
    table->num = pRef->number >> 3;
 
    /* FIXME should scan the existing list and reuse matching refs added by previous typeinfos */
 
    /* We don't want the first href to be 0 */
    typelib_ref = (list_count(&pTL->ref_list) + 1) << 2;
 
    for(ref = 0; ref < pRef->number >> 3; ref++) {
        char *refname;
    unsigned int lib_offs, type_num;
 
    ref_type = heap_alloc_zero(sizeof(TLBRefType));
 
    name += SLTG_ReadStringA(name, &refname);
    if(sscanf(refname, "*\\R%x*#%x", &lib_offs, &type_num) != 2)
        FIXME_(typelib)("Can't sscanf ref\n");
    if(lib_offs != 0xffff) {
        TLBImpLib *import;
 
            LIST_FOR_EACH_ENTRY(import, &pTL->implib_list, TLBImpLib, entry)
                if(import->offset == lib_offs)
                    break;
 
            if(&import->entry == &pTL->implib_list) {
            char fname[MAX_PATH+1];
        int len;
                GUID tmpguid;
 
        import = heap_alloc_zero(sizeof(*import));
        import->offset = lib_offs;
        TLB_GUIDFromString( pNameTable + lib_offs + 4, &tmpguid);
                import->guid = TLB_append_guid(&pTL->guid_list, &tmpguid, 2);
        if(sscanf(pNameTable + lib_offs + 40, "}#%hd.%hd#%x#%s",
              &import->wVersionMajor,
              &import->wVersionMinor,
              &import->lcid, fname) != 4) {
          FIXME_(typelib)("can't sscanf ref %s\n",
            pNameTable + lib_offs + 40);
        }
        len = strlen(fname);
        if(fname[len-1] != '#')
            FIXME("fname = %s\n", fname);
        fname[len-1] = '\0';
        import->name = TLB_MultiByteToBSTR(fname);
        list_add_tail(&pTL->implib_list, &import->entry);
        }
        ref_type->pImpTLInfo = import;
 
            /* Store a reference to IDispatch */
            if(pTL->dispatch_href == -1 && IsEqualGUID(&import->guid->guid, &IID_StdOle) && type_num == 4)
                pTL->dispatch_href = typelib_ref;
 
    } else { /* internal ref */
      ref_type->pImpTLInfo = TLB_REF_INTERNAL;
    }
    ref_type->reference = typelib_ref;
    ref_type->index = type_num;
 
    heap_free(refname);
        list_add_tail(&pTL->ref_list, &ref_type->entry);
 
        table->refs[ref] = typelib_ref;
        typelib_ref += 4;
    }
    if((BYTE)*name != SLTG_REF_MAGIC)
      FIXME_(typelib)("End of ref block magic = %x\n", *name);
    dump_TLBRefType(pTL);
    return table;
}

Referenced by SLTG_ProcessAlias(), SLTG_ProcessCoClass(), SLTG_ProcessDispatch(), SLTG_ProcessInterface(), and SLTG_ProcessModule().

SLTG_DoType()

static WORD * SLTG_DoType ( WORD *  pType, char *  pBlk, TYPEDESC *  pTD, const sltg_ref_lookup_t *  ref_lookup  )

static

Definition at line 3899 of file typelib.c.

{
    BOOL done = FALSE;
 
    while(!done) {
        if((*pType & 0xe00) == 0xe00) {
        pTD->vt = VT_PTR;
        pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
        pTD = pTD->u.lptdesc;
    }
    switch(*pType & 0x3f) {
    case VT_PTR:
        pTD->vt = VT_PTR;
        pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
        pTD = pTD->u.lptdesc;
        break;
 
    case VT_USERDEFINED:
        pTD->vt = VT_USERDEFINED;
            sltg_get_typelib_ref(ref_lookup, *(++pType) / 4, &pTD->u.hreftype);
        done = TRUE;
        break;
 
    case VT_CARRAY:
      {
        /* *(pType+1) is offset to a SAFEARRAY, *(pType+2) is type of
           array */
 
        SAFEARRAY *pSA = (SAFEARRAY *)(pBlk + *(++pType));
 
        pTD->vt = VT_CARRAY;
        pTD->u.lpadesc = heap_alloc_zero(sizeof(ARRAYDESC) + (pSA->cDims - 1) * sizeof(SAFEARRAYBOUND));
        pTD->u.lpadesc->cDims = pSA->cDims;
        memcpy(pTD->u.lpadesc->rgbounds, pSA->rgsabound,
           pSA->cDims * sizeof(SAFEARRAYBOUND));
 
        pTD = &pTD->u.lpadesc->tdescElem;
        break;
      }
 
    case VT_SAFEARRAY:
      {
        /* FIXME: *(pType+1) gives an offset to SAFEARRAY, is this
           useful? */
 
        pType++;
        pTD->vt = VT_SAFEARRAY;
        pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
        pTD = pTD->u.lptdesc;
        break;
      }
    default:
        pTD->vt = *pType & 0x3f;
        done = TRUE;
        break;
    }
    pType++;
    }
    return pType;
}

Referenced by SLTG_DoElem(), and SLTG_ProcessAlias().

SLTG_DoVars()

static void SLTG_DoVars ( char *  pBlk, char *  pFirstItem, ITypeInfoImpl *  pTI, unsigned short  cVars, const char *  pNameTable, const sltg_ref_lookup_t *  ref_lookup, const BYTE *  hlp_strings  )

static

Definition at line 4107 of file typelib.c.

{
  TLBVarDesc *pVarDesc;
  const TLBString *prevName = NULL;
  SLTG_Variable *pItem;
  unsigned short i;
  WORD *pType;
 
  pVarDesc = pTI->vardescs = TLBVarDesc_Alloc(cVars);
 
  for(pItem = (SLTG_Variable *)pFirstItem, i = 0; i < cVars;
      pItem = (SLTG_Variable *)(pBlk + pItem->next), i++, ++pVarDesc) {
 
      pVarDesc->vardesc.memid = pItem->memid;
 
      if (pItem->magic != SLTG_VAR_MAGIC &&
          pItem->magic != SLTG_VAR_WITH_FLAGS_MAGIC) {
      FIXME_(typelib)("var magic = %02x\n", pItem->magic);
      return;
      }
 
      if (pItem->name == 0xfffe)
        pVarDesc->Name = prevName;
      else
        pVarDesc->Name = SLTG_ReadName(pNameTable, pItem->name, pTI->pTypeLib);
 
      TRACE_(typelib)("name: %s\n", debugstr_w(TLB_get_bstr(pVarDesc->Name)));
      TRACE_(typelib)("byte_offs = 0x%x\n", pItem->byte_offs);
      TRACE_(typelib)("memid = 0x%x\n", pItem->memid);
 
      if (pItem->helpstring != 0xffff)
      {
          pVarDesc->HelpString = decode_string(hlp_strings, pBlk + pItem->helpstring, pNameTable - pBlk, pTI->pTypeLib);
          TRACE_(typelib)("helpstring = %s\n", debugstr_w(pVarDesc->HelpString->str));
      }
 
      if(pItem->flags & 0x02)
      pType = &pItem->type;
      else
      pType = (WORD*)(pBlk + pItem->type);
 
      if (pItem->flags & ~0xda)
        FIXME_(typelib)("unhandled flags = %02x\n", pItem->flags & ~0xda);
 
      SLTG_DoElem(pType, pBlk,
          &pVarDesc->vardesc.elemdescVar, ref_lookup);
 
      if (TRACE_ON(typelib)) {
          char buf[300];
          dump_TypeDesc(&pVarDesc->vardesc.elemdescVar.tdesc, buf);
          TRACE_(typelib)("elemdescVar: %s\n", buf);
      }
 
      if (pItem->flags & 0x40) {
        TRACE_(typelib)("VAR_DISPATCH\n");
        pVarDesc->vardesc.varkind = VAR_DISPATCH;
      }
      else if (pItem->flags & 0x10) {
        TRACE_(typelib)("VAR_CONST\n");
        pVarDesc->vardesc.varkind = VAR_CONST;
        pVarDesc->vardesc.u.lpvarValue = heap_alloc(sizeof(VARIANT));
        V_VT(pVarDesc->vardesc.u.lpvarValue) = VT_INT;
        if (pItem->flags & 0x08)
          V_INT(pVarDesc->vardesc.u.lpvarValue) = pItem->byte_offs;
        else {
          switch (pVarDesc->vardesc.elemdescVar.tdesc.vt)
          {
            case VT_LPSTR:
            case VT_LPWSTR:
            case VT_BSTR:
            {
              WORD len = *(WORD *)(pBlk + pItem->byte_offs);
              BSTR str;
              TRACE_(typelib)("len = %u\n", len);
              if (len == 0xffff) {
                str = NULL;
              } else {
                INT alloc_len = MultiByteToWideChar(CP_ACP, 0, pBlk + pItem->byte_offs + 2, len, NULL, 0);
                str = SysAllocStringLen(NULL, alloc_len);
                MultiByteToWideChar(CP_ACP, 0, pBlk + pItem->byte_offs + 2, len, str, alloc_len);
              }
              V_VT(pVarDesc->vardesc.u.lpvarValue) = VT_BSTR;
              V_BSTR(pVarDesc->vardesc.u.lpvarValue) = str;
              break;
            }
            case VT_I2:
            case VT_UI2:
            case VT_I4:
            case VT_UI4:
            case VT_INT:
            case VT_UINT:
              V_INT(pVarDesc->vardesc.u.lpvarValue) =
                *(INT*)(pBlk + pItem->byte_offs);
              break;
            default:
              FIXME_(typelib)("VAR_CONST unimplemented for type %d\n", pVarDesc->vardesc.elemdescVar.tdesc.vt);
          }
        }
      }
      else {
        TRACE_(typelib)("VAR_PERINSTANCE\n");
        pVarDesc->vardesc.u.oInst = pItem->byte_offs;
        pVarDesc->vardesc.varkind = VAR_PERINSTANCE;
      }
 
      if (pItem->magic == SLTG_VAR_WITH_FLAGS_MAGIC)
        pVarDesc->vardesc.wVarFlags = pItem->varflags;
 
      if (pItem->flags & 0x80)
        pVarDesc->vardesc.wVarFlags |= VARFLAG_FREADONLY;
 
      prevName = pVarDesc->Name;
  }
  pTI->typeattr.cVars = cVars;
}

Referenced by SLTG_ProcessDispatch(), SLTG_ProcessEnum(), SLTG_ProcessModule(), and SLTG_ProcessRecord().

sltg_get_typelib_ref()

static HRESULT sltg_get_typelib_ref ( const sltg_ref_lookup_t *  table, DWORD  typeinfo_ref, HREFTYPE *  typelib_ref  )

static

Definition at line 3885 of file typelib.c.

{
    if(table && typeinfo_ref < table->num)
    {
        *typelib_ref = table->refs[typeinfo_ref];
        return S_OK;
    }
 
    ERR_(typelib)("Unable to find reference\n");
    *typelib_ref = -1;
    return E_FAIL;
}

Referenced by SLTG_DoImpls(), and SLTG_DoType().

SLTG_ProcessAlias()

static void SLTG_ProcessAlias ( char *  pBlk, ITypeInfoImpl *  pTI, char *  pNameTable, SLTG_TypeInfoHeader *  pTIHeader, const SLTG_TypeInfoTail *  pTITail  )

static

Definition at line 4384 of file typelib.c.

{
  WORD *pType;
  sltg_ref_lookup_t *ref_lookup = NULL;
 
  if (pTITail->simple_alias) {
      /* if simple alias, no more processing required */
      pTI->tdescAlias = heap_alloc_zero(sizeof(TYPEDESC));
      pTI->tdescAlias->vt = pTITail->tdescalias_vt;
      return;
  }
 
  if(pTIHeader->href_table != 0xffffffff) {
      ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
          pNameTable);
  }
 
  /* otherwise it is an offset to a type */
  pType = (WORD *)(pBlk + pTITail->tdescalias_vt);
 
  pTI->tdescAlias = heap_alloc(sizeof(TYPEDESC));
  SLTG_DoType(pType, pBlk, pTI->tdescAlias, ref_lookup);
 
  heap_free(ref_lookup);
}

Referenced by ITypeLib2_Constructor_SLTG().

SLTG_ProcessCoClass()

static void SLTG_ProcessCoClass ( char *  pBlk, ITypeInfoImpl *  pTI, char *  pNameTable, SLTG_TypeInfoHeader *  pTIHeader, SLTG_TypeInfoTail *  pTITail  )

static

Definition at line 4329 of file typelib.c.

{
    char *pFirstItem;
    sltg_ref_lookup_t *ref_lookup = NULL;
 
    if(pTIHeader->href_table != 0xffffffff) {
        ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
            pNameTable);
    }
 
    pFirstItem = pBlk;
 
    if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
        SLTG_DoImpls(pFirstItem, pTI, FALSE, ref_lookup);
    }
    heap_free(ref_lookup);
}

Referenced by ITypeLib2_Constructor_SLTG().

SLTG_ProcessDispatch()

static void SLTG_ProcessDispatch ( char *  pBlk, ITypeInfoImpl *  pTI, char *  pNameTable, SLTG_TypeInfoHeader *  pTIHeader, const SLTG_TypeInfoTail *  pTITail, const BYTE *  hlp_strings  )

static

Definition at line 4412 of file typelib.c.

{
  sltg_ref_lookup_t *ref_lookup = NULL;
  if (pTIHeader->href_table != 0xffffffff)
      ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
                                  pNameTable);
 
  if (pTITail->vars_off != 0xffff)
    SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup, hlp_strings);
 
  if (pTITail->funcs_off != 0xffff)
    SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup, hlp_strings);
 
  if (pTITail->impls_off != 0xffff)
    SLTG_DoImpls(pBlk + pTITail->impls_off, pTI, FALSE, ref_lookup);
 
  /* this is necessary to cope with MSFT typelibs that set cFuncs to the number
   * of dispinterface functions including the IDispatch ones, so
   * ITypeInfo::GetFuncDesc takes the real value for cFuncs from cbSizeVft */
  pTI->typeattr.cbSizeVft = pTI->typeattr.cFuncs * pTI->pTypeLib->ptr_size;
 
  heap_free(ref_lookup);
  if (TRACE_ON(typelib))
      dump_TLBFuncDesc(pTI->funcdescs, pTI->typeattr.cFuncs);
}

Referenced by ITypeLib2_Constructor_SLTG().

SLTG_ProcessEnum()

static void SLTG_ProcessEnum ( char *  pBlk, ITypeInfoImpl *  pTI, const char *  pNameTable, SLTG_TypeInfoHeader *  pTIHeader, const SLTG_TypeInfoTail *  pTITail, const BYTE *  hlp_strings  )

static

Definition at line 4440 of file typelib.c.

{
  SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL, hlp_strings);
}

Referenced by ITypeLib2_Constructor_SLTG().

SLTG_ProcessInterface()

static void SLTG_ProcessInterface ( char *  pBlk, ITypeInfoImpl *  pTI, char *  pNameTable, SLTG_TypeInfoHeader *  pTIHeader, const SLTG_TypeInfoTail *  pTITail, const BYTE *  hlp_strings  )

static

Definition at line 4350 of file typelib.c.

{
    char *pFirstItem;
    sltg_ref_lookup_t *ref_lookup = NULL;
 
    if(pTIHeader->href_table != 0xffffffff) {
        ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
            pNameTable);
    }
 
    pFirstItem = pBlk;
 
    if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
        SLTG_DoImpls(pFirstItem, pTI, TRUE, ref_lookup);
    }
 
    if (pTITail->funcs_off != 0xffff)
        SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup, hlp_strings);
 
    heap_free(ref_lookup);
 
    if (TRACE_ON(typelib))
        dump_TLBFuncDesc(pTI->funcdescs, pTI->typeattr.cFuncs);
}

Referenced by ITypeLib2_Constructor_SLTG().

SLTG_ProcessModule()

static void SLTG_ProcessModule ( char *  pBlk, ITypeInfoImpl *  pTI, char *  pNameTable, SLTG_TypeInfoHeader *  pTIHeader, const SLTG_TypeInfoTail *  pTITail, const BYTE *  hlp_strings  )

static

Definition at line 4447 of file typelib.c.

{
  sltg_ref_lookup_t *ref_lookup = NULL;
  if (pTIHeader->href_table != 0xffffffff)
      ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
                                  pNameTable);
 
  if (pTITail->vars_off != 0xffff)
    SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup, hlp_strings);
 
  if (pTITail->funcs_off != 0xffff)
    SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup, hlp_strings);
  heap_free(ref_lookup);
  if (TRACE_ON(typelib))
    dump_TypeInfo(pTI);
}

Referenced by ITypeLib2_Constructor_SLTG().

SLTG_ProcessRecord()

static void SLTG_ProcessRecord ( char *  pBlk, ITypeInfoImpl *  pTI, const char *  pNameTable, SLTG_TypeInfoHeader *  pTIHeader, const SLTG_TypeInfoTail *  pTITail, const BYTE *  hlp_strings  )

static

Definition at line 4377 of file typelib.c.

{
  SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL, hlp_strings);
}

Referenced by ITypeLib2_Constructor_SLTG().

SLTG_ReadLibBlk()

static DWORD SLTG_ReadLibBlk ( LPVOID  pLibBlk, ITypeLibImpl *  pTypeLibImpl  )

static

Definition at line 3827 of file typelib.c.

{
    char *ptr = pLibBlk;
    WORD w;
 
    if((w = *(WORD*)ptr) != SLTG_LIBBLK_MAGIC) {
        FIXME("libblk magic = %04x\n", w);
    return 0;
    }
 
    ptr += 6;
    if((w = *(WORD*)ptr) != 0xffff) {
        FIXME("LibBlk.res06 = %04x. Assumung string and skipping\n", w);
        ptr += w;
    }
    ptr += 2;
 
    ptr += SLTG_ReadString(ptr, &pTypeLibImpl->DocString, pTypeLibImpl);
 
    ptr += SLTG_ReadString(ptr, &pTypeLibImpl->HelpFile, pTypeLibImpl);
 
    pTypeLibImpl->dwHelpContext = *(DWORD*)ptr;
    ptr += 4;
 
    pTypeLibImpl->syskind = *(WORD*)ptr;
    pTypeLibImpl->ptr_size = get_ptr_size(pTypeLibImpl->syskind);
    ptr += 2;
 
    if(SUBLANGID(*(WORD*)ptr) == SUBLANG_NEUTRAL)
        pTypeLibImpl->lcid = pTypeLibImpl->set_lcid = MAKELCID(MAKELANGID(PRIMARYLANGID(*(WORD*)ptr),0),0);
    else
        pTypeLibImpl->lcid = pTypeLibImpl->set_lcid = 0;
    ptr += 2;
 
    ptr += 4; /* skip res12 */
 
    pTypeLibImpl->libflags = *(WORD*)ptr;
    ptr += 2;
 
    pTypeLibImpl->ver_major = *(WORD*)ptr;
    ptr += 2;
 
    pTypeLibImpl->ver_minor = *(WORD*)ptr;
    ptr += 2;
 
    pTypeLibImpl->guid = TLB_append_guid(&pTypeLibImpl->guid_list, (GUID*)ptr, -2);
    ptr += sizeof(GUID);
 
    return ptr - (char*)pLibBlk;
}

Referenced by ITypeLib2_Constructor_SLTG().

SLTG_ReadName()

static TLBString * SLTG_ReadName ( const char *  pNameTable, int  offset, ITypeLibImpl *  lib  )

static

Definition at line 3810 of file typelib.c.

{
    BSTR tmp_str;
    TLBString *tlbstr;
 
    LIST_FOR_EACH_ENTRY(tlbstr, &lib->name_list, TLBString, entry) {
        if (tlbstr->offset == offset)
            return tlbstr;
    }
 
    tmp_str = TLB_MultiByteToBSTR(pNameTable + offset);
    tlbstr = TLB_append_str(&lib->name_list, tmp_str);
    SysFreeString(tmp_str);
 
    return tlbstr;
}

Referenced by ITypeLib2_Constructor_SLTG(), SLTG_DoFuncs(), and SLTG_DoVars().

SLTG_ReadString()

static WORD SLTG_ReadString ( const char *  ptr, const TLBString **  pStr, ITypeLibImpl *  lib  )

static

Definition at line 3777 of file typelib.c.

{
    WORD bytelen;
    DWORD len;
    BSTR tmp_str;
 
    *pStr = NULL;
    bytelen = *(const WORD*)ptr;
    if(bytelen == 0xffff) return 2;
 
    len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, NULL, 0);
    tmp_str = SysAllocStringLen(NULL, len);
    if (tmp_str) {
        MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, tmp_str, len);
        *pStr = TLB_append_str(&lib->string_list, tmp_str);
        SysFreeString(tmp_str);
    }
    return bytelen + 2;
}

Referenced by SLTG_ReadLibBlk().

SLTG_ReadStringA()

static WORD SLTG_ReadStringA ( const char *  ptr, char **  str  )

static

Definition at line 3797 of file typelib.c.

{
    WORD bytelen;
 
    *str = NULL;
    bytelen = *(const WORD*)ptr;
    if(bytelen == 0xffff) return 2;
    *str = heap_alloc(bytelen + 1);
    memcpy(*str, ptr + 2, bytelen);
    (*str)[bytelen] = '\0';
    return bytelen + 2;
}

Referenced by SLTG_DoRefs().

TLB_abort()

static void TLB_abort ( void  )

static

Definition at line 1612 of file typelib.c.

{
    DebugBreak();
}

Referenced by MSFT_Seek().

TLB_AllocAndInitFuncDesc()

static HRESULT TLB_AllocAndInitFuncDesc ( const FUNCDESC *  src, FUNCDESC **  dest_ptr, BOOL  dispinterface  )

static

Definition at line 5871 of file typelib.c.

{
    FUNCDESC *dest;
    char *buffer;
    SIZE_T size = sizeof(*src);
    SHORT i;
    HRESULT hr;
 
    size += sizeof(*src->lprgscode) * src->cScodes;
    size += TLB_SizeElemDesc(&src->elemdescFunc);
    for (i = 0; i < src->cParams; i++)
    {
        size += sizeof(ELEMDESC);
        size += TLB_SizeElemDesc(&src->lprgelemdescParam[i]);
    }
 
    dest = (FUNCDESC *)SysAllocStringByteLen(NULL, size);
    if (!dest) return E_OUTOFMEMORY;
 
    *dest = *src;
    if (dispinterface)    /* overwrite funckind */
        dest->funckind = FUNC_DISPATCH;
    buffer = (char *)(dest + 1);
 
    dest->oVft = dest->oVft & 0xFFFC;
 
    if (dest->cScodes) {
        dest->lprgscode = (SCODE *)buffer;
        memcpy(dest->lprgscode, src->lprgscode, sizeof(*src->lprgscode) * src->cScodes);
        buffer += sizeof(*src->lprgscode) * src->cScodes;
    } else
        dest->lprgscode = NULL;
 
    hr = TLB_CopyElemDesc(&src->elemdescFunc, &dest->elemdescFunc, &buffer);
    if (FAILED(hr))
    {
        SysFreeString((BSTR)dest);
        return hr;
    }
 
    if (dest->cParams) {
        dest->lprgelemdescParam = (ELEMDESC *)buffer;
        buffer += sizeof(ELEMDESC) * src->cParams;
        for (i = 0; i < src->cParams; i++)
        {
            hr = TLB_CopyElemDesc(&src->lprgelemdescParam[i], &dest->lprgelemdescParam[i], &buffer);
            if (FAILED(hr))
                break;
        }
        if (FAILED(hr))
        {
            /* undo the above actions */
            for (i = i - 1; i >= 0; i--)
                TLB_FreeElemDesc(&dest->lprgelemdescParam[i]);
            TLB_FreeElemDesc(&dest->elemdescFunc);
            SysFreeString((BSTR)dest);
            return hr;
        }
    } else
        dest->lprgelemdescParam = NULL;
 
    /* special treatment for dispinterfaces: this makes functions appear
     * to return their [retval] value when it is really returning an
     * HRESULT */
    if (dispinterface && dest->elemdescFunc.tdesc.vt == VT_HRESULT)
    {
        if (dest->cParams &&
            (dest->lprgelemdescParam[dest->cParams - 1].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
        {
            ELEMDESC *elemdesc = &dest->lprgelemdescParam[dest->cParams - 1];
            if (elemdesc->tdesc.vt != VT_PTR)
            {
                ERR("elemdesc should have started with VT_PTR instead of:\n");
                if (ERR_ON(ole))
                    dump_ELEMDESC(elemdesc);
                return E_UNEXPECTED;
            }
 
            /* copy last parameter to the return value. we are using a flat
             * buffer so there is no danger of leaking memory in
             * elemdescFunc */
            dest->elemdescFunc.tdesc = *elemdesc->tdesc.u.lptdesc;
 
            /* remove the last parameter */
            dest->cParams--;
        }
        else
            /* otherwise this function is made to appear to have no return
             * value */
            dest->elemdescFunc.tdesc.vt = VT_VOID;
 
    }
 
    *dest_ptr = dest;
    return S_OK;
}

Referenced by ITypeComp_fnBind(), and ITypeInfo_fnGetFuncDesc().

TLB_AllocAndInitVarDesc()

static HRESULT TLB_AllocAndInitVarDesc ( const VARDESC *  src, VARDESC **  dest_ptr  )

static

Definition at line 6110 of file typelib.c.

{
    VARDESC *dest;
    char *buffer;
    SIZE_T size = sizeof(*src);
    HRESULT hr;
 
    if (src->lpstrSchema) size += (lstrlenW(src->lpstrSchema) + 1) * sizeof(WCHAR);
    if (src->varkind == VAR_CONST)
        size += sizeof(VARIANT);
    size += TLB_SizeElemDesc(&src->elemdescVar);
 
    dest = (VARDESC *)SysAllocStringByteLen(NULL, size);
    if (!dest) return E_OUTOFMEMORY;
 
    *dest = *src;
    buffer = (char *)(dest + 1);
    if (src->lpstrSchema)
    {
        int len;
        dest->lpstrSchema = (LPOLESTR)buffer;
        len = lstrlenW(src->lpstrSchema);
        memcpy(dest->lpstrSchema, src->lpstrSchema, (len + 1) * sizeof(WCHAR));
        buffer += (len + 1) * sizeof(WCHAR);
    }
 
    if (src->varkind == VAR_CONST)
    {
        HRESULT hr;
 
        dest->u.lpvarValue = (VARIANT *)buffer;
        *dest->u.lpvarValue = *src->u.lpvarValue;
        buffer += sizeof(VARIANT);
        VariantInit(dest->u.lpvarValue);
        hr = VariantCopy(dest->u.lpvarValue, src->u.lpvarValue);
        if (FAILED(hr))
        {
            SysFreeString((BSTR)dest);
            return hr;
        }
    }
    hr = TLB_CopyElemDesc(&src->elemdescVar, &dest->elemdescVar, &buffer);
    if (FAILED(hr))
    {
        if (src->varkind == VAR_CONST)
            VariantClear(dest->u.lpvarValue);
        SysFreeString((BSTR)dest);
        return hr;
    }
    *dest_ptr = dest;
    return S_OK;
}

Referenced by ICreateTypeInfo2_fnAddVarDesc(), ITypeComp_fnBind(), ITypeInfo_fnGetVarDesc(), and ITypeLibComp_fnBind().

TLB_append_guid()

static TLBGuid * TLB_append_guid ( struct list *  guid_list, const GUID *  new_guid, HREFTYPE  hreftype  )

static

Definition at line 1828 of file typelib.c.

{
    TLBGuid *guid;
 
    LIST_FOR_EACH_ENTRY(guid, guid_list, TLBGuid, entry) {
        if (IsEqualGUID(&guid->guid, new_guid))
            return guid;
    }
 
    guid = heap_alloc(sizeof(TLBGuid));
    if (!guid)
        return NULL;
 
    memcpy(&guid->guid, new_guid, sizeof(GUID));
    guid->hreftype = hreftype;
 
    list_add_tail(guid_list, &guid->entry);
 
    return guid;
}

Referenced by ICreateTypeInfo2_fnAddRefTypeInfo(), ICreateTypeInfo2_fnSetCustData(), ICreateTypeInfo2_fnSetGuid(), ICreateTypeLib2_fnSetCustData(), ICreateTypeLib2_fnSetGuid(), ITypeLib2_Constructor_SLTG(), SLTG_DoRefs(), and SLTG_ReadLibBlk().

TLB_append_str()

static TLBString * TLB_append_str ( struct list *  string_list, BSTR  new_str  )

static

Definition at line 1884 of file typelib.c.

{
    TLBString *str;
 
    if(!new_str)
        return NULL;
 
    LIST_FOR_EACH_ENTRY(str, string_list, TLBString, entry) {
        if (wcscmp(str->str, new_str) == 0)
            return str;
    }
 
    str = heap_alloc(sizeof(TLBString));
    if (!str)
        return NULL;
 
    str->str = SysAllocString(new_str);
    if (!str->str) {
        heap_free(str);
        return NULL;
    }
 
    list_add_tail(string_list, &str->entry);
 
    return str;
}

Referenced by CreateDispTypeInfo(), decode_string(), ICreateTypeInfo2_fnSetDocString(), ICreateTypeInfo2_fnSetFuncAndParamNames(), ICreateTypeInfo2_fnSetFuncDocString(), ICreateTypeInfo2_fnSetName(), ICreateTypeInfo2_fnSetSchema(), ICreateTypeInfo2_fnSetVarDocString(), ICreateTypeInfo2_fnSetVarName(), ICreateTypeLib2_fnCreateTypeInfo(), ICreateTypeLib2_fnSetDocString(), ICreateTypeLib2_fnSetHelpFileName(), ICreateTypeLib2_fnSetHelpStringDll(), ICreateTypeLib2_fnSetName(), SLTG_ReadName(), and SLTG_ReadString().

TLB_copy_all_custdata()

static HRESULT TLB_copy_all_custdata ( struct list *  custdata_list, CUSTDATA *  pCustData  )

static

Definition at line 5360 of file typelib.c.

{
    TLBCustData *pCData;
    unsigned int ct;
    CUSTDATAITEM *cdi;
 
    ct = list_count(custdata_list);
 
    pCustData->prgCustData = CoTaskMemAlloc(ct * sizeof(CUSTDATAITEM));
    if(!pCustData->prgCustData)
        return E_OUTOFMEMORY;
 
    pCustData->cCustData = ct;
 
    cdi = pCustData->prgCustData;
    LIST_FOR_EACH_ENTRY(pCData, custdata_list, TLBCustData, entry){
        cdi->guid = *TLB_get_guid_null(pCData->guid);
        VariantCopy(&cdi->varValue, &pCData->data);
        ++cdi;
    }
 
    return S_OK;
}

Referenced by ITypeInfo2_fnGetAllCustData(), ITypeInfo2_fnGetAllFuncCustData(), ITypeInfo2_fnGetAllImplTypeCustData(), ITypeInfo2_fnGetAllParamCustData(), ITypeInfo2_fnGetAllVarCustData(), and ITypeLib2_fnGetAllCustData().

TLB_CopyElemDesc()

static HRESULT TLB_CopyElemDesc ( const ELEMDESC *  src, ELEMDESC *  dest, char **  buffer  )

static

Definition at line 5824 of file typelib.c.

{
    *dest = *src;
    *buffer = TLB_CopyTypeDesc(&dest->tdesc, &src->tdesc, *buffer);
    if (src->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
    {
        const PARAMDESCEX *pparamdescex_src = src->u.paramdesc.pparamdescex;
        PARAMDESCEX *pparamdescex_dest = dest->u.paramdesc.pparamdescex = (PARAMDESCEX *)*buffer;
        *buffer += sizeof(PARAMDESCEX);
        *pparamdescex_dest = *pparamdescex_src;
        pparamdescex_dest->cBytes = sizeof(PARAMDESCEX);
        VariantInit(&pparamdescex_dest->varDefaultValue);
        return VariantCopy(&pparamdescex_dest->varDefaultValue, 
                           (VARIANTARG *)&pparamdescex_src->varDefaultValue);
    }
    else
        dest->u.paramdesc.pparamdescex = NULL;
    return S_OK;
}

Referenced by ICreateTypeInfo2_fnAddFuncDesc(), TLB_AllocAndInitFuncDesc(), and TLB_AllocAndInitVarDesc().

TLB_CopyTypeDesc()

static void * TLB_CopyTypeDesc ( TYPEDESC *  dest, const TYPEDESC *  src, void *  buffer  )

static

Definition at line 1641 of file typelib.c.

{
    if (!dest)
    {
        dest = buffer;
        buffer = (char *)buffer + sizeof(TYPEDESC);
    }
 
    *dest = *src;
 
    switch (src->vt)
    {
    case VT_PTR:
    case VT_SAFEARRAY:
        dest->u.lptdesc = buffer;
        buffer = TLB_CopyTypeDesc(NULL, src->u.lptdesc, buffer);
        break;
    case VT_CARRAY:
        dest->u.lpadesc = buffer;
        memcpy(dest->u.lpadesc, src->u.lpadesc, FIELD_OFFSET(ARRAYDESC, rgbounds[src->u.lpadesc->cDims]));
        buffer = (char *)buffer + FIELD_OFFSET(ARRAYDESC, rgbounds[src->u.lpadesc->cDims]);
        buffer = TLB_CopyTypeDesc(&dest->u.lpadesc->tdescElem, &src->u.lpadesc->tdescElem, buffer);
        break;
    }
    return buffer;
}

Referenced by ICreateTypeInfo2_fnSetTypeDescAlias(), ITypeInfo_fnGetTypeAttr(), MSFT_DoTypeInfo(), TLB_CopyElemDesc(), and TLB_CopyTypeDesc().

TLB_FreeCustData()

static void TLB_FreeCustData ( struct list *  custdata_list )

inlinestatic

Definition at line 1669 of file typelib.c.

{
    TLBCustData *cd, *cdn;
    LIST_FOR_EACH_ENTRY_SAFE(cd, cdn, custdata_list, TLBCustData, entry)
    {
        list_remove(&cd->entry);
        VariantClear(&cd->data);
        heap_free(cd);
    }
}

Referenced by ITypeInfoImpl_Destroy(), and ITypeLib2_fnRelease().

TLB_FreeElemDesc()

static void TLB_FreeElemDesc ( ELEMDESC *  elemdesc )

static

Definition at line 5865 of file typelib.c.

{
    if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
        VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
}

Referenced by ITypeInfo_fnReleaseFuncDesc(), TLB_AllocAndInitFuncDesc(), and TLB_FreeVarDesc().

TLB_FreeVarDesc()

static void TLB_FreeVarDesc ( VARDESC *  var_desc )

static

Definition at line 5968 of file typelib.c.

{
    TLB_FreeElemDesc(&var_desc->elemdescVar);
    if (var_desc->varkind == VAR_CONST)
        VariantClear(var_desc->u.lpvarValue);
    SysFreeString((BSTR)var_desc);
}

Referenced by ITypeInfo_fnReleaseVarDesc(), and ITypeInfoImpl_Destroy().

TLB_get_bstr()

static BSTR TLB_get_bstr ( const TLBString *  str )

inlinestatic

Definition at line 1317 of file typelib.c.

{
    return str != NULL ? str->str : NULL;
}

Referenced by dump_TLBFuncDescOne(), dump_TLBVarDesc(), dump_TypeInfo(), ICreateTypeInfo2_fnSetFuncAndParamNames(), ITypeComp_fnBind(), ITypeInfo2_fnGetDocumentation2(), ITypeInfo_fnGetDllEntry(), ITypeInfo_fnGetDocumentation(), ITypeInfo_fnGetIDsOfNames(), ITypeInfo_fnGetNames(), ITypeLib2_Constructor_SLTG(), ITypeLib2_fnGetDocumentation(), ITypeLib2_fnGetDocumentation2(), ITypeLibComp_fnBind(), MSFT_DoFuncs(), MSFT_DoTypeInfo(), SLTG_DoVars(), TLB_get_typeinfo_by_name(), and TLB_get_vardesc_by_name().

TLB_get_custdata_by_guid()

static TLBCustData * TLB_get_custdata_by_guid ( struct list *  custdata_list, REFGUID  guid  )

inlinestatic

Definition at line 1728 of file typelib.c.

{
    TLBCustData *cust_data;
    LIST_FOR_EACH_ENTRY(cust_data, custdata_list, TLBCustData, entry)
        if(IsEqualIID(TLB_get_guid_null(cust_data->guid), guid))
            return cust_data;
    return NULL;
}

Referenced by ITypeInfo2_fnGetCustData(), ITypeInfo2_fnGetFuncCustData(), ITypeInfo2_fnGetImplTypeCustData(), ITypeInfo2_fnGetParamCustData(), ITypeInfo2_fnGetVarCustData(), ITypeLib2_fnGetCustData(), and TLB_set_custdata().

TLB_get_funcdesc_by_memberid()

static TLBFuncDesc * TLB_get_funcdesc_by_memberid ( TLBFuncDesc *  funcdescs, UINT  n, MEMBERID  memid  )

inlinestatic

Definition at line 1692 of file typelib.c.

{
    while(n){
        if(funcdescs->funcdesc.memid == memid)
            return funcdescs;
        ++funcdescs;
        --n;
    }
    return NULL;
}

Referenced by ITypeInfo2_fnGetDocumentation2(), ITypeInfo_fnGetDllEntry(), ITypeInfo_fnGetDocumentation(), and ITypeInfo_fnGetNames().

TLB_get_guid_null()

static const GUID * TLB_get_guid_null ( const TLBGuid *  guid )

inlinestatic

Definition at line 1334 of file typelib.c.

{
    return guid != NULL ? &guid->guid : &GUID_NULL;
}

Referenced by ITypeInfo_fnGetRefTypeInfo(), ITypeInfo_fnGetTypeAttr(), ITypeLib2_fnGetLibAttr(), ITypeLib2_fnGetTypeInfoOfGuid(), TLB_copy_all_custdata(), TLB_get_custdata_by_guid(), and TLB_set_custdata().

TLB_get_guidref()

static const GUID * TLB_get_guidref ( const TLBGuid *  guid )

inlinestatic

Definition at line 1329 of file typelib.c.

{
    return guid != NULL ? &guid->guid : NULL;
}

Referenced by dump_TLBImpLib(), dump_TLBRefType(), dump_TypeInfo(), ITypeLib2_Constructor_SLTG(), MSFT_DoTypeInfo(), and MSFT_ReadAllRefs().

TLB_get_size_from_hreftype()

static HRESULT TLB_get_size_from_hreftype ( ITypeInfoImpl *  info, HREFTYPE  href, ULONG *  size, WORD *  align  )

static

Definition at line 1911 of file typelib.c.

{
    ITypeInfo *other;
    TYPEATTR *attr;
    HRESULT hr;
 
    hr = ITypeInfo2_GetRefTypeInfo(&info->ITypeInfo2_iface, href, &other);
    if(FAILED(hr))
        return hr;
 
    hr = ITypeInfo_GetTypeAttr(other, &attr);
    if(FAILED(hr)){
        ITypeInfo_Release(other);
        return hr;
    }
 
    if(size)
        *size = attr->cbSizeInstance;
    if(align)
        *align = attr->cbAlignment;
 
    ITypeInfo_ReleaseTypeAttr(other, attr);
    ITypeInfo_Release(other);
 
    return S_OK;
}

Referenced by TLB_size_instance().

TLB_get_typeinfo_by_name()

static ITypeInfoImpl * TLB_get_typeinfo_by_name ( ITypeInfoImpl **  typeinfos, UINT  n, const OLECHAR *  name  )

inlinestatic

Definition at line 1737 of file typelib.c.

{
    while(n){
        if(!lstrcmpiW(TLB_get_bstr((*typeinfos)->Name), name))
            return *typeinfos;
        ++typeinfos;
        --n;
    }
    return NULL;
}

Referenced by ICreateTypeLib2_fnCreateTypeInfo(), and ITypeLibComp_fnBindType().

TLB_get_vardesc_by_memberid()

static TLBVarDesc * TLB_get_vardesc_by_memberid ( TLBVarDesc *  vardescs, UINT  n, MEMBERID  memid  )

inlinestatic

Definition at line 1704 of file typelib.c.

{
    while(n){
        if(vardescs->vardesc.memid == memid)
            return vardescs;
        ++vardescs;
        --n;
    }
    return NULL;
}

Referenced by ITypeInfo2_fnGetDocumentation2(), ITypeInfo2_fnGetVarIndexOfMemId(), ITypeInfo_fnGetDocumentation(), and ITypeInfo_fnGetNames().

TLB_get_vardesc_by_name()

static TLBVarDesc * TLB_get_vardesc_by_name ( TLBVarDesc *  vardescs, UINT  n, const OLECHAR *  name  )

inlinestatic

Definition at line 1716 of file typelib.c.

{
    while(n){
        if(!lstrcmpiW(TLB_get_bstr(vardescs->Name), name))
            return vardescs;
        ++vardescs;
        --n;
    }
    return NULL;
}

Referenced by ITypeComp_fnBind(), ITypeInfo_fnGetIDsOfNames(), and ITypeLib2_fnFindName().

TLB_GUIDFromString()

static BOOL TLB_GUIDFromString ( const char *  str, GUID *  guid  )

static

Definition at line 3674 of file typelib.c.

{
  char b[3];
  int i;
  short s;
 
  if(sscanf(str, "%x-%hx-%hx-%hx", &guid->Data1, &guid->Data2, &guid->Data3, &s) != 4) {
    FIXME("Can't parse guid %s\n", debugstr_guid(guid));
    return FALSE;
  }
 
  guid->Data4[0] = s >> 8;
  guid->Data4[1] = s & 0xff;
 
  b[2] = '\0';
  for(i = 0; i < 6; i++) {
    memcpy(b, str + 24 + 2 * i, 2);
    guid->Data4[i + 2] = strtol(b, NULL, 16);
  }
  return TRUE;
}

Referenced by SLTG_DoRefs().

TLB_is_propgetput()

static BOOL TLB_is_propgetput ( INVOKEKIND  invkind )

static

Definition at line 2332 of file typelib.c.

{
    return (invkind == INVOKE_PROPERTYGET ||
        invkind == INVOKE_PROPERTYPUT ||
        invkind == INVOKE_PROPERTYPUTREF);
}

Referenced by MSFT_DoFuncs().

TLB_Mapping_AddRef()

static ULONG WINAPI TLB_Mapping_AddRef ( IUnknown *  iface )

static

Definition at line 3212 of file typelib.c.

{
    TLB_Mapping *This = mapping_impl_from_IUnknown(iface);
    return InterlockedIncrement(&This->refs);
}

TLB_Mapping_Open()

static HRESULT TLB_Mapping_Open ( LPCWSTR  path, LPVOID *  ppBase, DWORD *  pdwTLBLength, IUnknown **  ppFile  )

static

Definition at line 3242 of file typelib.c.

{
    TLB_Mapping *This;
 
    This = heap_alloc(sizeof(TLB_Mapping));
    if (!This)
        return E_OUTOFMEMORY;
 
    This->IUnknown_iface.lpVtbl = &TLB_Mapping_Vtable;
    This->refs = 1;
    This->file = INVALID_HANDLE_VALUE;
    This->mapping = NULL;
    This->typelib_base = NULL;
 
    This->file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
    if (INVALID_HANDLE_VALUE != This->file)
    {
        This->mapping = CreateFileMappingW(This->file, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
        if (This->mapping)
        {
            This->typelib_base = MapViewOfFile(This->mapping, FILE_MAP_READ, 0, 0, 0);
            if(This->typelib_base)
            {
                /* retrieve file size */
                *pdwTLBLength = GetFileSize(This->file, NULL);
                *ppBase = This->typelib_base;
                *ppFile = &This->IUnknown_iface;
                return S_OK;
            }
        }
    }
 
    IUnknown_Release(&This->IUnknown_iface);
    return TYPE_E_CANTLOADLIBRARY;
}

Referenced by TLB_ReadTypeLib().

TLB_Mapping_QueryInterface()

static HRESULT WINAPI TLB_Mapping_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 3200 of file typelib.c.

{
    if (IsEqualIID(riid, &IID_IUnknown))
    {
        *ppv = iface;
        IUnknown_AddRef(iface);
        return S_OK;
    }
    *ppv = NULL;
    return E_NOINTERFACE;
}

TLB_Mapping_Release()

static ULONG WINAPI TLB_Mapping_Release ( IUnknown *  iface )

static

Definition at line 3218 of file typelib.c.

{
    TLB_Mapping *This = mapping_impl_from_IUnknown(iface);
    ULONG refs = InterlockedDecrement(&This->refs);
    if (!refs)
    {
        if (This->typelib_base)
            UnmapViewOfFile(This->typelib_base);
        if (This->mapping)
            CloseHandle(This->mapping);
        if (This->file != INVALID_HANDLE_VALUE)
            CloseHandle(This->file);
        heap_free(This);
    }
    return refs;
}

TLB_MultiByteToBSTR()

static BSTR TLB_MultiByteToBSTR ( const char *  ptr )

static

Definition at line 1680 of file typelib.c.

{
    DWORD len;
    BSTR ret;
 
    len = MultiByteToWideChar(CP_ACP, 0, ptr, -1, NULL, 0);
    ret = SysAllocStringLen(NULL, len - 1);
    if (!ret) return ret;
    MultiByteToWideChar(CP_ACP, 0, ptr, -1, ret, len);
    return ret;
}

Referenced by ITypeLib2_Constructor_MSFT(), SLTG_DoRefs(), and SLTG_ReadName().

TLB_NEFile_AddRef()

static ULONG WINAPI TLB_NEFile_AddRef ( IUnknown *  iface )

static

Definition at line 2990 of file typelib.c.

{
    TLB_NEFile *This = nefile_impl_from_IUnknown(iface);
    return InterlockedIncrement(&This->refs);
}

TLB_NEFile_Open()

static HRESULT TLB_NEFile_Open ( LPCWSTR  path, INT  index, LPVOID *  ppBase, DWORD *  pdwTLBLength, IUnknown **  ppFile  )

static

Definition at line 3145 of file typelib.c.

                                                                                                               {
 
    HFILE lzfd = -1;
    OFSTRUCT ofs;
    HRESULT hr = TYPE_E_CANTLOADLIBRARY;
    TLB_NEFile *This;
 
    This = heap_alloc(sizeof(TLB_NEFile));
    if (!This) return E_OUTOFMEMORY;
 
    This->IUnknown_iface.lpVtbl = &TLB_NEFile_Vtable;
    This->refs = 1;
    This->typelib_base = NULL;
 
    lzfd = LZOpenFileW( (LPWSTR)path, &ofs, OF_READ );
    if ( lzfd >= 0 && read_xx_header( lzfd ) == IMAGE_OS2_SIGNATURE )
    {
        DWORD reslen, offset;
        if( find_ne_resource( lzfd, "TYPELIB", MAKEINTRESOURCEA(index), &reslen, &offset ) )
        {
            This->typelib_base = heap_alloc(reslen);
            if( !This->typelib_base )
                hr = E_OUTOFMEMORY;
            else
            {
                LZSeek( lzfd, offset, SEEK_SET );
                reslen = LZRead( lzfd, This->typelib_base, reslen );
                LZClose( lzfd );
                *ppBase = This->typelib_base;
                *pdwTLBLength = reslen;
                *ppFile = &This->IUnknown_iface;
                return S_OK;
            }
        }
    }
 
    if( lzfd >= 0) LZClose( lzfd );
    TLB_NEFile_Release(&This->IUnknown_iface);
    return hr;
}

Referenced by TLB_ReadTypeLib().

TLB_NEFile_QueryInterface()

static HRESULT WINAPI TLB_NEFile_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 2978 of file typelib.c.

{
    if (IsEqualIID(riid, &IID_IUnknown))
    {
        *ppv = iface;
        IUnknown_AddRef(iface);
        return S_OK;
    }
    *ppv = NULL;
    return E_NOINTERFACE;
}

TLB_NEFile_Release()

static ULONG WINAPI TLB_NEFile_Release ( IUnknown *  iface )

static

Definition at line 2996 of file typelib.c.

{
    TLB_NEFile *This = nefile_impl_from_IUnknown(iface);
    ULONG refs = InterlockedDecrement(&This->refs);
    if (!refs)
    {
        heap_free(This->typelib_base);
        heap_free(This);
    }
    return refs;
}

Referenced by TLB_NEFile_Open().

TLB_PEFile_AddRef()

static ULONG WINAPI TLB_PEFile_AddRef ( IUnknown *  iface )

static

Definition at line 2890 of file typelib.c.

{
    TLB_PEFile *This = pefile_impl_from_IUnknown(iface);
    return InterlockedIncrement(&This->refs);
}

TLB_PEFile_Open()

static HRESULT TLB_PEFile_Open ( LPCWSTR  path, INT  index, LPVOID *  ppBase, DWORD *  pdwTLBLength, IUnknown **  ppFile  )

static

Definition at line 2918 of file typelib.c.

{
    TLB_PEFile *This;
    HRESULT hr = TYPE_E_CANTLOADLIBRARY;
 
    This = heap_alloc(sizeof(TLB_PEFile));
    if (!This)
        return E_OUTOFMEMORY;
 
    This->IUnknown_iface.lpVtbl = &TLB_PEFile_Vtable;
    This->refs = 1;
    This->dll = NULL;
    This->typelib_resource = NULL;
    This->typelib_global = NULL;
    This->typelib_base = NULL;
 
    This->dll = LoadLibraryExW(path, 0, DONT_RESOLVE_DLL_REFERENCES |
                    LOAD_LIBRARY_AS_DATAFILE | LOAD_WITH_ALTERED_SEARCH_PATH);
 
    if (This->dll)
    {
        static const WCHAR TYPELIBW[] = {'T','Y','P','E','L','I','B',0};
        This->typelib_resource = FindResourceW(This->dll, MAKEINTRESOURCEW(index), TYPELIBW);
        if (This->typelib_resource)
        {
            This->typelib_global = LoadResource(This->dll, This->typelib_resource);
            if (This->typelib_global)
            {
                This->typelib_base = LockResource(This->typelib_global);
 
                if (This->typelib_base)
                {
                    *pdwTLBLength = SizeofResource(This->dll, This->typelib_resource);
                    *ppBase = This->typelib_base;
                    *ppFile = &This->IUnknown_iface;
                    return S_OK;
                }
            }
        }
 
        TRACE("No TYPELIB resource found\n");
        hr = E_FAIL;
    }
 
    TLB_PEFile_Release(&This->IUnknown_iface);
    return hr;
}

Referenced by TLB_ReadTypeLib().

TLB_PEFile_QueryInterface()

static HRESULT WINAPI TLB_PEFile_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 2878 of file typelib.c.

{
    if (IsEqualIID(riid, &IID_IUnknown))
    {
        *ppv = iface;
        IUnknown_AddRef(iface);
        return S_OK;
    }
    *ppv = NULL;
    return E_NOINTERFACE;
}

TLB_PEFile_Release()

static ULONG WINAPI TLB_PEFile_Release ( IUnknown *  iface )

static

Definition at line 2896 of file typelib.c.

{
    TLB_PEFile *This = pefile_impl_from_IUnknown(iface);
    ULONG refs = InterlockedDecrement(&This->refs);
    if (!refs)
    {
        if (This->typelib_global)
            FreeResource(This->typelib_global);
        if (This->dll)
            FreeLibrary(This->dll);
        heap_free(This);
    }
    return refs;
}

Referenced by TLB_PEFile_Open().

TLB_ReadTypeLib()

static HRESULT TLB_ReadTypeLib ( LPCWSTR  pszFileName, LPWSTR  pszPath, UINT  cchPath, ITypeLib2 **  ppTypeLib  )

static

Definition at line 3286 of file typelib.c.

{
    ITypeLibImpl *entry;
    HRESULT ret;
    INT index = 1;
    LPWSTR index_str, file = (LPWSTR)pszFileName;
    LPVOID pBase = NULL;
    DWORD dwTLBLength = 0;
    IUnknown *pFile = NULL;
    HANDLE h;
 
    *ppTypeLib = NULL;
 
    index_str = wcsrchr(pszFileName, '\\');
    if(index_str && *++index_str != '\0')
    {
        LPWSTR end_ptr;
        LONG idx = wcstol(index_str, &end_ptr, 10);
        if(*end_ptr == '\0')
        {
            int str_len = index_str - pszFileName - 1;
            index = idx;
            file = heap_alloc((str_len + 1) * sizeof(WCHAR));
            memcpy(file, pszFileName, str_len * sizeof(WCHAR));
            file[str_len] = 0;
        }
    }
 
    if(!SearchPathW(NULL, file, NULL, cchPath, pszPath, NULL))
    {
        if(wcschr(file, '\\'))
        {
            lstrcpyW(pszPath, file);
        }
        else
        {
            int len = GetSystemDirectoryW(pszPath, cchPath);
            pszPath[len] = '\\';
            memcpy(pszPath + len + 1, file, (lstrlenW(file) + 1) * sizeof(WCHAR));
        }
    }
 
    if(file != pszFileName) heap_free(file);
 
    h = CreateFileW(pszPath, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if(h != INVALID_HANDLE_VALUE){
        FILE_NAME_INFORMATION size_info;
        BOOL br;
 
        /* GetFileInformationByHandleEx returns the path of the file without
         * WOW64 redirection */
        br = GetFileInformationByHandleEx(h, FileNameInfo, &size_info, sizeof(size_info));
        if(br || GetLastError() == ERROR_MORE_DATA){
            FILE_NAME_INFORMATION *info;
            DWORD size = sizeof(*info) + size_info.FileNameLength + sizeof(WCHAR);
 
            info = HeapAlloc(GetProcessHeap(), 0, size);
 
            br = GetFileInformationByHandleEx(h, FileNameInfo, info, size);
            if(br){
                info->FileName[info->FileNameLength / sizeof(WCHAR)] = 0;
                lstrcpynW(pszPath + 2, info->FileName, cchPath - 2);
            }
 
            HeapFree(GetProcessHeap(), 0, info);
        }
 
        CloseHandle(h);
    }
 
    TRACE_(typelib)("File %s index %d\n", debugstr_w(pszPath), index);
 
    /* We look the path up in the typelib cache. If found, we just addref it, and return the pointer. */
    EnterCriticalSection(&cache_section);
    LIST_FOR_EACH_ENTRY(entry, &tlb_cache, ITypeLibImpl, entry)
    {
        if (!wcsicmp(entry->path, pszPath) && entry->index == index)
        {
            TRACE("cache hit\n");
            *ppTypeLib = &entry->ITypeLib2_iface;
            ITypeLib2_AddRef(*ppTypeLib);
            LeaveCriticalSection(&cache_section);
            return S_OK;
        }
    }
    LeaveCriticalSection(&cache_section);
 
    /* now actually load and parse the typelib */
 
    ret = TLB_PEFile_Open(pszPath, index, &pBase, &dwTLBLength, &pFile);
    if (ret == TYPE_E_CANTLOADLIBRARY)
        ret = TLB_NEFile_Open(pszPath, index, &pBase, &dwTLBLength, &pFile);
    if (ret == TYPE_E_CANTLOADLIBRARY)
        ret = TLB_Mapping_Open(pszPath, &pBase, &dwTLBLength, &pFile);
    if (SUCCEEDED(ret))
    {
        if (dwTLBLength >= 4)
        {
            DWORD dwSignature = FromLEDWord(*((DWORD*) pBase));
            if (dwSignature == MSFT_SIGNATURE)
                *ppTypeLib = ITypeLib2_Constructor_MSFT(pBase, dwTLBLength);
            else if (dwSignature == SLTG_SIGNATURE)
                *ppTypeLib = ITypeLib2_Constructor_SLTG(pBase, dwTLBLength);
            else
            {
                FIXME("Header type magic 0x%08x not supported.\n",dwSignature);
                ret = TYPE_E_CANTLOADLIBRARY;
            }
        }
        else
            ret = TYPE_E_CANTLOADLIBRARY;
        IUnknown_Release(pFile);
    }
 
    if(*ppTypeLib) {
    ITypeLibImpl *impl = impl_from_ITypeLib2(*ppTypeLib);
 
    TRACE("adding to cache\n");
    impl->path = heap_alloc((lstrlenW(pszPath)+1) * sizeof(WCHAR));
    lstrcpyW(impl->path, pszPath);
    /* We should really canonicalise the path here. */
        impl->index = index;
 
        /* FIXME: check if it has added already in the meantime */
        EnterCriticalSection(&cache_section);
        list_add_head(&tlb_cache, &impl->entry);
        LeaveCriticalSection(&cache_section);
        ret = S_OK;
    }
    else
    {
        if(ret != E_FAIL)
            ERR("Loading of typelib %s failed with error %d\n", debugstr_w(pszFileName), GetLastError());
 
        ret = TYPE_E_CANTLOADLIBRARY;
    }
 
 
    return ret;
}

Referenced by LoadTypeLibEx().

TLB_register_interface()

static void TLB_register_interface ( TLIBATTR *  libattr, LPOLESTR  name, TYPEATTR *  tattr, DWORD  flag  )

static

Definition at line 583 of file typelib.c.

{
    WCHAR keyName[60];
    HKEY key, subKey;
 
    static const WCHAR typelib_proxy_clsid[] = {'{','0','0','0','2','0','4','2','4','-',
            '0','0','0','0','-','0','0','0','0','-','C','0','0','0','-',
            '0','0','0','0','0','0','0','0','0','0','4','6','}',0};
    static const WCHAR dispatch_proxy_clsid[] = {'{','0','0','0','2','0','4','2','0','-',
            '0','0','0','0','-','0','0','0','0','-','C','0','0','0','-',
            '0','0','0','0','0','0','0','0','0','0','4','6','}',0};
 
    get_interface_key( &tattr->guid, keyName );
    if (RegCreateKeyExW(HKEY_CLASSES_ROOT, keyName, 0, NULL, 0,
                        KEY_WRITE | flag, NULL, &key, NULL) == ERROR_SUCCESS)
    {
        const WCHAR *proxy_clsid;
 
        if (tattr->typekind == TKIND_INTERFACE || (tattr->wTypeFlags & TYPEFLAG_FDUAL))
            proxy_clsid = typelib_proxy_clsid;
        else
            proxy_clsid = dispatch_proxy_clsid;
 
        if (name)
            RegSetValueExW(key, NULL, 0, REG_SZ,
                           (BYTE *)name, (lstrlenW(name)+1) * sizeof(OLECHAR));
 
        if (RegCreateKeyExW(key, ProxyStubClsidW, 0, NULL, 0,
            KEY_WRITE | flag, NULL, &subKey, NULL) == ERROR_SUCCESS) {
            RegSetValueExW(subKey, NULL, 0, REG_SZ,
                           (const BYTE *)proxy_clsid, sizeof(typelib_proxy_clsid));
            RegCloseKey(subKey);
        }
 
        if (RegCreateKeyExW(key, ProxyStubClsid32W, 0, NULL, 0,
            KEY_WRITE | flag, NULL, &subKey, NULL) == ERROR_SUCCESS) {
            RegSetValueExW(subKey, NULL, 0, REG_SZ,
                           (const BYTE *)proxy_clsid, sizeof(typelib_proxy_clsid));
            RegCloseKey(subKey);
        }
 
        if (RegCreateKeyExW(key, TypeLibW, 0, NULL, 0,
            KEY_WRITE | flag, NULL, &subKey, NULL) == ERROR_SUCCESS)
        {
            WCHAR buffer[40];
            static const WCHAR fmtver[] = {'%','x','.','%','x',0 };
            static const WCHAR VersionW[] = {'V','e','r','s','i','o','n',0};
 
            StringFromGUID2(&libattr->guid, buffer, 40);
            RegSetValueExW(subKey, NULL, 0, REG_SZ,
                           (BYTE *)buffer, (lstrlenW(buffer)+1) * sizeof(WCHAR));
            swprintf(buffer, fmtver, libattr->wMajorVerNum, libattr->wMinorVerNum);
            RegSetValueExW(subKey, VersionW, 0, REG_SZ,
                           (BYTE*)buffer, (lstrlenW(buffer)+1) * sizeof(WCHAR));
            RegCloseKey(subKey);
        }
 
        RegCloseKey(key);
    }
}

Referenced by RegisterTypeLib().

TLB_SanitizeBSTR()

static HRESULT TLB_SanitizeBSTR ( BSTR  str )

static

Definition at line 5844 of file typelib.c.

{
    UINT len = SysStringLen(str), i;
    for (i = 0; i < len; ++i)
        if (str[i] > 0x7f)
            str[i] = '?';
    return S_OK;
}

Referenced by TLB_SanitizeVariant().

TLB_SanitizeVariant()

static HRESULT TLB_SanitizeVariant ( VARIANT *  var )

static

Definition at line 5853 of file typelib.c.

{
    if (V_VT(var) == VT_INT)
        return VariantChangeType(var, var, 0, VT_I4);
    else if (V_VT(var) == VT_UINT)
        return VariantChangeType(var, var, 0, VT_UI4);
    else if (V_VT(var) == VT_BSTR)
        return TLB_SanitizeBSTR(V_BSTR(var));
 
    return S_OK;
}

Referenced by ICreateTypeInfo2_fnAddFuncDesc().

TLB_set_custdata()

static HRESULT TLB_set_custdata ( struct list *  custdata_list, TLBGuid *  tlbguid, VARIANT *  var  )

static

Definition at line 1850 of file typelib.c.

{
    TLBCustData *cust_data;
 
    switch(V_VT(var)){
    case VT_I4:
    case VT_R4:
    case VT_UI4:
    case VT_INT:
    case VT_UINT:
    case VT_HRESULT:
    case VT_BSTR:
        break;
    default:
        return DISP_E_BADVARTYPE;
    }
 
    cust_data = TLB_get_custdata_by_guid(custdata_list, TLB_get_guid_null(tlbguid));
 
    if (!cust_data) {
        cust_data = heap_alloc(sizeof(TLBCustData));
        if (!cust_data)
            return E_OUTOFMEMORY;
 
        cust_data->guid = tlbguid;
        VariantInit(&cust_data->data);
 
        list_add_tail(custdata_list, &cust_data->entry);
    }else
        VariantClear(&cust_data->data);
 
    return VariantCopy(&cust_data->data, var);
}

Referenced by ICreateTypeInfo2_fnSetCustData(), and ICreateTypeLib2_fnSetCustData().

TLB_size_instance()

static HRESULT TLB_size_instance ( ITypeInfoImpl *  info, SYSKIND  sys, TYPEDESC *  tdesc, ULONG *  size, WORD *  align  )

static

Definition at line 1939 of file typelib.c.

{
    ULONG i, sub, ptr_size;
    HRESULT hr;
 
    ptr_size = get_ptr_size(sys);
 
    switch(tdesc->vt){
    case VT_VOID:
        *size = 0;
        break;
    case VT_I1:
    case VT_UI1:
        *size = 1;
        break;
    case VT_I2:
    case VT_BOOL:
    case VT_UI2:
        *size = 2;
        break;
    case VT_I4:
    case VT_R4:
    case VT_ERROR:
    case VT_UI4:
    case VT_INT:
    case VT_UINT:
    case VT_HRESULT:
        *size = 4;
        break;
    case VT_R8:
    case VT_I8:
    case VT_UI8:
        *size = 8;
        break;
    case VT_BSTR:
    case VT_DISPATCH:
    case VT_UNKNOWN:
    case VT_PTR:
    case VT_SAFEARRAY:
    case VT_LPSTR:
    case VT_LPWSTR:
        *size = ptr_size;
        break;
    case VT_DATE:
        *size = sizeof(DATE);
        break;
    case VT_VARIANT:
        *size = sizeof(VARIANT);
#ifdef _WIN64
        if(sys == SYS_WIN32)
            *size -= 8; /* 32-bit VARIANT is 8 bytes smaller than 64-bit VARIANT */
#endif
        break;
    case VT_DECIMAL:
        *size = sizeof(DECIMAL);
        break;
    case VT_CY:
        *size = sizeof(CY);
        break;
    case VT_CARRAY:
        *size = 0;
        for(i = 0; i < tdesc->u.lpadesc->cDims; ++i)
            *size += tdesc->u.lpadesc->rgbounds[i].cElements;
        hr = TLB_size_instance(info, sys, &tdesc->u.lpadesc->tdescElem, &sub, align);
        if(FAILED(hr))
            return hr;
        *size *= sub;
        return S_OK;
    case VT_USERDEFINED:
        return TLB_get_size_from_hreftype(info, tdesc->u.hreftype, size, align);
    default:
        FIXME("Unsized VT: 0x%x\n", tdesc->vt);
        return E_FAIL;
    }
 
    if(align){
        if(*size < 4)
            *align = *size;
        else
            *align = 4;
    }
 
    return S_OK;
}

Referenced by ICreateTypeInfo2_fnSetTypeDescAlias(), and TLB_size_instance().

TLB_SizeElemDesc()

static SIZE_T TLB_SizeElemDesc ( const ELEMDESC *  elemdesc )

static

Definition at line 5816 of file typelib.c.

{
    SIZE_T size = TLB_SizeTypeDesc(&elemdesc->tdesc, FALSE);
    if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
        size += sizeof(*elemdesc->u.paramdesc.pparamdescex);
    return size;
}

Referenced by ICreateTypeInfo2_fnAddFuncDesc(), TLB_AllocAndInitFuncDesc(), and TLB_AllocAndInitVarDesc().

TLB_SizeTypeDesc()

static SIZE_T TLB_SizeTypeDesc ( const TYPEDESC *  tdesc, BOOL  alloc_initial_space  )

static

Definition at line 1619 of file typelib.c.

{
    SIZE_T size = 0;
 
    if (alloc_initial_space)
        size += sizeof(TYPEDESC);
 
    switch (tdesc->vt)
    {
    case VT_PTR:
    case VT_SAFEARRAY:
        size += TLB_SizeTypeDesc(tdesc->u.lptdesc, TRUE);
        break;
    case VT_CARRAY:
        size += FIELD_OFFSET(ARRAYDESC, rgbounds[tdesc->u.lpadesc->cDims]);
        size += TLB_SizeTypeDesc(&tdesc->u.lpadesc->tdescElem, FALSE);
        break;
    }
    return size;
}

Referenced by ICreateTypeInfo2_fnSetTypeDescAlias(), ITypeInfo_fnGetTypeAttr(), MSFT_DoTypeInfo(), TLB_SizeElemDesc(), and TLB_SizeTypeDesc().

TLB_str_memcmp()

static int TLB_str_memcmp ( void *  left, const TLBString *  str, DWORD  len  )

inlinestatic

Definition at line 1322 of file typelib.c.

{
    if(!str)
        return 1;
    return memcmp(left, str->str, len);
}

Referenced by ITypeLib2_fnFindName(), and ITypeLib2_fnIsName().

TLB_unregister_interface()

static void TLB_unregister_interface ( GUID *  guid, REGSAM  flag  )

static

Definition at line 854 of file typelib.c.

{
    WCHAR subKeyName[50];
    HKEY subKey;
 
    /* the path to the type */
    get_interface_key( guid, subKeyName );
 
    /* Delete its bits */
    if (RegOpenKeyExW(HKEY_CLASSES_ROOT, subKeyName, 0, KEY_WRITE | flag, &subKey) != ERROR_SUCCESS)
        return;
 
    RegDeleteKeyW(subKey, ProxyStubClsidW);
    RegDeleteKeyW(subKey, ProxyStubClsid32W);
    RegDeleteKeyW(subKey, TypeLibW);
    RegCloseKey(subKey);
    RegDeleteKeyExW(HKEY_CLASSES_ROOT, subKeyName, flag, 0);
}

Referenced by UnRegisterTypeLib().

TLBFuncDesc_Alloc()

static TLBFuncDesc * TLBFuncDesc_Alloc ( UINT  n )

static

Definition at line 1791 of file typelib.c.

{
    TLBFuncDesc *ret;
 
    ret = heap_alloc_zero(sizeof(TLBFuncDesc) * n);
    if(!ret)
        return NULL;
 
    while(n){
        TLBFuncDesc_Constructor(&ret[n-1]);
        --n;
    }
 
    return ret;
}

Referenced by CreateDispTypeInfo(), MSFT_DoFuncs(), and SLTG_DoFuncs().

TLBFuncDesc_Constructor()

static void TLBFuncDesc_Constructor ( TLBFuncDesc *  func_desc )

static

Definition at line 1786 of file typelib.c.

{
    list_init(&func_desc->custdata_list);
}

Referenced by ICreateTypeInfo2_fnAddFuncDesc(), and TLBFuncDesc_Alloc().

TLBImplType_Alloc()

static TLBImplType * TLBImplType_Alloc ( UINT  n )

static

Definition at line 1812 of file typelib.c.

{
    TLBImplType *ret;
 
    ret = heap_alloc_zero(sizeof(TLBImplType) * n);
    if(!ret)
        return NULL;
 
    while(n){
        TLBImplType_Constructor(&ret[n-1]);
        --n;
    }
 
    return ret;
}

Referenced by CreateDispTypeInfo(), MSFT_DoImplTypes(), MSFT_DoTypeInfo(), and SLTG_DoImpls().

TLBImplType_Constructor()

static void TLBImplType_Constructor ( TLBImplType *  impl )

static

Definition at line 1807 of file typelib.c.

{
    list_init(&impl->custdata_list);
}

Referenced by ICreateTypeInfo2_fnAddImplType(), and TLBImplType_Alloc().

TLBParDesc_Constructor()

static TLBParDesc * TLBParDesc_Constructor ( UINT  n )

static

Definition at line 1770 of file typelib.c.

{
    TLBParDesc *ret;
 
    ret = heap_alloc_zero(sizeof(TLBParDesc) * n);
    if(!ret)
        return NULL;
 
    while(n){
        list_init(&ret[n-1].custdata_list);
        --n;
    }
 
    return ret;
}

Referenced by CreateDispTypeInfo(), ICreateTypeInfo2_fnAddFuncDesc(), MSFT_DoFuncs(), and SLTG_DoFuncs().

TLBVarDesc_Alloc()

static TLBVarDesc * TLBVarDesc_Alloc ( UINT  n )

static

Definition at line 1754 of file typelib.c.

{
    TLBVarDesc *ret;
 
    ret = heap_alloc_zero(sizeof(TLBVarDesc) * n);
    if(!ret)
        return NULL;
 
    while(n){
        TLBVarDesc_Constructor(&ret[n-1]);
        --n;
    }
 
    return ret;
}

Referenced by MSFT_DoVars(), and SLTG_DoVars().

TLBVarDesc_Constructor()

static void TLBVarDesc_Constructor ( TLBVarDesc *  var_desc )

static

Definition at line 1749 of file typelib.c.

{
    list_init(&var_desc->custdata_list);
}

Referenced by ICreateTypeInfo2_fnAddVarDesc(), and TLBVarDesc_Alloc().

tmp_fill_segdir_seg()

static void tmp_fill_segdir_seg ( MSFT_pSeg *  segdir, WMSFT_SegContents *  contents, DWORD *  running_offset  )

static

Definition at line 10251 of file typelib.c.

{
    if(contents && contents->len){
        segdir->offset = *running_offset;
        segdir->length = contents->len;
        *running_offset += segdir->length;
    }else{
        segdir->offset = -1;
        segdir->length = 0;
    }
 
    /* TODO: do these ever change? */
    segdir->res08 = -1;
    segdir->res0c = 0xf;
}

Referenced by ICreateTypeLib2_fnSaveAllChanges().

typedescvt_to_variantvt()

static HRESULT typedescvt_to_variantvt ( ITypeInfo *  tinfo, const TYPEDESC *  tdesc, VARTYPE *  vt  )

static

Definition at line 7148 of file typelib.c.

{
    HRESULT hr = S_OK;
 
    /* enforce only one level of pointer indirection */
    if (!(*vt & VT_BYREF) && !(*vt & VT_ARRAY) && (tdesc->vt == VT_PTR))
    {
        tdesc = tdesc->u.lptdesc;
 
        /* munch VT_PTR -> VT_USERDEFINED(interface) into VT_UNKNOWN or
         * VT_DISPATCH and VT_PTR -> VT_PTR -> VT_USERDEFINED(interface) into 
         * VT_BYREF|VT_DISPATCH or VT_BYREF|VT_UNKNOWN */
        if ((tdesc->vt == VT_USERDEFINED) ||
            ((tdesc->vt == VT_PTR) && (tdesc->u.lptdesc->vt == VT_USERDEFINED)))
        {
            VARTYPE vt_userdefined = 0;
            const TYPEDESC *tdesc_userdefined = tdesc;
            if (tdesc->vt == VT_PTR)
            {
                vt_userdefined = VT_BYREF;
                tdesc_userdefined = tdesc->u.lptdesc;
            }
            hr = userdefined_to_variantvt(tinfo, tdesc_userdefined, &vt_userdefined);
            if ((hr == S_OK) && 
                (((vt_userdefined & VT_TYPEMASK) == VT_UNKNOWN) ||
                 ((vt_userdefined & VT_TYPEMASK) == VT_DISPATCH)))
            {
                *vt |= vt_userdefined;
                return S_OK;
            }
        }
        *vt = VT_BYREF;
    }
 
    switch (tdesc->vt)
    {
    case VT_HRESULT:
        *vt |= VT_ERROR;
        break;
    case VT_USERDEFINED:
        hr = userdefined_to_variantvt(tinfo, tdesc, vt);
        break;
    case VT_VOID:
    case VT_CARRAY:
    case VT_PTR:
    case VT_LPSTR:
    case VT_LPWSTR:
        ERR("cannot convert type %d into variant VT\n", tdesc->vt);
        hr = DISP_E_BADVARTYPE;
        break;
    case VT_SAFEARRAY:
        *vt |= VT_ARRAY;
        hr = typedescvt_to_variantvt(tinfo, tdesc->u.lptdesc, vt);
        break;
    case VT_INT:
        *vt |= VT_I4;
        break;
    case VT_UINT:
        *vt |= VT_UI4;
        break;
    default:
        *vt |= tdesc->vt;
        break;
    }
    return hr;
}

Referenced by ITypeInfo_fnInvoke(), typedescvt_to_variantvt(), and userdefined_to_variantvt().

TypeLibImpl_Constructor()

static ITypeLibImpl * TypeLibImpl_Constructor ( void  )

static

Definition at line 3429 of file typelib.c.

{
    ITypeLibImpl* pTypeLibImpl;
 
    pTypeLibImpl = heap_alloc_zero(sizeof(ITypeLibImpl));
    if (!pTypeLibImpl) return NULL;
 
    pTypeLibImpl->ITypeLib2_iface.lpVtbl = &tlbvt;
    pTypeLibImpl->ITypeComp_iface.lpVtbl = &tlbtcvt;
    pTypeLibImpl->ICreateTypeLib2_iface.lpVtbl = &CreateTypeLib2Vtbl;
    pTypeLibImpl->ref = 1;
 
    list_init(&pTypeLibImpl->implib_list);
    list_init(&pTypeLibImpl->custdata_list);
    list_init(&pTypeLibImpl->name_list);
    list_init(&pTypeLibImpl->string_list);
    list_init(&pTypeLibImpl->guid_list);
    list_init(&pTypeLibImpl->ref_list);
    pTypeLibImpl->dispatch_href = -1;
 
    return pTypeLibImpl;
}

Referenced by CreateDispTypeInfo(), CreateTypeLib2(), ITypeLib2_Constructor_MSFT(), and ITypeLib2_Constructor_SLTG().

UnRegisterTypeLib()

HRESULT WINAPI UnRegisterTypeLib	(	REFGUID	libid,
		WORD	wVerMajor,
		WORD	wVerMinor,
		LCID	lcid,
		SYSKIND	syskind
	)

Definition at line 882 of file typelib.c.

{
    BSTR tlibPath = NULL;
    DWORD tmpLength;
    WCHAR keyName[60];
    WCHAR subKeyName[50];
    int result = S_OK;
    DWORD i = 0;
    BOOL deleteOtherStuff;
    HKEY key = NULL;
    TYPEATTR* typeAttr = NULL;
    TYPEKIND kind;
    ITypeInfo* typeInfo = NULL;
    ITypeLib* typeLib = NULL;
    int numTypes;
 
    TRACE("(IID: %s)\n",debugstr_guid(libid));
 
    /* Create the path to the key */
    get_typelib_key( libid, wVerMajor, wVerMinor, keyName );
 
    if (syskind != SYS_WIN16 && syskind != SYS_WIN32 && syskind != SYS_WIN64)
    {
        TRACE("Unsupported syskind %i\n", syskind);
        result = E_INVALIDARG;
        goto end;
    }
 
    /* get the path to the typelib on disk */
    if (query_typelib_path(libid, wVerMajor, wVerMinor, syskind, lcid, &tlibPath, FALSE) != S_OK) {
        result = E_INVALIDARG;
        goto end;
    }
 
    /* Try and open the key to the type library. */
    if (RegOpenKeyExW(HKEY_CLASSES_ROOT, keyName, 0, KEY_READ | KEY_WRITE, &key) != ERROR_SUCCESS) {
        result = E_INVALIDARG;
        goto end;
    }
 
    /* Try and load the type library */
    if (LoadTypeLibEx(tlibPath, REGKIND_NONE, &typeLib) != S_OK) {
        result = TYPE_E_INVALIDSTATE;
        goto end;
    }
 
    /* remove any types registered with this typelib */
    numTypes = ITypeLib_GetTypeInfoCount(typeLib);
    for (i=0; i<numTypes; i++) {
        /* get the kind of type */
        if (ITypeLib_GetTypeInfoType(typeLib, i, &kind) != S_OK) {
            goto enddeleteloop;
        }
 
        /* skip non-interfaces, and get type info for the type */
        if ((kind != TKIND_INTERFACE) && (kind != TKIND_DISPATCH)) {
            goto enddeleteloop;
        }
        if (ITypeLib_GetTypeInfo(typeLib, i, &typeInfo) != S_OK) {
            goto enddeleteloop;
        }
        if (ITypeInfo_GetTypeAttr(typeInfo, &typeAttr) != S_OK) {
            goto enddeleteloop;
        }
 
        if ((kind == TKIND_INTERFACE && (typeAttr->wTypeFlags & TYPEFLAG_FOLEAUTOMATION)) ||
            kind == TKIND_DISPATCH)
        {
            BOOL is_wow64;
            REGSAM opposite = (sizeof(void*) == 8 ? KEY_WOW64_32KEY : KEY_WOW64_64KEY);
 
            TLB_unregister_interface(&typeAttr->guid, 0);
 
            /* unregister TLBs into the opposite registry view, too */
            if(opposite == KEY_WOW64_32KEY ||
               (IsWow64Process(GetCurrentProcess(), &is_wow64) && is_wow64)) {
                TLB_unregister_interface(&typeAttr->guid, opposite);
            }
        }
 
enddeleteloop:
        if (typeAttr) ITypeInfo_ReleaseTypeAttr(typeInfo, typeAttr);
        typeAttr = NULL;
        if (typeInfo) ITypeInfo_Release(typeInfo);
        typeInfo = NULL;
    }
 
    /* Now, delete the type library path subkey */
    get_lcid_subkey( lcid, syskind, subKeyName );
    RegDeleteKeyW(key, subKeyName);
    *wcsrchr( subKeyName, '\\' ) = 0;  /* remove last path component */
    RegDeleteKeyW(key, subKeyName);
 
    /* check if there is anything besides the FLAGS/HELPDIR keys.
       If there is, we don't delete them */
    tmpLength = ARRAY_SIZE(subKeyName);
    deleteOtherStuff = TRUE;
    i = 0;
    while(RegEnumKeyExW(key, i++, subKeyName, &tmpLength, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
        tmpLength = ARRAY_SIZE(subKeyName);
 
        /* if its not FLAGS or HELPDIR, then we must keep the rest of the key */
        if (!wcscmp(subKeyName, FLAGSW)) continue;
        if (!wcscmp(subKeyName, HELPDIRW)) continue;
        deleteOtherStuff = FALSE;
        break;
    }
 
    /* only delete the other parts of the key if we're absolutely sure */
    if (deleteOtherStuff) {
        RegDeleteKeyW(key, FLAGSW);
        RegDeleteKeyW(key, HELPDIRW);
        RegCloseKey(key);
        key = NULL;
 
        RegDeleteKeyW(HKEY_CLASSES_ROOT, keyName);
        *wcsrchr( keyName, '\\' ) = 0;  /* remove last path component */
        RegDeleteKeyW(HKEY_CLASSES_ROOT, keyName);
    }
 
end:
    SysFreeString(tlibPath);
    if (typeLib) ITypeLib_Release(typeLib);
    if (key) RegCloseKey(key);
    return result;
}

Referenced by ATL::AtlComModuleUnregisterServer(), ITERATE_UnregisterTypeLibraries(), register_server(), START_TEST(), test_register_typelib(), test_stub(), and UnRegisterTypeLibForUser().

UnRegisterTypeLibForUser()

HRESULT WINAPI UnRegisterTypeLibForUser	(	REFGUID	libid,
		WORD	wVerMajor,
		WORD	wVerMinor,
		LCID	lcid,
		SYSKIND	syskind
	)

Definition at line 1045 of file typelib.c.

{
    FIXME("(%s, %u, %u, %u, %u) unregistering the typelib system-wide\n",
          debugstr_guid(libid), wVerMajor, wVerMinor, lcid, syskind);
    return UnRegisterTypeLib(libid, wVerMajor, wVerMinor, lcid, syskind);
}

userdefined_to_variantvt()

static HRESULT userdefined_to_variantvt ( ITypeInfo *  tinfo, const TYPEDESC *  tdesc, VARTYPE *  vt  )

static

Definition at line 7081 of file typelib.c.

{
    HRESULT hr = S_OK;
    ITypeInfo *tinfo2 = NULL;
    TYPEATTR *tattr = NULL;
 
    hr = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2);
    if (hr)
    {
        ERR("Could not get typeinfo of hreftype %x for VT_USERDEFINED, "
            "hr = 0x%08x\n",
              tdesc->u.hreftype, hr);
        return hr;
    }
    hr = ITypeInfo_GetTypeAttr(tinfo2, &tattr);
    if (hr)
    {
        ERR("ITypeInfo_GetTypeAttr failed, hr = 0x%08x\n", hr);
        ITypeInfo_Release(tinfo2);
        return hr;
    }
 
    switch (tattr->typekind)
    {
    case TKIND_ENUM:
        *vt |= VT_I4;
        break;
 
    case TKIND_ALIAS:
        hr = typedescvt_to_variantvt(tinfo2, &tattr->tdescAlias, vt);
        break;
 
    case TKIND_INTERFACE:
        if (tattr->wTypeFlags & TYPEFLAG_FDISPATCHABLE)
           *vt |= VT_DISPATCH;
        else
           *vt |= VT_UNKNOWN;
        break;
 
    case TKIND_DISPATCH:
        *vt |= VT_DISPATCH;
        break;
 
    case TKIND_COCLASS:
        *vt |= VT_DISPATCH;
        break;
 
    case TKIND_RECORD:
        FIXME("TKIND_RECORD unhandled.\n");
        hr = E_NOTIMPL;
        break;
 
    case TKIND_UNION:
        FIXME("TKIND_UNION unhandled.\n");
        hr = E_NOTIMPL;
        break;
 
    default:
        FIXME("TKIND %d unhandled.\n",tattr->typekind);
        hr = E_NOTIMPL;
        break;
    }
    ITypeInfo_ReleaseTypeAttr(tinfo2, tattr);
    ITypeInfo_Release(tinfo2);
    return hr;
}

Referenced by typedescvt_to_variantvt().

WINE_DECLARE_DEBUG_CHANNEL()

WINE_DECLARE_DEBUG_CHANNEL

(

typelib

)

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

WMSFT_append_arraydesc()

static DWORD WMSFT_append_arraydesc ( ARRAYDESC *  desc, WMSFT_TLBFile *  file  )

static

Definition at line 9574 of file typelib.c.

{
    DWORD offs = file->arraydesc_seg.len;
    DWORD *encoded;
    USHORT i;
 
    /* TODO: we should check for duplicates, but that's harder because each
     * chunk is variable length (really we should store TYPEDESC and ARRAYDESC
     * at the library-level) */
 
    file->arraydesc_seg.len += (2 + desc->cDims * 2) * sizeof(DWORD);
    if(!file->arraydesc_seg.data)
        file->arraydesc_seg.data = heap_alloc(file->arraydesc_seg.len);
    else
        file->arraydesc_seg.data = heap_realloc(file->arraydesc_seg.data, file->arraydesc_seg.len);
    encoded = (DWORD*)((char *)file->arraydesc_seg.data + offs);
 
    encoded[0] = WMSFT_append_typedesc(&desc->tdescElem, file, NULL, NULL);
    encoded[1] = desc->cDims | ((desc->cDims * 2 * sizeof(DWORD)) << 16);
    for(i = 0; i < desc->cDims; ++i){
        encoded[2 + i * 2] =  desc->rgbounds[i].cElements;
        encoded[2 + i * 2 + 1] = desc->rgbounds[i].lLbound;
    }
 
    return offs;
}

Referenced by WMSFT_append_typedesc().

WMSFT_append_typedesc()

static DWORD WMSFT_append_typedesc ( TYPEDESC *  desc, WMSFT_TLBFile *  file, DWORD *  out_mix, INT16 *  out_size  )

static

Definition at line 9601 of file typelib.c.

{
    DWORD junk;
    INT16 junk2;
    DWORD offs = 0;
    DWORD encoded[2];
    VARTYPE vt, subtype;
    char *data;
 
    if(!desc)
        return -1;
 
    if(!out_mix)
        out_mix = &junk;
    if(!out_size)
        out_size = &junk2;
 
    vt = desc->vt & VT_TYPEMASK;
 
    if(vt == VT_PTR || vt == VT_SAFEARRAY){
        DWORD mix;
        encoded[1] = WMSFT_append_typedesc(desc->u.lptdesc, file, &mix, out_size);
        encoded[0] = desc->vt | ((mix | VT_BYREF) << 16);
        *out_mix = 0x7FFF;
        *out_size += 2 * sizeof(DWORD);
    }else if(vt == VT_CARRAY){
        encoded[0] = desc->vt | (0x7FFE << 16);
        encoded[1] = WMSFT_append_arraydesc(desc->u.lpadesc, file);
        *out_mix = 0x7FFE;
    }else if(vt == VT_USERDEFINED){
        encoded[0] = desc->vt | (0x7FFF << 16);
        encoded[1] = desc->u.hreftype;
        *out_mix = 0x7FFF; /* FIXME: Should get TYPEKIND of the hreftype, e.g. TKIND_ENUM => VT_I4 */
    }else{
        TRACE("Mixing in-place, VT: 0x%x\n", desc->vt);
 
        switch(vt){
        case VT_INT:
            subtype = VT_I4;
            break;
        case VT_UINT:
            subtype = VT_UI4;
            break;
        case VT_VOID:
            subtype = VT_EMPTY;
            break;
        default:
            subtype = vt;
            break;
        }
 
        *out_mix = subtype;
        return 0x80000000 | (subtype << 16) | desc->vt;
    }
 
    data = file->typdesc_seg.data;
    while(offs < file->typdesc_seg.len){
        if(!memcmp(&data[offs], encoded, sizeof(encoded)))
            return offs;
        offs += sizeof(encoded);
    }
 
    file->typdesc_seg.len += sizeof(encoded);
    if(!file->typdesc_seg.data)
        data = file->typdesc_seg.data = heap_alloc(file->typdesc_seg.len);
    else
        data = file->typdesc_seg.data = heap_realloc(file->typdesc_seg.data, file->typdesc_seg.len);
 
    memcpy(&data[offs], encoded, sizeof(encoded));
 
    return offs;
}

Referenced by WMSFT_append_arraydesc(), WMSFT_append_typedesc(), WMSFT_compile_typeinfo(), and WMSFT_compile_typeinfo_aux().

WMSFT_compile_custdata()

static DWORD WMSFT_compile_custdata ( struct list *  custdata_list, WMSFT_TLBFile *  file  )

static

Definition at line 9674 of file typelib.c.

{
    WMSFT_SegContents *cdguids_seg = &file->cdguids_seg;
    DWORD ret = cdguids_seg->len, offs;
    MSFT_CDGuid *cdguid;
    TLBCustData *cd;
 
    if(list_empty(custdata_list))
        return -1;
 
    cdguids_seg->len += sizeof(MSFT_CDGuid) * list_count(custdata_list);
    if(!cdguids_seg->data){
        cdguid = cdguids_seg->data = heap_alloc(cdguids_seg->len);
    }else {
        cdguids_seg->data = heap_realloc(cdguids_seg->data, cdguids_seg->len);
        cdguid = (MSFT_CDGuid*)((char*)cdguids_seg->data + ret);
    }
 
    offs = ret + sizeof(MSFT_CDGuid);
    LIST_FOR_EACH_ENTRY(cd, custdata_list, TLBCustData, entry){
        cdguid->GuidOffset = cd->guid->offset;
        cdguid->DataOffset = WMSFT_encode_variant(&cd->data, file);
        cdguid->next = offs;
        offs += sizeof(MSFT_CDGuid);
        ++cdguid;
    }
 
    --cdguid;
    cdguid->next = -1;
 
    return ret;
}

Referenced by ICreateTypeLib2_fnSaveAllChanges(), WMSFT_compile_typeinfo(), and WMSFT_compile_typeinfo_aux().

WMSFT_compile_guidhash()

static void WMSFT_compile_guidhash ( ITypeLibImpl *  This, WMSFT_TLBFile *  file  )

static

Definition at line 10237 of file typelib.c.

{
    file->guidhash_seg.len = 0x80;
    file->guidhash_seg.data = heap_alloc(file->guidhash_seg.len);
    memset(file->guidhash_seg.data, 0xFF, file->guidhash_seg.len);
}

Referenced by ICreateTypeLib2_fnSaveAllChanges().

WMSFT_compile_guids()

static HRESULT WMSFT_compile_guids ( ITypeLibImpl *  This, WMSFT_TLBFile *  file  )

static

Definition at line 9436 of file typelib.c.

{
    TLBGuid *guid;
    MSFT_GuidEntry *entry;
    DWORD offs;
    int hash_key, *guidhashtab;
 
    file->guid_seg.len = sizeof(MSFT_GuidEntry) * list_count(&This->guid_list);
    file->guid_seg.data = heap_alloc(file->guid_seg.len);
 
    entry = file->guid_seg.data;
    offs = 0;
    guidhashtab = file->guidhash_seg.data;
    LIST_FOR_EACH_ENTRY(guid, &This->guid_list, TLBGuid, entry){
        memcpy(&entry->guid, &guid->guid, sizeof(GUID));
        entry->hreftype = guid->hreftype;
 
        hash_key = hash_guid(&guid->guid);
        entry->next_hash = guidhashtab[hash_key];
        guidhashtab[hash_key] = offs;
 
        guid->offset = offs;
        offs += sizeof(MSFT_GuidEntry);
        ++entry;
    }
 
    return S_OK;
}

Referenced by ICreateTypeLib2_fnSaveAllChanges().

WMSFT_compile_impfile()

static void WMSFT_compile_impfile ( ITypeLibImpl *  This, WMSFT_TLBFile *  file  )

static

Definition at line 10143 of file typelib.c.

{
    TLBImpLib *implib;
    WMSFT_ImpFile *impfile;
    char *data;
    DWORD last_offs = 0;
 
    file->impfile_seg.len = 0;
    LIST_FOR_EACH_ENTRY(implib, &This->implib_list, TLBImpLib, entry){
        int size = 0;
 
        if(implib->name){
            WCHAR *path = wcsrchr(implib->name, '\\');
            if(path)
                ++path;
            else
                path = implib->name;
            size = WideCharToMultiByte(CP_ACP, 0, path, lstrlenW(path), NULL, 0, NULL, NULL);
            if (size == 0)
                ERR("failed to convert wide string: %s\n", debugstr_w(path));
        }
 
        size += sizeof(INT16);
        if (size % 4)
            size = (size + 4) & ~0x3;
        if (size < 8)
            size = 8;
 
        file->impfile_seg.len += sizeof(WMSFT_ImpFile) + size;
    }
 
    data = file->impfile_seg.data = heap_alloc(file->impfile_seg.len);
 
    LIST_FOR_EACH_ENTRY(implib, &This->implib_list, TLBImpLib, entry){
        int strlen = 0, size;
 
        impfile = (WMSFT_ImpFile*)data;
        impfile->guid_offs = implib->guid->offset;
        impfile->lcid = implib->lcid;
        impfile->version = (implib->wVersionMinor << 16) | implib->wVersionMajor;
 
        data += sizeof(WMSFT_ImpFile);
 
        if(implib->name){
            WCHAR *path= wcsrchr(implib->name, '\\');
            if(path)
                ++path;
            else
                path = implib->name;
            strlen = WideCharToMultiByte(CP_ACP, 0, path, lstrlenW(path),
                    data + sizeof(INT16), file->impfile_seg.len - last_offs - sizeof(INT16), NULL, NULL);
            if (strlen == 0)
                ERR("failed to convert wide string: %s\n", debugstr_w(path));
        }
 
        *((INT16*)data) = (strlen << 2) | 1; /* FIXME: is that a flag, or what? */
 
        size = strlen + sizeof(INT16);
        if (size % 4)
            size = (size + 4) & ~0x3;
        if (size < 8)
            size = 8;
        memset(data + sizeof(INT16) + strlen, 0x57, size - strlen - sizeof(INT16));
 
        data += size;
        implib->offset = last_offs;
        last_offs += size + sizeof(WMSFT_ImpFile);
    }
}

Referenced by WMSFT_compile_impinfo().

WMSFT_compile_impinfo()

static void WMSFT_compile_impinfo ( ITypeLibImpl *  This, WMSFT_TLBFile *  file  )

static

Definition at line 10213 of file typelib.c.

{
    MSFT_ImpInfo *info;
    TLBRefType *ref_type;
    UINT i = 0;
 
    WMSFT_compile_impfile(This, file);
 
    file->impinfo_seg.len = sizeof(MSFT_ImpInfo) * list_count(&This->ref_list);
    info = file->impinfo_seg.data = heap_alloc(file->impinfo_seg.len);
 
    LIST_FOR_EACH_ENTRY(ref_type, &This->ref_list, TLBRefType, entry){
        info->flags = i | ((ref_type->tkind & 0xFF) << 24);
        if(ref_type->index == TLB_REF_USE_GUID){
            info->flags |= MSFT_IMPINFO_OFFSET_IS_GUID;
            info->oGuid = ref_type->guid->offset;
        }else
            info->oGuid = ref_type->index;
        info->oImpFile = ref_type->pImpTLInfo->offset;
        ++i;
        ++info;
    }
}

Referenced by ICreateTypeLib2_fnSaveAllChanges().

WMSFT_compile_namehash()

static void WMSFT_compile_namehash ( ITypeLibImpl *  This, WMSFT_TLBFile *  file  )

static

Definition at line 10244 of file typelib.c.

{
    file->namehash_seg.len = 0x200;
    file->namehash_seg.data = heap_alloc(file->namehash_seg.len);
    memset(file->namehash_seg.data, 0xFF, file->namehash_seg.len);
}

Referenced by ICreateTypeLib2_fnSaveAllChanges().

WMSFT_compile_names()

static HRESULT WMSFT_compile_names ( ITypeLibImpl *  This, WMSFT_TLBFile *  file  )

static

Definition at line 9346 of file typelib.c.

{
    TLBString *str;
    UINT last_offs;
    char *data;
    MSFT_NameIntro *last_intro = NULL;
 
    file->header.nametablecount = 0;
    file->header.nametablechars = 0;
 
    file->name_seg.len = 0;
    LIST_FOR_EACH_ENTRY(str, &This->name_list, TLBString, entry) {
        int size;
 
        size = lstrlenW(str->str);
        file->header.nametablechars += size;
        file->header.nametablecount++;
 
        size = WideCharToMultiByte(CP_ACP, 0, str->str, size, NULL, 0, NULL, NULL);
        if (size == 0)
            return E_UNEXPECTED;
 
        size += sizeof(MSFT_NameIntro);
        if (size % 4)
            size = (size + 4) & ~0x3;
        if (size < 8)
            size = 8;
 
        file->name_seg.len += size;
 
        /* temporarily use str->offset to store the length of the aligned,
         * converted string */
        str->offset = size;
    }
 
    /* Allocate bigger buffer so we can temporarily NULL terminate the name */
    file->name_seg.data = data = heap_alloc(file->name_seg.len+1);
 
    last_offs = 0;
    LIST_FOR_EACH_ENTRY(str, &This->name_list, TLBString, entry) {
        int size, hash;
        MSFT_NameIntro *intro = (MSFT_NameIntro*)data;
 
        size = WideCharToMultiByte(CP_ACP, 0, str->str, lstrlenW(str->str),
                data + sizeof(MSFT_NameIntro),
                file->name_seg.len - last_offs - sizeof(MSFT_NameIntro), NULL, NULL);
        if (size == 0) {
            heap_free(file->name_seg.data);
            return E_UNEXPECTED;
        }
        data[sizeof(MSFT_NameIntro) + size] = '\0';
 
        intro->hreftype = -1; /* TODO? */
        intro->namelen = size & 0xFF;
        /* TODO: namelen & 0xFF00 == ??? maybe HREF type indicator? */
        hash = LHashValOfNameSysA(This->syskind, This->lcid, data + sizeof(MSFT_NameIntro));
        intro->namelen |= hash << 16;
        intro->next_hash = ((DWORD*)file->namehash_seg.data)[hash & 0x7f];
        ((DWORD*)file->namehash_seg.data)[hash & 0x7f] = last_offs;
 
        memset(data + sizeof(MSFT_NameIntro) + size, 0x57,
                str->offset - size - sizeof(MSFT_NameIntro));
 
        /* update str->offset to actual value to use in other
         * compilation functions that require positions within
         * the string table */
        last_intro = intro;
        size = str->offset;
        data += size;
        str->offset = last_offs;
        last_offs += size;
    }
 
    if(last_intro)
        last_intro->hreftype = 0; /* last one is 0? */
 
    return S_OK;
}

Referenced by ICreateTypeLib2_fnSaveAllChanges().

WMSFT_compile_strings()

static HRESULT WMSFT_compile_strings ( ITypeLibImpl *  This, WMSFT_TLBFile *  file  )

static

Definition at line 9292 of file typelib.c.

{
    TLBString *str;
    UINT last_offs;
    char *data;
 
    file->string_seg.len = 0;
    LIST_FOR_EACH_ENTRY(str, &This->string_list, TLBString, entry) {
        int size;
 
        size = WideCharToMultiByte(CP_ACP, 0, str->str, lstrlenW(str->str), NULL, 0, NULL, NULL);
        if (size == 0)
            return E_UNEXPECTED;
 
        size += sizeof(INT16);
        if (size % 4)
            size = (size + 4) & ~0x3;
        if (size < 8)
            size = 8;
 
        file->string_seg.len += size;
 
        /* temporarily use str->offset to store the length of the aligned,
         * converted string */
        str->offset = size;
    }
 
    file->string_seg.data = data = heap_alloc(file->string_seg.len);
 
    last_offs = 0;
    LIST_FOR_EACH_ENTRY(str, &This->string_list, TLBString, entry) {
        int size;
 
        size = WideCharToMultiByte(CP_ACP, 0, str->str, lstrlenW(str->str),
                data + sizeof(INT16), file->string_seg.len - last_offs - sizeof(INT16), NULL, NULL);
        if (size == 0) {
            heap_free(file->string_seg.data);
            return E_UNEXPECTED;
        }
 
        *((INT16*)data) = size;
 
        memset(data + sizeof(INT16) + size, 0x57, str->offset - size - sizeof(INT16));
 
        size = str->offset;
        data += size;
        str->offset = last_offs;
        last_offs += size;
    }
 
    return S_OK;
}

Referenced by ICreateTypeLib2_fnSaveAllChanges().

WMSFT_compile_typeinfo()

static DWORD WMSFT_compile_typeinfo ( ITypeInfoImpl *  info, INT16  index, WMSFT_TLBFile *  file, char *  data  )

static

Definition at line 10040 of file typelib.c.

{
    DWORD size;
 
    size = sizeof(MSFT_TypeInfoBase);
 
    if(data){
        MSFT_TypeInfoBase *base = (MSFT_TypeInfoBase*)data;
        if(info->typeattr.wTypeFlags & TYPEFLAG_FDUAL)
            base->typekind = TKIND_DISPATCH;
        else
            base->typekind = info->typeattr.typekind;
        base->typekind |= index << 16; /* TODO: There are some other flags here */
        base->typekind |= (info->typeattr.cbAlignment << 11) | (info->typeattr.cbAlignment << 6);
        base->memoffset = WMSFT_compile_typeinfo_aux(info, file);
        base->res2 = 0;
        base->res3 = 0;
        base->res4 = 3;
        base->res5 = 0;
        base->cElement = (info->typeattr.cVars << 16) | info->typeattr.cFuncs;
        base->res7 = 0;
        base->res8 = 0;
        base->res9 = 0;
        base->resA = 0;
        if(info->guid)
            base->posguid = info->guid->offset;
        else
            base->posguid = -1;
        base->flags = info->typeattr.wTypeFlags;
        if(info->Name) {
            base->NameOffset = info->Name->offset;
 
            ((unsigned char*)file->name_seg.data)[info->Name->offset+9] = 0x38;
            *(HREFTYPE*)((unsigned char*)file->name_seg.data+info->Name->offset) = info->hreftype;
        }else {
            base->NameOffset = -1;
        }
        base->version = (info->typeattr.wMinorVerNum << 16) | info->typeattr.wMajorVerNum;
        if(info->DocString)
            base->docstringoffs = info->DocString->offset;
        else
            base->docstringoffs = -1;
        base->helpstringcontext = info->dwHelpStringContext;
        base->helpcontext = info->dwHelpContext;
        base->oCustData = WMSFT_compile_custdata(info->pcustdata_list, file);
        base->cImplTypes = info->typeattr.cImplTypes;
        base->cbSizeVft = info->typeattr.cbSizeVft;
        base->size = info->typeattr.cbSizeInstance;
        if(info->typeattr.typekind == TKIND_COCLASS){
            base->datatype1 = WMSFT_compile_typeinfo_ref(info, file);
        }else if(info->typeattr.typekind == TKIND_ALIAS){
            base->datatype1 = WMSFT_append_typedesc(info->tdescAlias, file, NULL, NULL);
        }else if(info->typeattr.typekind == TKIND_MODULE){
            if(info->DllName)
                base->datatype1 = info->DllName->offset;
            else
                base->datatype1 = -1;
        }else{
            if(info->typeattr.cImplTypes > 0)
                base->datatype1 = info->impltypes[0].hRef;
            else
                base->datatype1 = -1;
        }
        base->datatype2 = index; /* FIXME: i think there's more here */
        base->res18 = 0;
        base->res19 = -1;
    }
 
    return size;
}

Referenced by WMSFT_compile_typeinfo_seg().

WMSFT_compile_typeinfo_aux()

static DWORD WMSFT_compile_typeinfo_aux ( ITypeInfoImpl *  info, WMSFT_TLBFile *  file  )

static

Definition at line 9707 of file typelib.c.

{
    WMSFT_SegContents *aux_seg = &file->aux_seg;
    DWORD ret = aux_seg->len, i, j, recorded_size = 0, extra_size = 0;
    MSFT_VarRecord *varrecord;
    MSFT_FuncRecord *funcrecord;
    MEMBERID *memid;
    DWORD *name, *offsets, offs;
 
    for(i = 0; i < info->typeattr.cFuncs; ++i){
        TLBFuncDesc *desc = &info->funcdescs[i];
 
        recorded_size += 6 * sizeof(INT); /* mandatory fields */
 
        /* optional fields */
        /* TODO: oArgCustData - FuncSetCustData not impl yet */
        if(!list_empty(&desc->custdata_list))
            recorded_size += 7 * sizeof(INT);
        else if(desc->HelpStringContext != 0)
            recorded_size += 6 * sizeof(INT);
        /* res9? resA? */
        else if(desc->Entry)
            recorded_size += 3 * sizeof(INT);
        else if(desc->HelpString)
            recorded_size += 2 * sizeof(INT);
        else if(desc->helpcontext)
            recorded_size += sizeof(INT);
 
        recorded_size += desc->funcdesc.cParams * sizeof(MSFT_ParameterInfo);
 
        for(j = 0; j < desc->funcdesc.cParams; ++j){
            if(desc->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT){
                recorded_size += desc->funcdesc.cParams * sizeof(INT);
                break;
            }
        }
 
        extra_size += 2 * sizeof(INT); /* memberid, name offs */
    }
 
    for(i = 0; i < info->typeattr.cVars; ++i){
        TLBVarDesc *desc = &info->vardescs[i];
 
        recorded_size += 5 * sizeof(INT); /* mandatory fields */
 
        /* optional fields */
        if(desc->HelpStringContext != 0)
            recorded_size += 5 * sizeof(INT);
        else if(!list_empty(&desc->custdata_list))
            recorded_size += 4 * sizeof(INT);
        /* res9? */
        else if(desc->HelpString)
            recorded_size += 2 * sizeof(INT);
        else if(desc->HelpContext != 0)
            recorded_size += sizeof(INT);
 
        extra_size += 2 * sizeof(INT); /* memberid, name offs */
    }
 
    if(!recorded_size && !extra_size)
        return ret;
 
    extra_size += sizeof(INT); /* total aux size for this typeinfo */
 
    aux_seg->len += recorded_size + extra_size;
 
    aux_seg->len += sizeof(INT) * (info->typeattr.cVars + info->typeattr.cFuncs); /* offsets at the end */
 
    if(aux_seg->data)
        aux_seg->data = heap_realloc(aux_seg->data, aux_seg->len);
    else
        aux_seg->data = heap_alloc(aux_seg->len);
 
    *((DWORD*)((char *)aux_seg->data + ret)) = recorded_size;
 
    offsets = (DWORD*)((char *)aux_seg->data + ret + recorded_size + extra_size);
    offs = 0;
 
    funcrecord = (MSFT_FuncRecord*)(((char *)aux_seg->data) + ret + sizeof(INT));
    for(i = 0; i < info->typeattr.cFuncs; ++i){
        TLBFuncDesc *desc = &info->funcdescs[i];
        DWORD size = 6 * sizeof(INT), paramdefault_size = 0, *paramdefault;
 
        funcrecord->funcdescsize = sizeof(desc->funcdesc) + desc->funcdesc.cParams * sizeof(ELEMDESC);
        funcrecord->DataType = WMSFT_append_typedesc(&desc->funcdesc.elemdescFunc.tdesc, file, NULL, &funcrecord->funcdescsize);
        funcrecord->Flags = desc->funcdesc.wFuncFlags;
        funcrecord->VtableOffset = desc->funcdesc.oVft;
 
        /* FKCCIC:
         * XXXX XXXX XXXX XXXX  XXXX XXXX XXXX XXXX
         *                                      ^^^funckind
         *                                 ^^^ ^invkind
         *                                ^has_cust_data
         *                           ^^^^callconv
         *                         ^has_param_defaults
         *                        ^oEntry_is_intresource
         */
        funcrecord->FKCCIC =
            desc->funcdesc.funckind |
            (desc->funcdesc.invkind << 3) |
            (list_empty(&desc->custdata_list) ? 0 : 0x80) |
            (desc->funcdesc.callconv << 8);
 
        if(desc->Entry && desc->Entry != (TLBString*)-1 && IS_INTRESOURCE(desc->Entry))
            funcrecord->FKCCIC |= 0x2000;
 
        for(j = 0; j < desc->funcdesc.cParams; ++j){
            if(desc->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT){
                paramdefault_size = sizeof(INT) * desc->funcdesc.cParams;
                funcrecord->funcdescsize += sizeof(PARAMDESCEX);
            }
        }
        if(paramdefault_size > 0)
            funcrecord->FKCCIC |= 0x1000;
 
        funcrecord->nrargs = desc->funcdesc.cParams;
        funcrecord->nroargs = desc->funcdesc.cParamsOpt;
 
        /* optional fields */
        /* res9? resA? */
        if(!list_empty(&desc->custdata_list)){
            size += 7 * sizeof(INT);
            funcrecord->HelpContext = desc->helpcontext;
            if(desc->HelpString)
                funcrecord->oHelpString = desc->HelpString->offset;
            else
                funcrecord->oHelpString = -1;
            if(!desc->Entry)
                funcrecord->oEntry = -1;
            else if(IS_INTRESOURCE(desc->Entry))
                funcrecord->oEntry = LOWORD(desc->Entry);
            else
                funcrecord->oEntry = desc->Entry->offset;
            funcrecord->res9 = -1;
            funcrecord->resA = -1;
            funcrecord->HelpStringContext = desc->HelpStringContext;
            funcrecord->oCustData = WMSFT_compile_custdata(&desc->custdata_list, file);
        }else if(desc->HelpStringContext != 0){
            size += 6 * sizeof(INT);
            funcrecord->HelpContext = desc->helpcontext;
            if(desc->HelpString)
                funcrecord->oHelpString = desc->HelpString->offset;
            else
                funcrecord->oHelpString = -1;
            if(!desc->Entry)
                funcrecord->oEntry = -1;
            else if(IS_INTRESOURCE(desc->Entry))
                funcrecord->oEntry = LOWORD(desc->Entry);
            else
                funcrecord->oEntry = desc->Entry->offset;
            funcrecord->res9 = -1;
            funcrecord->resA = -1;
            funcrecord->HelpStringContext = desc->HelpStringContext;
        }else if(desc->Entry){
            size += 3 * sizeof(INT);
            funcrecord->HelpContext = desc->helpcontext;
            if(desc->HelpString)
                funcrecord->oHelpString = desc->HelpString->offset;
            else
                funcrecord->oHelpString = -1;
            if(!desc->Entry)
                funcrecord->oEntry = -1;
            else if(IS_INTRESOURCE(desc->Entry))
                funcrecord->oEntry = LOWORD(desc->Entry);
            else
                funcrecord->oEntry = desc->Entry->offset;
        }else if(desc->HelpString){
            size += 2 * sizeof(INT);
            funcrecord->HelpContext = desc->helpcontext;
            funcrecord->oHelpString = desc->HelpString->offset;
        }else if(desc->helpcontext){
            size += sizeof(INT);
            funcrecord->HelpContext = desc->helpcontext;
        }
 
        paramdefault = (DWORD*)((char *)funcrecord + size);
        size += paramdefault_size;
 
        for(j = 0; j < desc->funcdesc.cParams; ++j){
            MSFT_ParameterInfo *info = (MSFT_ParameterInfo*)(((char *)funcrecord) + size);
 
            info->DataType = WMSFT_append_typedesc(&desc->funcdesc.lprgelemdescParam[j].tdesc, file, NULL, &funcrecord->funcdescsize);
            if(desc->pParamDesc[j].Name)
                info->oName = desc->pParamDesc[j].Name->offset;
            else
                info->oName = -1;
            info->Flags = desc->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags;
 
            if(paramdefault_size){
                if(desc->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
                    *paramdefault = WMSFT_encode_variant(&desc->funcdesc.lprgelemdescParam[j].u.paramdesc.pparamdescex->varDefaultValue, file);
                else if(paramdefault_size)
                    *paramdefault = -1;
                ++paramdefault;
            }
 
            size += sizeof(MSFT_ParameterInfo);
        }
 
        funcrecord->Info = size | (i << 16); /* is it just the index? */
 
        *offsets = offs;
        offs += size;
        ++offsets;
 
        funcrecord = (MSFT_FuncRecord*)(((char*)funcrecord) + size);
    }
 
    varrecord = (MSFT_VarRecord*)funcrecord;
    for(i = 0; i < info->typeattr.cVars; ++i){
        TLBVarDesc *desc = &info->vardescs[i];
        DWORD size = 5 * sizeof(INT);
 
        varrecord->vardescsize = sizeof(desc->vardesc);
        varrecord->DataType = WMSFT_append_typedesc(&desc->vardesc.elemdescVar.tdesc, file, NULL, &varrecord->vardescsize);
        varrecord->Flags = desc->vardesc.wVarFlags;
        varrecord->VarKind = desc->vardesc.varkind;
 
        if(desc->vardesc.varkind == VAR_CONST){
            varrecord->vardescsize += sizeof(VARIANT);
            varrecord->OffsValue = WMSFT_encode_variant(desc->vardesc.u.lpvarValue, file);
        }else
            varrecord->OffsValue = desc->vardesc.u.oInst;
 
        /* res9? */
        if(desc->HelpStringContext != 0){
            size += 5 * sizeof(INT);
            varrecord->HelpContext = desc->HelpContext;
            if(desc->HelpString)
                varrecord->HelpString = desc->HelpString->offset;
            else
                varrecord->HelpString = -1;
            varrecord->res9 = -1;
            varrecord->oCustData = WMSFT_compile_custdata(&desc->custdata_list, file);
            varrecord->HelpStringContext = desc->HelpStringContext;
        }else if(!list_empty(&desc->custdata_list)){
            size += 4 * sizeof(INT);
            varrecord->HelpContext = desc->HelpContext;
            if(desc->HelpString)
                varrecord->HelpString = desc->HelpString->offset;
            else
                varrecord->HelpString = -1;
            varrecord->res9 = -1;
            varrecord->oCustData = WMSFT_compile_custdata(&desc->custdata_list, file);
        }else if(desc->HelpString){
            size += 2 * sizeof(INT);
            varrecord->HelpContext = desc->HelpContext;
            if(desc->HelpString)
                varrecord->HelpString = desc->HelpString->offset;
            else
                varrecord->HelpString = -1;
        }else if(desc->HelpContext != 0){
            size += sizeof(INT);
            varrecord->HelpContext = desc->HelpContext;
        }
 
        varrecord->Info = size | (i << 16);
 
        *offsets = offs;
        offs += size;
        ++offsets;
 
        varrecord = (MSFT_VarRecord*)(((char*)varrecord) + size);
    }
 
    memid = (MEMBERID*)varrecord;
    for(i = 0; i < info->typeattr.cFuncs; ++i){
        TLBFuncDesc *desc = &info->funcdescs[i];
        *memid = desc->funcdesc.memid;
        ++memid;
    }
    for(i = 0; i < info->typeattr.cVars; ++i){
        TLBVarDesc *desc = &info->vardescs[i];
        *memid = desc->vardesc.memid;
        ++memid;
    }
 
    name = (UINT*)memid;
    for(i = 0; i < info->typeattr.cFuncs; ++i){
        TLBFuncDesc *desc = &info->funcdescs[i];
        if(desc->Name)
            *name = desc->Name->offset;
        else
            *name = -1;
        ++name;
    }
    for(i = 0; i < info->typeattr.cVars; ++i){
        TLBVarDesc *desc = &info->vardescs[i];
        if(desc->Name)
            *name = desc->Name->offset;
        else
            *name = -1;
        ++name;
    }
 
    return ret;
}

Referenced by WMSFT_compile_typeinfo().

WMSFT_compile_typeinfo_ref()

static DWORD WMSFT_compile_typeinfo_ref ( ITypeInfoImpl *  info, WMSFT_TLBFile *  file  )

static

Definition at line 10013 of file typelib.c.

{
    DWORD offs = file->ref_seg.len, i;
    WMSFT_RefChunk *chunk;
 
    file->ref_seg.len += info->typeattr.cImplTypes * sizeof(WMSFT_RefChunk);
    if(!file->ref_seg.data)
        file->ref_seg.data = heap_alloc(file->ref_seg.len);
    else
        file->ref_seg.data = heap_realloc(file->ref_seg.data, file->ref_seg.len);
 
    chunk = (WMSFT_RefChunk*)((char*)file->ref_seg.data + offs);
 
    for(i = 0; i < info->typeattr.cImplTypes; ++i){
        chunk->href = info->impltypes[i].hRef;
        chunk->res04 = info->impltypes[i].implflags;
        chunk->res08 = -1;
        if(i < info->typeattr.cImplTypes - 1)
            chunk->next = offs + sizeof(WMSFT_RefChunk) * (i + 1);
        else
            chunk->next = -1;
        ++chunk;
    }
 
    return offs;
}

Referenced by WMSFT_compile_typeinfo().

WMSFT_compile_typeinfo_seg()

static void WMSFT_compile_typeinfo_seg ( ITypeLibImpl *  This, WMSFT_TLBFile *  file, DWORD *  junk  )

static

Definition at line 10111 of file typelib.c.

{
    UINT i;
 
    file->typeinfo_seg.len = 0;
    for(i = 0; i < This->TypeInfoCount; ++i){
        ITypeInfoImpl *info = This->typeinfos[i];
        *junk = file->typeinfo_seg.len;
        ++junk;
        file->typeinfo_seg.len += WMSFT_compile_typeinfo(info, i, NULL, NULL);
    }
 
    file->typeinfo_seg.data = heap_alloc(file->typeinfo_seg.len);
    memset(file->typeinfo_seg.data, 0x96, file->typeinfo_seg.len);
 
    file->aux_seg.len = 0;
    file->aux_seg.data = NULL;
 
    file->typeinfo_seg.len = 0;
    for(i = 0; i < This->TypeInfoCount; ++i){
        ITypeInfoImpl *info = This->typeinfos[i];
        file->typeinfo_seg.len += WMSFT_compile_typeinfo(info, i, file,
                ((char *)file->typeinfo_seg.data) + file->typeinfo_seg.len);
    }
}

Referenced by ICreateTypeLib2_fnSaveAllChanges().

WMSFT_encode_variant()

static DWORD WMSFT_encode_variant ( VARIANT *  value, WMSFT_TLBFile *  file  )

static

Definition at line 9465 of file typelib.c.

{
    VARIANT v = *value;
    VARTYPE arg_type = V_VT(value);
    int mask = 0;
    HRESULT hres;
    DWORD ret = file->custdata_seg.len;
 
    if(arg_type == VT_INT)
        arg_type = VT_I4;
    if(arg_type == VT_UINT)
        arg_type = VT_UI4;
 
    v = *value;
    if(V_VT(value) != arg_type) {
        hres = VariantChangeType(&v, value, 0, arg_type);
        if(FAILED(hres)){
            ERR("VariantChangeType failed: %08x\n", hres);
            return -1;
        }
    }
 
    /* Check if default value can be stored in-place */
    switch(arg_type){
    case VT_I4:
    case VT_UI4:
        mask = 0x3ffffff;
        if(V_UI4(&v) > 0x3ffffff)
            break;
        /* fall through */
    case VT_I1:
    case VT_UI1:
    case VT_BOOL:
        if(!mask)
            mask = 0xff;
        /* fall through */
    case VT_I2:
    case VT_UI2:
        if(!mask)
            mask = 0xffff;
        return ((0x80 + 0x4 * V_VT(value)) << 24) | (V_UI4(&v) & mask);
    }
 
    /* have to allocate space in custdata_seg */
    switch(arg_type) {
    case VT_I4:
    case VT_R4:
    case VT_UI4:
    case VT_INT:
    case VT_UINT:
    case VT_HRESULT:
    case VT_PTR: {
        /* Construct the data to be allocated */
        int *data;
 
        if(file->custdata_seg.data){
            file->custdata_seg.data = heap_realloc(file->custdata_seg.data, file->custdata_seg.len + sizeof(int) * 2);
            data = (int *)(((char *)file->custdata_seg.data) + file->custdata_seg.len);
            file->custdata_seg.len += sizeof(int) * 2;
        }else{
            file->custdata_seg.len = sizeof(int) * 2;
            data = file->custdata_seg.data = heap_alloc(file->custdata_seg.len);
        }
 
        data[0] = V_VT(value) + (V_UI4(&v) << 16);
        data[1] = (V_UI4(&v) >> 16) + 0x57570000;
 
        /* TODO: Check if the encoded data is already present in custdata_seg */
 
        return ret;
    }
 
    case VT_BSTR: {
        int i, len = (6+SysStringLen(V_BSTR(&v))+3) & ~0x3;
        char *data;
 
        if(file->custdata_seg.data){
            file->custdata_seg.data = heap_realloc(file->custdata_seg.data, file->custdata_seg.len + len);
            data = ((char *)file->custdata_seg.data) + file->custdata_seg.len;
            file->custdata_seg.len += len;
        }else{
            file->custdata_seg.len = len;
            data = file->custdata_seg.data = heap_alloc(file->custdata_seg.len);
        }
 
        *((unsigned short *)data) = V_VT(value);
        *((unsigned int *)(data+2)) = SysStringLen(V_BSTR(&v));
        for(i=0; i<SysStringLen(V_BSTR(&v)); i++) {
            if(V_BSTR(&v)[i] <= 0x7f)
                data[i+6] = V_BSTR(&v)[i];
            else
                data[i+6] = '?';
        }
        WideCharToMultiByte(CP_ACP, 0, V_BSTR(&v), SysStringLen(V_BSTR(&v)), &data[6], len-6, NULL, NULL);
        for(i=6+SysStringLen(V_BSTR(&v)); i<len; i++)
            data[i] = 0x57;
 
        /* TODO: Check if the encoded data is already present in custdata_seg */
 
        return ret;
    }
    default:
        FIXME("Argument type not yet handled\n");
        return -1;
    }
}

Referenced by WMSFT_compile_custdata(), and WMSFT_compile_typeinfo_aux().

WMSFT_fixup_typeinfos()

static HRESULT WMSFT_fixup_typeinfos ( ITypeLibImpl *  This, WMSFT_TLBFile *  file, DWORD  file_len  )

static

Definition at line 10274 of file typelib.c.

{
    DWORD i;
    MSFT_TypeInfoBase *base = (MSFT_TypeInfoBase *)file->typeinfo_seg.data;
 
    for(i = 0; i < This->TypeInfoCount; ++i){
        base->memoffset += file_len;
        ++base;
    }
 
    return S_OK;
}

Referenced by ICreateTypeLib2_fnSaveAllChanges().

WMSFT_free_file()

static void WMSFT_free_file ( WMSFT_TLBFile *  file )

static

Definition at line 10288 of file typelib.c.

{
    HeapFree(GetProcessHeap(), 0, file->typeinfo_seg.data);
    HeapFree(GetProcessHeap(), 0, file->guidhash_seg.data);
    HeapFree(GetProcessHeap(), 0, file->guid_seg.data);
    HeapFree(GetProcessHeap(), 0, file->ref_seg.data);
    HeapFree(GetProcessHeap(), 0, file->impinfo_seg.data);
    HeapFree(GetProcessHeap(), 0, file->impfile_seg.data);
    HeapFree(GetProcessHeap(), 0, file->namehash_seg.data);
    HeapFree(GetProcessHeap(), 0, file->name_seg.data);
    HeapFree(GetProcessHeap(), 0, file->string_seg.data);
    HeapFree(GetProcessHeap(), 0, file->typdesc_seg.data);
    HeapFree(GetProcessHeap(), 0, file->arraydesc_seg.data);
    HeapFree(GetProcessHeap(), 0, file->custdata_seg.data);
    HeapFree(GetProcessHeap(), 0, file->cdguids_seg.data);
    HeapFree(GetProcessHeap(), 0, file->aux_seg.data);
}

Referenced by ICreateTypeLib2_fnSaveAllChanges().

WMSFT_write_segment()

static void WMSFT_write_segment ( HANDLE  outfile, WMSFT_SegContents *  segment  )

static

Definition at line 10267 of file typelib.c.

{
    DWORD written;
    if(segment)
        WriteFile(outfile, segment->data, segment->len, &written, NULL);
}

Referenced by ICreateTypeLib2_fnSaveAllChanges().

Variable Documentation

cache_section

static CRITICAL_SECTION cache_section = { &cache_section_debug, -1, 0, 0, 0, 0 }

static

Definition at line 2853 of file typelib.c.

Referenced by ITypeLib2_fnRelease(), and TLB_ReadTypeLib().

cache_section_debug

CRITICAL_SECTION_DEBUG cache_section_debug

static

Initial value:

=
{
    0, 0, &cache_section,
    { &cache_section_debug.ProcessLocksList, &cache_section_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": typelib loader cache") }
}

Definition at line 2854 of file typelib.c.

CreateTypeInfo2Vtbl

static const ICreateTypeInfo2Vtbl CreateTypeInfo2Vtbl

static

Definition at line 1301 of file typelib.c.

Referenced by ITypeInfoImpl_Constructor().

CreateTypeLib2Vtbl

static const ICreateTypeLib2Vtbl CreateTypeLib2Vtbl

static

Initial value:

= {
    ICreateTypeLib2_fnQueryInterface,
    ICreateTypeLib2_fnAddRef,
    ICreateTypeLib2_fnRelease,
    ICreateTypeLib2_fnCreateTypeInfo,
    ICreateTypeLib2_fnSetName,
    ICreateTypeLib2_fnSetVersion,
    ICreateTypeLib2_fnSetGuid,
    ICreateTypeLib2_fnSetDocString,
    ICreateTypeLib2_fnSetHelpFileName,
    ICreateTypeLib2_fnSetHelpContext,
    ICreateTypeLib2_fnSetLcid,
    ICreateTypeLib2_fnSetLibFlags,
    ICreateTypeLib2_fnSaveAllChanges,
    ICreateTypeLib2_fnDeleteTypeInfo,
    ICreateTypeLib2_fnSetCustData,
    ICreateTypeLib2_fnSetHelpStringContext,
    ICreateTypeLib2_fnSetHelpStringDll
}

Definition at line 1147 of file typelib.c.

Referenced by TypeLibImpl_Constructor().

FLAGSW

const WCHAR FLAGSW[] = {'F','L','A','G','S',0}

static

Definition at line 578 of file typelib.c.

Referenced by RegisterTypeLib(), and UnRegisterTypeLib().

HELPDIRW

const WCHAR HELPDIRW[] = {'H','E','L','P','D','I','R',0}

static

Definition at line 579 of file typelib.c.

Referenced by RegisterTypeLib(), and UnRegisterTypeLib().

ProxyStubClsid32W

const WCHAR ProxyStubClsid32W[] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0}

static

Definition at line 581 of file typelib.c.

Referenced by TLB_register_interface(), and TLB_unregister_interface().

ProxyStubClsidW

const WCHAR ProxyStubClsidW[] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d',0}

static

Definition at line 580 of file typelib.c.

Referenced by TLB_register_interface(), and TLB_unregister_interface().

std_typedesc

TYPEDESC std_typedesc[VT_LPWSTR+1]

static

Initial value:

=
{
    
    {{0}, VT_EMPTY},  {{0}, VT_NULL},        {{0}, VT_I2},      {{0}, VT_I4},
    {{0}, VT_R4},     {{0}, VT_R8},          {{0}, VT_CY},      {{0}, VT_DATE},
    {{0}, VT_BSTR},   {{0}, VT_DISPATCH},    {{0}, VT_ERROR},   {{0}, VT_BOOL},
    {{0}, VT_VARIANT},{{0}, VT_UNKNOWN},     {{0}, VT_DECIMAL}, {{0}, 15}, 
    {{0}, VT_I1},     {{0}, VT_UI1},         {{0}, VT_UI2},     {{0}, VT_UI4},
    {{0}, VT_I8},     {{0}, VT_UI8},         {{0}, VT_INT},     {{0}, VT_UINT},
    {{0}, VT_VOID},   {{0}, VT_HRESULT},     {{0}, VT_PTR},     {{0}, VT_SAFEARRAY},
    {{0}, VT_CARRAY}, {{0}, VT_USERDEFINED}, {{0}, VT_LPSTR},   {{0}, VT_LPWSTR}
}

Definition at line 1599 of file typelib.c.

Referenced by ITypeLib2_Constructor_MSFT().

tcompvt

static const ITypeCompVtbl tcompvt

static

Initial value:

=
{
 
    ITypeComp_fnQueryInterface,
    ITypeComp_fnAddRef,
    ITypeComp_fnRelease,
 
    ITypeComp_fnBind,
    ITypeComp_fnBindType
}

Definition at line 1300 of file typelib.c.

Referenced by ITypeInfoImpl_Constructor().

tinfvt

static const ITypeInfo2Vtbl tinfvt

static

Definition at line 1299 of file typelib.c.

Referenced by ITypeInfoImpl_Constructor().

tlb_cache

struct list tlb_cache = LIST_INIT(tlb_cache)

static

Definition at line 2852 of file typelib.c.

Referenced by TLB_ReadTypeLib().

TLB_Mapping_Vtable

const IUnknownVtbl TLB_Mapping_Vtable

static

Initial value:

=
{
    TLB_Mapping_QueryInterface,
    TLB_Mapping_AddRef,
    TLB_Mapping_Release
}

Definition at line 3235 of file typelib.c.

Referenced by TLB_Mapping_Open().

TLB_NEFile_Vtable

const IUnknownVtbl TLB_NEFile_Vtable

static

Initial value:

=
{
    TLB_NEFile_QueryInterface,
    TLB_NEFile_AddRef,
    TLB_NEFile_Release
}

Definition at line 3008 of file typelib.c.

Referenced by TLB_NEFile_Open().

TLB_PEFile_Vtable

const IUnknownVtbl TLB_PEFile_Vtable

static

Initial value:

=
{
    TLB_PEFile_QueryInterface,
    TLB_PEFile_AddRef,
    TLB_PEFile_Release
}

Definition at line 2911 of file typelib.c.

Referenced by TLB_PEFile_Open().

tlbtcvt

static const ITypeCompVtbl tlbtcvt

static

Initial value:

=
{
 
    ITypeLibComp_fnQueryInterface,
    ITypeLibComp_fnAddRef,
    ITypeLibComp_fnRelease,
 
    ITypeLibComp_fnBind,
    ITypeLibComp_fnBindType
}

Definition at line 1146 of file typelib.c.

Referenced by TypeLibImpl_Constructor().

tlbvt

static const ITypeLib2Vtbl tlbvt

static

Initial value:

= {
    ITypeLib2_fnQueryInterface,
    ITypeLib2_fnAddRef,
    ITypeLib2_fnRelease,
    ITypeLib2_fnGetTypeInfoCount,
    ITypeLib2_fnGetTypeInfo,
    ITypeLib2_fnGetTypeInfoType,
    ITypeLib2_fnGetTypeInfoOfGuid,
    ITypeLib2_fnGetLibAttr,
    ITypeLib2_fnGetTypeComp,
    ITypeLib2_fnGetDocumentation,
    ITypeLib2_fnIsName,
    ITypeLib2_fnFindName,
    ITypeLib2_fnReleaseTLibAttr,
 
    ITypeLib2_fnGetCustData,
    ITypeLib2_fnGetLibStatistics,
    ITypeLib2_fnGetDocumentation2,
    ITypeLib2_fnGetAllCustData
 }

Definition at line 1145 of file typelib.c.

Referenced by ICreateTypeInfo2_fnAddRefTypeInfo(), and TypeLibImpl_Constructor().

typekind_desc

const char* const typekind_desc[]

static

Initial value:

=
{
    "TKIND_ENUM",
    "TKIND_RECORD",
    "TKIND_MODULE",
    "TKIND_INTERFACE",
    "TKIND_DISPATCH",
    "TKIND_COCLASS",
    "TKIND_ALIAS",
    "TKIND_UNION",
    "TKIND_MAX"
}

Definition at line 1460 of file typelib.c.

Referenced by dump_TypeInfo(), ITypeLib2_Constructor_SLTG(), and MSFT_DoTypeInfo().

TypeLibW

const WCHAR TypeLibW[] = {'T','y','p','e','L','i','b',0}

static

Definition at line 577 of file typelib.c.

Referenced by TLB_register_interface(), and TLB_unregister_interface().