Implemented CreateStdDispatch and CreateDispTypeInfo.

dlls/oleaut32/Makefile.in

@@ -12,6 +12,8 @@ SYMBOLFILE = $(MODULE).tmp.o
 C_SRCS = \
 	connpt.c \
 	dispatch.c \
+	dispstd.c \
+	disptype.c \
 	hash.c \
 	ole2disp.c \
 	oleaut.c \

dlls/oleaut32/dispstd.c

+/*
+ * Copyright 2001 Hidenori Takeshima
+ *
+ *	FIXME - stub
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "config.h"
+
+#include "winerror.h"
+#include "winnls.h"         /* for PRIMARYLANGID */
+#include "winreg.h"         /* for HKEY_LOCAL_MACHINE */
+#include "winuser.h"
+#include "oleauto.h"
+
+#include "wine/debug.h"
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+typedef struct CStdDispImpl
+{
+	ICOM_VFIELD(IDispatch);
+	struct { ICOM_VFIELD(IUnknown); } unkimpl;
+	UINT ref;
+
+	IUnknown*	punk;
+	void*		pvThis;
+	ITypeInfo*	pti;
+} CStdDispImpl;
+
+static HRESULT CStdDispImpl_Construct(
+	CStdDispImpl* This,
+	IUnknown* punkOuter, void* pvThis, ITypeInfo* pti )
+{
+	This->punk = punkOuter;
+	This->pvThis = pvThis;
+	This->pti = pti; ITypeInfo_AddRef(pti);
+
+	return S_OK;
+}
+
+static void CStdDispImpl_Destruct(
+	CStdDispImpl* This )
+{
+	if ( This->pti != NULL )
+		ITypeInfo_Release(This->pti);
+}
+
+
+/****************************************************************************/
+
+
+static HRESULT WINAPI In_CStdDispImpl_fnQueryInterface(
+	IUnknown* iface,REFIID riid,void** ppvobj)
+{
+	CStdDispImpl* This = (CStdDispImpl*)(((BYTE*)iface)-offsetof(CStdDispImpl,unkimpl));
+
+	if ( IsEqualGUID(riid,&IID_IUnknown) )
+	{
+		*ppvobj = (void*)iface;
+		IUnknown_AddRef(iface);
+		return S_OK;
+	}
+	if ( IsEqualGUID(riid,&IID_IDispatch) )
+	{
+		*ppvobj = (void*)This;
+		IUnknown_AddRef((IUnknown*)This);
+		return S_OK;
+	}
+
+	return E_NOINTERFACE;
+}
+
+static ULONG WINAPI In_CStdDispImpl_fnAddRef(IUnknown* iface)
+{
+	CStdDispImpl* This = (CStdDispImpl*)(((BYTE*)iface)-offsetof(CStdDispImpl,unkimpl));
+
+	return ++ This->ref;
+}
+
+static ULONG WINAPI In_CStdDispImpl_fnRelease(IUnknown* iface)
+{
+	CStdDispImpl* This = (CStdDispImpl*)(((BYTE*)iface)-offsetof(CStdDispImpl,unkimpl));
+
+	if ( -- This->ref > 0 ) return This->ref;
+
+	++ This->ref;
+	CStdDispImpl_Destruct(This);
+	HeapFree(GetProcessHeap(),0,This);
+	return 0;
+}
+
+
+/****************************************************************************/
+
+
+
+static HRESULT WINAPI CStdDispImpl_fnQueryInterface(
+	IDispatch* iface,REFIID riid,void** ppvobj)
+{
+    ICOM_THIS(CStdDispImpl,iface);
+
+	return IUnknown_QueryInterface(This->punk,riid,ppvobj);
+}
+
+static ULONG WINAPI CStdDispImpl_fnAddRef(IDispatch* iface)
+{
+    ICOM_THIS(CStdDispImpl,iface);
+
+	return IUnknown_AddRef(This->punk);
+}
+
+static ULONG WINAPI CStdDispImpl_fnRelease(IDispatch* iface)
+{
+    ICOM_THIS(CStdDispImpl,iface);
+
+	return IUnknown_Release(This->punk);
+}
+
+
+static HRESULT WINAPI CStdDispImpl_fnGetTypeInfoCount(
+	IDispatch* iface,UINT* pctinfo)
+{
+    ICOM_THIS(CStdDispImpl,iface);
+
+	FIXME("(%p)\n",This);
+	if ( pctinfo == NULL ) return E_POINTER;
+	*pctinfo = 1;
+
+	return S_OK;
+}
+
+static HRESULT WINAPI CStdDispImpl_fnGetTypeInfo(
+	IDispatch* iface,
+	UINT itiindex,LCID lcid,ITypeInfo** ppti)
+{
+    ICOM_THIS(CStdDispImpl,iface);
+
+	FIXME("(%p)\n",This);
+
+	if ( ppti != NULL ) return E_POINTER;
+	*ppti = NULL;
+
+	if ( itiindex != 0 ) return DISP_E_BADINDEX;
+	/* lcid is ignored */
+	ITypeInfo_AddRef(This->pti);
+	*ppti = This->pti;
+
+	return S_OK;
+}
+
+static HRESULT WINAPI CStdDispImpl_fnGetIDsOfNames(
+	IDispatch* iface,
+	REFIID riid,LPOLESTR* ppwszNames,UINT cNames,LCID lcid,DISPID* pdispid)
+{
+    ICOM_THIS(CStdDispImpl,iface);
+
+	FIXME("(%p)\n",This);
+	return DispGetIDsOfNames(This->pti,ppwszNames,cNames,pdispid);
+}
+
+static HRESULT WINAPI CStdDispImpl_fnInvoke(
+	IDispatch* iface,
+	DISPID dispid,REFIID riid,LCID lcid,WORD wFlags,
+	DISPPARAMS* pDispParams,VARIANT* pVarResult,
+	EXCEPINFO* pExcepInfo,UINT* puArgErr)
+{
+    ICOM_THIS(CStdDispImpl,iface);
+
+	FIXME("(%p)\n",This);
+	return DispInvoke(This->pvThis,
+		This->pti,dispid,wFlags,
+		pDispParams,pVarResult,
+		pExcepInfo,puArgErr);
+}
+
+static ICOM_VTABLE(IUnknown) iunk =
+{
+	ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+
+	/* IUnknown */
+	In_CStdDispImpl_fnQueryInterface,
+	In_CStdDispImpl_fnAddRef,
+	In_CStdDispImpl_fnRelease,
+};
+
+static ICOM_VTABLE(IDispatch) idisp =
+{
+	ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+
+	/* IUnknown */
+	CStdDispImpl_fnQueryInterface,
+	CStdDispImpl_fnAddRef,
+	CStdDispImpl_fnRelease,
+	/* IDispatch */
+	CStdDispImpl_fnGetTypeInfoCount,
+	CStdDispImpl_fnGetTypeInfo,
+	CStdDispImpl_fnGetIDsOfNames,
+	CStdDispImpl_fnInvoke,
+};
+
+/*****************************************************************************/
+
+HRESULT WINAPI CreateStdDispatch(
+	IUnknown* punkOuter,
+	void* pvThis,
+	ITypeInfo* pti,
+	IUnknown** ppvobj )
+{
+	HRESULT hr;
+	CStdDispImpl*	This;
+
+	if ( punkOuter == NULL || pvThis == NULL ||
+	     pti == NULL || ppvobj == NULL )
+		return E_POINTER;
+
+	This = (CStdDispImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CStdDispImpl));
+	if ( This == NULL ) return E_OUTOFMEMORY;
+	ICOM_VTBL(This) = &idisp;
+	ICOM_VTBL(&(This->unkimpl)) = &iunk;
+	This->ref = 1;
+
+	hr = CStdDispImpl_Construct( This, punkOuter, pvThis, pti );
+	if ( FAILED(hr) )
+	{
+		IUnknown_Release((IUnknown*)(&This->unkimpl));
+		return hr;
+	}
+	*ppvobj = (IUnknown*)(&This->unkimpl);
+
+	return S_OK;
+}

dlls/oleaut32/disptype.c

+/*
+ * Copyright 2001 Hidenori Takeshima
+ *
+ *	FIXME - stub
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "config.h"
+
+#include "winerror.h"
+#include "winnls.h"         /* for PRIMARYLANGID */
+#include "winreg.h"         /* for HKEY_LOCAL_MACHINE */
+#include "winuser.h"
+#include "oleauto.h"
+
+#include "typelib.h"
+
+#include "wine/debug.h"
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+typedef struct CTypeInfo2Impl
+{
+	ICOM_VFIELD(ITypeInfo2);
+	UINT ref;
+
+	INTERFACEDATA	ifd;
+	LCID	lcid;
+} CTypeInfo2Impl;
+
+static OLECHAR* olestrdup(OLECHAR* psz)
+{
+	OLECHAR*	pret;
+	DWORD	cb;
+
+	cb = (lstrlenW(psz)+1) * sizeof(OLECHAR);
+	pret = (OLECHAR*)HeapAlloc( GetProcessHeap(), 0, cb );
+	if ( pret != NULL )
+		memcpy( pret, psz, cb );
+	return pret;
+}
+
+static HRESULT CTypeInfo2Impl_Construct(
+	CTypeInfo2Impl* This,INTERFACEDATA* pifd,LCID lcid)
+{
+	DWORD	n,k;
+	METHODDATA*	pmdst;
+	const METHODDATA*	pmsrc;
+	PARAMDATA*	pPdst;
+	const PARAMDATA*	pPsrc;
+
+	This->ifd.pmethdata = (METHODDATA*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(METHODDATA)*pifd->cMembers);
+	if ( This->ifd.pmethdata == NULL ) return E_OUTOFMEMORY;
+	This->ifd.cMembers = pifd->cMembers;
+	for ( n = 0; n < pifd->cMembers; n++ )
+	{
+		pmdst = &This->ifd.pmethdata[n];
+		pmsrc = &pifd->pmethdata[n];
+
+		pmdst->szName = olestrdup(pmsrc->szName);
+		if ( pmdst->szName == NULL ) return E_OUTOFMEMORY;
+		pmdst->ppdata = NULL;
+		pmdst->dispid = pmsrc->dispid;
+		pmdst->iMeth = pmsrc->iMeth;
+		pmdst->cc = pmsrc->cc;
+		pmdst->cArgs = pmsrc->cArgs;
+		pmdst->wFlags = pmsrc->wFlags;
+		pmdst->vtReturn = pmsrc->vtReturn;
+
+		if ( pmsrc->cArgs <= 0 ) continue;
+		pmdst->ppdata = (PARAMDATA*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(PARAMDATA)*pmsrc->cArgs);
+		if ( pmdst->ppdata == NULL ) return E_OUTOFMEMORY;
+
+		for ( k = 0; k < pmsrc->cArgs; k++ )
+		{
+			pPdst = &pmdst->ppdata[k];
+			pPsrc = &pmsrc->ppdata[k];
+			pPdst->szName = olestrdup(pPsrc->szName);
+			if ( pPdst->szName == NULL ) return E_OUTOFMEMORY;
+			pPdst->vt = pPsrc->vt;
+		}
+	}
+
+	This->lcid = lcid;
+
+	return S_OK;
+}
+
+static void CTypeInfo2Impl_Destruct(CTypeInfo2Impl* This)
+{
+	DWORD	n,k;
+	METHODDATA*	pm;
+	PARAMDATA*	pP;
+
+	if ( This->ifd.pmethdata != NULL )
+	{
+		for ( n = 0; n < This->ifd.cMembers; n++ )
+		{
+			pm = &This->ifd.pmethdata[n];
+			if ( pm->szName != NULL )
+				HeapFree(GetProcessHeap(),0,pm->szName);
+			if ( pm->ppdata == NULL ) continue;
+
+			for ( k = 0; k < pm->cArgs; k++ )
+			{
+				pP = &pm->ppdata[k];
+				if ( pP->szName != NULL )
+					HeapFree(GetProcessHeap(),0,pP->szName);
+			}
+			HeapFree(GetProcessHeap(),0,pm->ppdata);
+		}
+		HeapFree(GetProcessHeap(),0,This->ifd.pmethdata);
+		This->ifd.pmethdata = NULL;
+	}
+}
+
+/****************************************************************************/
+
+static const METHODDATA* CTypeInfo2Impl_SearchMethodByName(
+	CTypeInfo2Impl* This,const OLECHAR* pName)
+{
+	DWORD	n;
+	METHODDATA*	pm;
+
+	for ( n = 0; n < This->ifd.cMembers; n++ )
+	{
+		pm = &This->ifd.pmethdata[n];
+		if ( !lstrcmpiW(pm->szName,pName) )
+			return pm;
+	}
+
+	return NULL;
+}
+
+static const METHODDATA* CTypeInfo2Impl_SearchMethodByDispIDAndFlags(
+	CTypeInfo2Impl* This,DISPID dispid,UINT16 wFlags)
+{
+	DWORD	n;
+	METHODDATA*	pm;
+
+	for ( n = 0; n < This->ifd.cMembers; n++ )
+	{
+		pm = &This->ifd.pmethdata[n];
+		if ( (pm->dispid == dispid) && (pm->wFlags & wFlags) )
+			return pm;
+	}
+
+	return NULL;
+}
+
+
+static int CTypeInfo2Impl_SearchParamByName(
+	const METHODDATA* pm,const OLECHAR* pName)
+{
+	PARAMDATA*	pP;
+	DWORD	k;
+
+	for ( k = 0; k < pm->cArgs; k++ )
+	{
+		pP = &pm->ppdata[k];
+		if ( !lstrcmpiW(pP->szName,pName) )
+			return (int)k;
+	}
+
+	return -1;
+}
+
+
+/****************************************************************************/
+
+static HRESULT WINAPI CTypeInfo2Impl_fnQueryInterface(
+	ITypeInfo2* iface,REFIID riid,void** ppvobj)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
+
+    *ppvobj = NULL;
+	if ( IsEqualIID(riid, &IID_IUnknown) ||
+	     IsEqualIID(riid, &IID_ITypeInfo) ||
+	     IsEqualIID(riid, &IID_ITypeInfo2) )
+	{
+		*ppvobj = (void*)iface;
+		ITypeInfo2_AddRef(iface);
+		return S_OK;
+	}
+
+	return E_NOINTERFACE;
+}
+
+static ULONG WINAPI CTypeInfo2Impl_fnAddRef(ITypeInfo2* iface)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+	return ++ This->ref;
+}
+
+static ULONG WINAPI CTypeInfo2Impl_fnRelease(ITypeInfo2* iface)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+	if ( -- This->ref > 0 ) return This->ref;
+
+	++ This->ref;
+	CTypeInfo2Impl_Destruct(This);
+	HeapFree(GetProcessHeap(),0,This);
+	return 0;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetTypeAttr(
+	ITypeInfo2* iface,LPTYPEATTR* ppTypeAttr)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+    TYPEATTR*	pta;
+
+    FIXME("(%p)\n",This);
+
+	if ( ppTypeAttr == NULL )
+		return E_POINTER;
+	pta = (TYPEATTR*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TYPEATTR));
+	if ( pta == NULL ) return E_OUTOFMEMORY;
+
+	/* FIXME!!! */
+	pta->lcid = This->lcid;
+	pta->memidConstructor = MEMBERID_NIL;
+	pta->memidDestructor = MEMBERID_NIL;
+	pta->lpstrSchema = NULL;
+	pta->cbSizeInstance = 0;
+	pta->typekind = 0;
+	pta->cFuncs = This->ifd.cMembers;
+	pta->cVars = 0;
+	pta->cImplTypes = 1;
+	pta->cbSizeVft = sizeof(DWORD)*This->ifd.cMembers;
+	pta->cbAlignment = sizeof(DWORD);
+	pta->wTypeFlags = 0;
+	pta->wMajorVerNum = 1;
+	pta->wMinorVerNum = 0;
+	ZeroMemory( &pta->idldescType, sizeof(pta->idldescType) );
+
+	*ppTypeAttr = pta;
+	return S_OK;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetTypeComp(
+	ITypeInfo2* iface,ITypeComp** ppTComp)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetFuncDesc(
+	ITypeInfo2* iface,UINT index,LPFUNCDESC* ppFuncDesc)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetVarDesc(
+	ITypeInfo2* iface,UINT index,LPVARDESC* ppVarDesc)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetNames(
+	ITypeInfo2* iface, MEMBERID memid,BSTR* rgBstrNames,
+	UINT cMaxNames, UINT* pcNames)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetRefTypeOfImplType(
+	ITypeInfo2* iface,UINT index,HREFTYPE* pRefType)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetImplTypeFlags(
+	ITypeInfo2* iface,UINT index,INT* pImplTypeFlags)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetIDsOfNames(
+	ITypeInfo2* iface,LPOLESTR* rgszNames,UINT cNames,MEMBERID* pMemId)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+	const METHODDATA*	pm;
+	DWORD	n;
+	int	index;
+
+	TRACE("(%p,%s,%u,%p)\n",This,debugstr_w(*rgszNames),cNames,pMemId);
+
+	if ( rgszNames == NULL || pMemId == NULL ) return E_POINTER;
+	if ( cNames <= 0 ) return E_INVALIDARG;
+	for ( n = 0; n < cNames; n++ )
+	{
+		if ( rgszNames[n] == NULL ) return E_POINTER;
+	}
+
+	pm = CTypeInfo2Impl_SearchMethodByName(This,rgszNames[0]);
+	if ( pm == NULL ) return DISP_E_UNKNOWNNAME;
+	pMemId[0] = (MEMBERID)pm->dispid;
+
+	for ( n = 1; n < cNames; n++ )
+	{
+		index = CTypeInfo2Impl_SearchParamByName(pm,rgszNames[n]);
+		if ( index < 0 ) return DISP_E_UNKNOWNNAME;
+		pMemId[n] = (MEMBERID)index;
+	}
+
+	return S_OK;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnInvoke(
+	ITypeInfo2* iface,VOID* punk,MEMBERID memid,
+	UINT16 wFlags,DISPPARAMS* pDispParams,VARIANT* pVarResult,
+	EXCEPINFO* pExcepInfo,UINT* pArgErr)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+	const METHODDATA*	pm;
+	DWORD	res;
+	HRESULT hr;
+	int		n;
+	DWORD	cargs;
+	DWORD*	pargs = NULL;
+	VARIANT	varError;
+	VARIANT	varRet;
+
+	FIXME("(%p,%p,%ld,%08x,%p,%p,%p,%p)\n",
+		This,punk,(long)memid,(int)wFlags,
+		pDispParams,pVarResult,pExcepInfo,pArgErr);
+
+	if ( punk == NULL || pArgErr == NULL )
+		return E_POINTER;
+
+	pm = CTypeInfo2Impl_SearchMethodByDispIDAndFlags(
+		This,memid,wFlags);
+	if ( pm == NULL )
+	{
+		ERR("did not find member id %ld, flags %d!\n", (long)memid, (int)wFlags);
+		return DISP_E_MEMBERNOTFOUND;
+	}
+
+	cargs = pm->cArgs + 1;
+	pargs = (DWORD*)HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD)*(pm->cArgs+2) );
+	if ( pargs == NULL ) { hr = E_OUTOFMEMORY; goto err_invoke; }
+
+	V_VT(&varError) = VT_ERROR;
+	pargs[0] = (DWORD)punk;
+	for ( n = 1; n <= (int)pm->cArgs; n++ )
+		pargs[n] = (DWORD)&varError; /* FIXME? */
+
+	if ( (int)pDispParams->cArgs > (int)pm->cArgs )
+	{
+		hr = E_FAIL; /* FIXME? */
+		goto err_invoke;
+	}
+
+	for ( n = 1; n <= (int)pm->cArgs; n++ )
+	{
+		if ( n <= (int)pDispParams->cNamedArgs )
+		{
+			/* FIXME - handle named args. */
+			/* FIXME - check types. */
+
+			/* pDispParams->rgdispidNamedArgs */
+			/* pDispParams->cNamedArgs */
+			FIXME("named args - %d\n",n);
+			pargs[n] = V_UNION(&pDispParams->rgvarg[pDispParams->cArgs-n],lVal);
+		}
+		else
+		{
+			/* FIXME - check types. */
+			pargs[n] = V_UNION(&pDispParams->rgvarg[pDispParams->cArgs-n],lVal);
+		}
+	}
+
+	VariantInit( &varRet );
+	if ( pm->vtReturn != VT_EMPTY &&
+		 (!(wFlags & (DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF))) )
+	{
+		if ( pVarResult != NULL )
+		{
+			pargs[cargs] = (DWORD)pVarResult;
+		}
+		else
+		{
+			pargs[cargs] = (DWORD)(&varRet);
+		}
+		cargs ++;
+	}
+
+	res = _invoke(
+		(*(DWORD***)punk)[pm->iMeth],
+		pm->cc, cargs, pargs );
+	VariantClear( &varRet );
+
+	if ( res == (DWORD)-1 ) /* FIXME? */
+	{
+		hr = E_FAIL;
+		goto err_invoke;
+	}
+
+	hr = S_OK;
+err_invoke:
+	HeapFree( GetProcessHeap(), 0, pargs );
+
+	return hr;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetDocumentation(
+	ITypeInfo2* iface,
+	MEMBERID memid, BSTR* pBstrName, BSTR* pBstrDocString,
+	DWORD* pdwHelpContext, BSTR* pBstrHelpFile)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetDllEntry(
+	ITypeInfo2* iface,MEMBERID memid,
+	INVOKEKIND invKind,BSTR* pBstrDllName,BSTR* pBstrName,
+	WORD* pwOrdinal)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetRefTypeInfo(
+	ITypeInfo2* iface,HREFTYPE hRefType,ITypeInfo** ppTInfo)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnAddressOfMember(
+	ITypeInfo2 *iface,
+	MEMBERID memid,INVOKEKIND invKind,PVOID* ppv)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnCreateInstance(
+	ITypeInfo2* iface,
+	IUnknown* punk,REFIID riid,VOID** ppvObj)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetMops(
+	ITypeInfo2* iface,MEMBERID memid,BSTR* pBstrMops)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetContainingTypeLib(
+	ITypeInfo2* iface,ITypeLib** ppTLib,UINT* pIndex)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnReleaseTypeAttr(
+	ITypeInfo2* iface,TYPEATTR* pTypeAttr)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p)\n",This);
+
+	if ( pTypeAttr != NULL )
+		HeapFree(GetProcessHeap(),0,pTypeAttr);
+
+	return S_OK;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnReleaseFuncDesc(
+	ITypeInfo2* iface,FUNCDESC* pFuncDesc)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnReleaseVarDesc(
+	ITypeInfo2* iface,VARDESC* pVarDesc)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetTypeKind(
+	ITypeInfo2* iface,TYPEKIND* pTypeKind)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetTypeFlags(
+	ITypeInfo2* iface,UINT* pTypeFlags)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetFuncIndexOfMemId(
+	ITypeInfo2* iface,
+    MEMBERID memid,INVOKEKIND invKind,UINT* pFuncIndex)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetVarIndexOfMemId(
+	ITypeInfo2* iface,
+    MEMBERID memid,UINT* pVarIndex)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetCustData(
+	ITypeInfo2* iface,REFGUID guid,VARIANT* pVarVal)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetFuncCustData(
+	ITypeInfo2* iface,UINT index,REFGUID guid,VARIANT* pVarVal)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetParamCustData(
+	ITypeInfo2* iface,UINT indexFunc,UINT indexParam,
+	REFGUID guid,VARIANT* pVarVal)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetVarCustData(
+	ITypeInfo2* iface,UINT index,REFGUID guid,VARIANT* pVarVal)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetImplTypeCustData(
+	ITypeInfo2 * iface,UINT index,REFGUID guid,VARIANT* pVarVal)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetDocumentation2(
+	ITypeInfo2* iface,MEMBERID memid,LCID lcid,
+	BSTR* pbstrHelpString,DWORD* pdwHelpStringContext,BSTR* pbstrHelpStringDll)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetAllCustData(
+	ITypeInfo2* iface,CUSTDATA* pCustData)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetAllFuncCustData(
+	ITypeInfo2* iface,UINT index,CUSTDATA* pCustData)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetAllParamCustData(
+	ITypeInfo2* iface,UINT indexFunc,UINT indexParam,CUSTDATA* pCustData)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetAllVarCustData(
+	ITypeInfo2* iface,UINT index,CUSTDATA* pCustData)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static HRESULT WINAPI CTypeInfo2Impl_fnGetAllImplTypeCustData(
+	ITypeInfo2* iface,UINT index,CUSTDATA* pCustData)
+{
+    ICOM_THIS(CTypeInfo2Impl,iface);
+
+    FIXME("(%p) stub!\n",This);
+
+	return E_NOTIMPL;
+}
+
+static ICOM_VTABLE(ITypeInfo2) itypeinfo2 =
+{
+	ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+
+	/* IUnknown */
+    CTypeInfo2Impl_fnQueryInterface,
+    CTypeInfo2Impl_fnAddRef,
+    CTypeInfo2Impl_fnRelease,
+	/* ITypeInfo */
+    CTypeInfo2Impl_fnGetTypeAttr,
+    CTypeInfo2Impl_fnGetTypeComp,
+    CTypeInfo2Impl_fnGetFuncDesc,
+    CTypeInfo2Impl_fnGetVarDesc,
+    CTypeInfo2Impl_fnGetNames,
+    CTypeInfo2Impl_fnGetRefTypeOfImplType,
+    CTypeInfo2Impl_fnGetImplTypeFlags,
+    CTypeInfo2Impl_fnGetIDsOfNames,
+    CTypeInfo2Impl_fnInvoke,
+    CTypeInfo2Impl_fnGetDocumentation,
+    CTypeInfo2Impl_fnGetDllEntry,
+    CTypeInfo2Impl_fnGetRefTypeInfo,
+    CTypeInfo2Impl_fnAddressOfMember,
+    CTypeInfo2Impl_fnCreateInstance,
+    CTypeInfo2Impl_fnGetMops,
+    CTypeInfo2Impl_fnGetContainingTypeLib,
+    CTypeInfo2Impl_fnReleaseTypeAttr,
+    CTypeInfo2Impl_fnReleaseFuncDesc,
+    CTypeInfo2Impl_fnReleaseVarDesc,
+	/* ITypeInfo2 */
+    CTypeInfo2Impl_fnGetTypeKind,
+    CTypeInfo2Impl_fnGetTypeFlags,
+    CTypeInfo2Impl_fnGetFuncIndexOfMemId,
+    CTypeInfo2Impl_fnGetVarIndexOfMemId,
+    CTypeInfo2Impl_fnGetCustData,
+    CTypeInfo2Impl_fnGetFuncCustData,
+    CTypeInfo2Impl_fnGetParamCustData,
+    CTypeInfo2Impl_fnGetVarCustData,
+    CTypeInfo2Impl_fnGetImplTypeCustData,
+    CTypeInfo2Impl_fnGetDocumentation2,
+    CTypeInfo2Impl_fnGetAllCustData,
+    CTypeInfo2Impl_fnGetAllFuncCustData,
+    CTypeInfo2Impl_fnGetAllParamCustData,
+    CTypeInfo2Impl_fnGetAllVarCustData,
+    CTypeInfo2Impl_fnGetAllImplTypeCustData,
+};
+
+/*****************************************************************************/
+
+HRESULT WINAPI CreateDispTypeInfo(
+	INTERFACEDATA* pifd,
+	LCID lcid,
+	ITypeInfo** ppinfo )
+{
+	HRESULT hr;
+	CTypeInfo2Impl*	This;
+
+	if ( ppinfo == NULL )
+		return E_POINTER;
+
+	This = (CTypeInfo2Impl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CTypeInfo2Impl));
+	if ( This == NULL ) return E_OUTOFMEMORY;
+	ICOM_VTBL(This) = &itypeinfo2;
+	This->ref = 1;
+
+	hr = CTypeInfo2Impl_Construct(This,pifd,lcid);
+	if ( FAILED(hr) )
+	{
+		IUnknown_Release((IUnknown*)This);
+		return hr;
+	}
+	*ppinfo = (ITypeInfo*)This;
+
+	return S_OK;
+}

dlls/oleaut32/ole2disp.c

@@ -364,18 +364,6 @@ HRESULT WINAPI CreateDispTypeInfo16(
 }
 
 /******************************************************************************
- * CreateDispTypeInfo [OLEAUT32.31]
- */
-HRESULT WINAPI CreateDispTypeInfo(
-	INTERFACEDATA *pidata,
-	LCID lcid,
-	ITypeInfo **pptinfo)
-{
-	FIXME("(%p,%ld,%p),stub\n",pidata,lcid,pptinfo);
-	return 0;
-}
-
-/******************************************************************************
  * CreateStdDispatch [OLE2DISP.32]
  */
 HRESULT WINAPI CreateStdDispatch16(
@@ -390,20 +378,6 @@ HRESULT WINAPI CreateStdDispatch16(
 }
 
 /******************************************************************************
- * CreateStdDispatch [OLEAUT32.32]
- */
-HRESULT WINAPI CreateStdDispatch(
-        IUnknown* punkOuter,
-        void* pvThis,
-	ITypeInfo* ptinfo,
-	IUnknown** ppunkStdDisp)
-{
-	FIXME("(%p,%p,%p,%p),stub\n",punkOuter, pvThis, ptinfo,
-               ppunkStdDisp);
-	return 0;
-}
-
-/******************************************************************************
  * RegisterActiveObject [OLE2DISP.35]
  */
 HRESULT WINAPI RegisterActiveObject16(