#ifdef __i386__
#include "pshpack1.h"
-
typedef struct _TMAsmProxy {
DWORD lealeax;
BYTE pushleax;
WORD bytestopop;
WORD nop;
} TMAsmProxy;
+#include "poppack.h"
+
+#elif defined(__x86_64__)
+#include "pshpack1.h"
+typedef struct _TMAsmProxy {
+ BYTE pushq_rbp;
+ BYTE movq_rsp_rbp[3];
+ DWORD subq_0x20_rsp;
+ DWORD movq_rcx_0x10rbp;
+ DWORD movq_rdx_0x18rbp;
+ DWORD movq_r8_0x20rbp;
+ DWORD movq_r9_0x28rbp;
+ BYTE movq_rcx[3];
+ DWORD nr;
+ DWORD leaq_0x10rbp_rdx;
+ WORD movq_rax;
+ void *xcall;
+ WORD callq_rax;
+ BYTE movq_rbp_rsp[3];
+ BYTE popq_rbp;
+ BYTE ret;
+ DWORD nop;
+} TMAsmProxy;
#include "poppack.h"
#else /* __i386__ */
TMProxyImpl_Disconnect
};
-/* how much space do we use on stack in DWORD steps. */
+/* how much space do we use on stack in DWORD_PTR steps. */
static int
_argsize(TYPEDESC *tdesc, ITypeInfo *tinfo) {
+ DWORD ret;
switch (tdesc->vt) {
case VT_I8:
case VT_UI8:
- return 8/sizeof(DWORD);
+ ret = 8;
+ break;
case VT_R8:
- return sizeof(double)/sizeof(DWORD);
+ ret = sizeof(double);
+ break;
case VT_CY:
- return sizeof(CY)/sizeof(DWORD);
+ ret = sizeof(CY);
+ break;
case VT_DATE:
- return sizeof(DATE)/sizeof(DWORD);
+ ret = sizeof(DATE);
+ break;
case VT_DECIMAL:
- return (sizeof(DECIMAL)+3)/sizeof(DWORD);
+ ret = sizeof(DECIMAL);
+ break;
case VT_VARIANT:
- return (sizeof(VARIANT)+3)/sizeof(DWORD);
+ ret = sizeof(VARIANT);
+ break;
case VT_USERDEFINED:
{
ITypeInfo *tinfo2;
TYPEATTR *tattr;
HRESULT hres;
- DWORD ret;
hres = ITypeInfo_GetRefTypeInfo(tinfo,tdesc->u.hreftype,&tinfo2);
if (FAILED(hres))
return 0; /* should fail critically in serialize_param */
ITypeInfo_GetTypeAttr(tinfo2,&tattr);
- ret = (tattr->cbSizeInstance+3)/sizeof(DWORD);
+ ret = tattr->cbSizeInstance;
ITypeInfo_ReleaseTypeAttr(tinfo2, tattr);
ITypeInfo_Release(tinfo2);
- return ret;
+ break;
}
default:
- return 1;
+ ret = sizeof(DWORD_PTR);
+ break;
}
+
+ return (ret + sizeof(DWORD_PTR) - 1) / sizeof(DWORD_PTR);
}
/* how much space do we use on the heap (in bytes) */
return ret;
}
default:
- return 4;
+ return sizeof(DWORD_PTR);
}
}
BOOL debugout,
BOOL dealloc,
TYPEDESC *tdesc,
- DWORD *arg,
+ DWORD_PTR *arg,
marshal_state *buf)
{
HRESULT hres = S_OK;
case VT_R8:
case VT_CY:
hres = S_OK;
- if (debugout) TRACE_(olerelay)("%x%x\n",arg[0],arg[1]);
+ if (debugout) TRACE_(olerelay)("%s\n", wine_dbgstr_longlong(*(ULONGLONG *)arg));
if (writeit)
hres = xbuf_add(buf,(LPBYTE)arg,8);
return hres;
case VT_R4:
case VT_UI4:
hres = S_OK;
- if (debugout) TRACE_(olerelay)("%x\n",*arg);
+ if (debugout) TRACE_(olerelay)("%x\n", *(DWORD *)arg);
if (writeit)
hres = xbuf_add(buf,(LPBYTE)arg,sizeof(DWORD));
return hres;
case VT_UI2:
case VT_BOOL:
hres = S_OK;
- if (debugout) TRACE_(olerelay)("%04x\n",*arg & 0xffff);
+ if (debugout) TRACE_(olerelay)("%04x\n", *(WORD *)arg);
if (writeit)
hres = xbuf_add(buf,(LPBYTE)arg,sizeof(DWORD));
return hres;
case VT_I1:
case VT_UI1:
hres = S_OK;
- if (debugout) TRACE_(olerelay)("%02x\n",*arg & 0xff);
+ if (debugout) TRACE_(olerelay)("%02x\n", *(BYTE *)arg);
if (writeit)
hres = xbuf_add(buf,(LPBYTE)arg,sizeof(DWORD));
return hres;
return hres;
}
ITypeInfo_GetTypeAttr(tinfo2,&tattr);
- derefhere = (tattr->typekind != TKIND_DISPATCH && tattr->typekind != TKIND_INTERFACE);
+ derefhere = (tattr->typekind != TKIND_DISPATCH &&
+ tattr->typekind != TKIND_INTERFACE &&
+ tattr->typekind != TKIND_COCLASS);
}
break;
case TKIND_ENUM: /* confirmed */
break;
case TKIND_DISPATCH: /* will be done in VT_USERDEFINED case */
case TKIND_INTERFACE: /* will be done in VT_USERDEFINED case */
+ case TKIND_COCLASS: /* will be done in VT_USERDEFINED case */
derefhere=FALSE;
break;
default:
if (debugout) TRACE_(olerelay)("NULL");
return S_OK;
}
- hres = serialize_param(tinfo,writeit,debugout,dealloc,tdesc->u.lptdesc,(DWORD*)*arg,buf);
+ hres = serialize_param(tinfo,writeit,debugout,dealloc,tdesc->u.lptdesc,(DWORD_PTR *)*arg,buf);
if (derefhere && dealloc) HeapFree(GetProcessHeap(),0,(LPVOID)*arg);
return hres;
}
case VT_UNKNOWN:
- if (debugout) TRACE_(olerelay)("unk(0x%x)",*arg);
+ if (debugout) TRACE_(olerelay)("unk(0x%lx)", *arg);
if (writeit)
hres = _marshal_interface(buf,&IID_IUnknown,(LPUNKNOWN)*arg);
if (dealloc && *(IUnknown **)arg)
IUnknown_Release((LPUNKNOWN)*arg);
return hres;
case VT_DISPATCH:
- if (debugout) TRACE_(olerelay)("idisp(0x%x)",*arg);
+ if (debugout) TRACE_(olerelay)("idisp(0x%lx)", *arg);
if (writeit)
hres = _marshal_interface(buf,&IID_IDispatch,(LPUNKNOWN)*arg);
if (dealloc && *(IUnknown **)arg)
if (dealloc)
IUnknown_Release((LPUNKNOWN)arg);
break;
+ case TKIND_COCLASS: {
+ GUID iid = tattr->guid;
+ unsigned int i;
+ int type_flags;
+
+ for(i = 0; i < tattr->cImplTypes; i++) {
+ if(SUCCEEDED(ITypeInfo_GetImplTypeFlags(tinfo2, i, &type_flags)) &&
+ type_flags == (IMPLTYPEFLAG_FSOURCE|IMPLTYPEFLAG_FDEFAULT)) {
+ ITypeInfo *tinfo3;
+ TYPEATTR *tattr2;
+ HREFTYPE href;
+ if(FAILED(ITypeInfo_GetRefTypeOfImplType(tinfo2, i, &href)))
+ break;
+ if(FAILED(ITypeInfo_GetRefTypeInfo(tinfo2, href, &tinfo3)))
+ break;
+ if(SUCCEEDED(ITypeInfo_GetTypeAttr(tinfo3, &tattr2))) {
+ iid = tattr2->guid;
+ ITypeInfo_ReleaseTypeAttr(tinfo3, tattr2);
+ }
+ ITypeInfo_Release(tinfo3);
+ break;
+ }
+ }
+
+ if(writeit)
+ hres=_marshal_interface(buf, &iid, (LPUNKNOWN)arg);
+ if(dealloc)
+ IUnknown_Release((LPUNKNOWN)arg);
+ break;
+ }
case TKIND_RECORD: {
int i;
if (debugout) TRACE_(olerelay)("{");
debugout,
dealloc,
tdesc2,
- (DWORD*)(((LPBYTE)arg)+vdesc->u.oInst),
+ (DWORD_PTR *)(((LPBYTE)arg)+vdesc->u.oInst),
buf
);
ITypeInfo_ReleaseVarDesc(tinfo2, vdesc);
break;
case TKIND_ENUM:
hres = S_OK;
- if (debugout) TRACE_(olerelay)("%x",*arg);
+ if (debugout) TRACE_(olerelay)("%x", *(DWORD *)arg);
if (writeit)
hres = xbuf_add(buf,(LPBYTE)arg,sizeof(DWORD));
break;
if (debugout) TRACE_(olerelay)("[");
for (i=0;i<arrsize;i++) {
LPBYTE base = _passbyref(&adesc->tdescElem, tinfo) ? (LPBYTE) *arg : (LPBYTE) arg;
- hres = serialize_param(tinfo, writeit, debugout, dealloc, &adesc->tdescElem, (DWORD*)((LPBYTE)base+i*_xsize(&adesc->tdescElem, tinfo)), buf);
+ hres = serialize_param(tinfo, writeit, debugout, dealloc, &adesc->tdescElem, (DWORD_PTR *)((LPBYTE)base+i*_xsize(&adesc->tdescElem, tinfo)), buf);
if (hres)
return hres;
if (debugout && (i<arrsize-1)) TRACE_(olerelay)(",");
BOOL debugout,
BOOL alloc,
TYPEDESC *tdesc,
- DWORD *arg,
+ DWORD_PTR *arg,
marshal_state *buf)
{
HRESULT hres = S_OK;
hres = xbuf_get(buf,(LPBYTE)arg,8);
if (hres) ERR("Failed to read integer 8 byte\n");
}
- if (debugout) TRACE_(olerelay)("%x%x",arg[0],arg[1]);
+ if (debugout) TRACE_(olerelay)("%s", wine_dbgstr_longlong(*(ULONGLONG *)arg));
return hres;
case VT_ERROR:
case VT_I4:
hres = xbuf_get(buf,(LPBYTE)arg,sizeof(DWORD));
if (hres) ERR("Failed to read integer 4 byte\n");
}
- if (debugout) TRACE_(olerelay)("%x",*arg);
+ if (debugout) TRACE_(olerelay)("%x", *(DWORD *)arg);
return hres;
case VT_I2:
case VT_UI2:
if (hres) ERR("Failed to read integer 4 byte\n");
memcpy(arg,&x,2);
}
- if (debugout) TRACE_(olerelay)("%04x",*arg & 0xffff);
+ if (debugout) TRACE_(olerelay)("%04x", *(WORD *)arg);
return hres;
case VT_I1:
case VT_UI1:
if (hres) ERR("Failed to read integer 4 byte\n");
memcpy(arg,&x,1);
}
- if (debugout) TRACE_(olerelay)("%02x",*arg & 0xff);
+ if (debugout) TRACE_(olerelay)("%02x", *(BYTE *)arg);
return hres;
case VT_BSTR: {
if (readit)
return hres;
}
ITypeInfo_GetTypeAttr(tinfo2,&tattr);
- derefhere = (tattr->typekind != TKIND_DISPATCH && tattr->typekind != TKIND_INTERFACE);
+ derefhere = (tattr->typekind != TKIND_DISPATCH &&
+ tattr->typekind != TKIND_INTERFACE &&
+ tattr->typekind != TKIND_COCLASS);
}
break;
case TKIND_ENUM: /* confirmed */
break;
case TKIND_DISPATCH: /* will be done in VT_USERDEFINED case */
case TKIND_INTERFACE: /* will be done in VT_USERDEFINED case */
+ case TKIND_COCLASS: /* will be done in VT_USERDEFINED case */
derefhere=FALSE;
break;
default:
if (alloc) {
/* Allocate space for the referenced struct */
if (derefhere)
- *arg=(DWORD)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,_xsize(tdesc->u.lptdesc, tinfo));
+ *arg=(DWORD_PTR)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,_xsize(tdesc->u.lptdesc, tinfo));
}
if (derefhere)
- return deserialize_param(tinfo, readit, debugout, alloc, tdesc->u.lptdesc, (LPDWORD)*arg, buf);
+ return deserialize_param(tinfo, readit, debugout, alloc, tdesc->u.lptdesc, (DWORD_PTR *)*arg, buf);
else
return deserialize_param(tinfo, readit, debugout, alloc, tdesc->u.lptdesc, arg, buf);
}
case VT_UNKNOWN:
/* FIXME: UNKNOWN is unknown ..., but allocate 4 byte for it */
if (alloc)
- *arg=(DWORD)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DWORD));
+ *arg=(DWORD_PTR)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DWORD_PTR));
hres = S_OK;
if (readit)
hres = _unmarshal_interface(buf,&IID_IUnknown,(LPUNKNOWN*)arg);
if (readit)
hres = _unmarshal_interface(buf,&(tattr->guid),(LPUNKNOWN*)arg);
break;
+ case TKIND_COCLASS: {
+ GUID iid = tattr->guid;
+ unsigned int i;
+ int type_flags;
+
+ for(i = 0; i < tattr->cImplTypes; i++) {
+ if(SUCCEEDED(ITypeInfo_GetImplTypeFlags(tinfo2, i, &type_flags)) &&
+ type_flags == (IMPLTYPEFLAG_FSOURCE|IMPLTYPEFLAG_FDEFAULT)) {
+ ITypeInfo *tinfo3;
+ TYPEATTR *tattr2;
+ HREFTYPE href;
+ if(FAILED(ITypeInfo_GetRefTypeOfImplType(tinfo2, i, &href)))
+ break;
+ if(FAILED(ITypeInfo_GetRefTypeInfo(tinfo2, href, &tinfo3)))
+ break;
+ if(SUCCEEDED(ITypeInfo_GetTypeAttr(tinfo3, &tattr2))) {
+ iid = tattr2->guid;
+ ITypeInfo_ReleaseTypeAttr(tinfo3, tattr2);
+ }
+ ITypeInfo_Release(tinfo3);
+ break;
+ }
+ }
+
+ if(readit)
+ hres = _unmarshal_interface(buf, &iid, (LPUNKNOWN*)arg);
+ break;
+ }
case TKIND_RECORD: {
int i;
debugout,
alloc,
&vdesc->elemdescVar.tdesc,
- (DWORD*)(((LPBYTE)arg)+vdesc->u.oInst),
+ (DWORD_PTR *)(((LPBYTE)arg)+vdesc->u.oInst),
buf
);
ITypeInfo_ReleaseVarDesc(tinfo2, vdesc);
hres = xbuf_get(buf,(LPBYTE)arg,sizeof(DWORD));
if (hres) ERR("Failed to read enum (4 byte)\n");
}
- if (debugout) TRACE_(olerelay)("%x",*arg);
+ if (debugout) TRACE_(olerelay)("%x", *(DWORD *)arg);
break;
default:
ERR("Unhandled typekind %d\n",tattr->typekind);
if (_passbyref(&adesc->tdescElem, tinfo))
{
base = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,_xsize(tdesc->u.lptdesc, tinfo) * arrsize);
- *arg = (DWORD) base;
+ *arg = (DWORD_PTR)base;
}
for (i=0;i<arrsize;i++)
deserialize_param(
debugout,
alloc,
&adesc->tdescElem,
- (DWORD*)(base + i*_xsize(&adesc->tdescElem, tinfo)),
+ (DWORD_PTR *)(base + i*_xsize(&adesc->tdescElem, tinfo)),
buf
);
return S_OK;
static DWORD WINAPI xCall(int method, void **args)
{
TMProxyImpl *tpinfo = args[0];
- DWORD *xargs;
+ DWORD_PTR *xargs;
const FUNCDESC *fdesc;
HRESULT hres;
int i;
if (nrofnames > sizeof(names)/sizeof(names[0]))
ERR("Need more names!\n");
- xargs = (DWORD *)(args + 1);
+ xargs = (DWORD_PTR *)(args + 1);
for (i=0;i<fdesc->cParams;i++) {
ELEMDESC *elem = fdesc->lprgelemdescParam+i;
if (TRACE_ON(olerelay)) {
buf.curoff = 0;
/* generic deserializer using typelib description */
- xargs = (DWORD *)(args + 1);
+ xargs = (DWORD_PTR *)(args + 1);
status = S_OK;
for (i=0;i<fdesc->cParams;i++) {
ELEMDESC *elem = fdesc->lprgelemdescParam+i;
/* nrofargs including This */
int nrofargs = 1;
ITypeInfo *tinfo2;
-
-#ifdef __i386__
TMAsmProxy *xasm = proxy->asmstubs + num;
-#endif
-
HRESULT hres;
const FUNCDESC *fdesc;
xasm->bytestopop = nrofargs * 4;
xasm->nop = 0x9090;
proxy->lpvtbl[fdesc->oVft / sizeof(void *)] = xasm;
+
+#elif defined(__x86_64__)
+
+ xasm->pushq_rbp = 0x55; /* pushq %rbp */
+ xasm->movq_rsp_rbp[0] = 0x48; /* movq %rsp,%rbp */
+ xasm->movq_rsp_rbp[1] = 0x89;
+ xasm->movq_rsp_rbp[2] = 0xe5;
+ xasm->subq_0x20_rsp = 0x20ec8348; /* subq 0x20,%rsp */
+ xasm->movq_rcx_0x10rbp = 0x104d8948; /* movq %rcx,0x10(%rbp) */
+ xasm->movq_rdx_0x18rbp = 0x18558948; /* movq %rdx,0x18(%rbp) */
+ xasm->movq_r8_0x20rbp = 0x2045894c; /* movq %r8,0x20(%rbp) */
+ xasm->movq_r9_0x28rbp = 0x284d894c; /* movq %r9,0x28(%rbp) */
+ xasm->movq_rcx[0] = 0x48; /* movq <num>,%rcx */
+ xasm->movq_rcx[1] = 0xc7;
+ xasm->movq_rcx[2] = 0xc1;
+ xasm->nr = num;
+ xasm->leaq_0x10rbp_rdx = 0x10558d48; /* leaq 0x10(%rbp),%rdx */
+ xasm->movq_rax = 0xb848; /* movq <xCall>,%rax */
+ xasm->xcall = xCall;
+ xasm->callq_rax = 0xd0ff; /* callq *%rax */
+ xasm->movq_rbp_rsp[0] = 0x48; /* movq %rbp,%rsp */
+ xasm->movq_rbp_rsp[1] = 0x89;
+ xasm->movq_rbp_rsp[2] = 0xec;
+ xasm->popq_rbp = 0x5d; /* popq %rbp */
+ xasm->ret = 0xc3; /* ret */
+ xasm->nop = 0x90909090; /* nop */
+ proxy->lpvtbl[fdesc->oVft / sizeof(void *)] = xasm;
+
#else
FIXME("not implemented on non i386\n");
return E_FAIL;
TMStubImpl_Invoke(
LPRPCSTUBBUFFER iface, RPCOLEMESSAGE* xmsg,IRpcChannelBuffer*rpcchanbuf)
{
-#ifdef __i386__
+#if defined(__i386__) || defined(__x86_64__)
int i;
const FUNCDESC *fdesc;
TMStubImpl *This = impl_from_IRpcStubBuffer(iface);
HRESULT hres;
- DWORD *args = NULL, res, *xargs, nrofargs;
+ DWORD_PTR *args = NULL, *xargs;
+ DWORD res, nrofargs;
marshal_state buf;
UINT nrofnames = 0;
BSTR names[10];
nrofargs = 0;
for (i=0;i<fdesc->cParams;i++)
nrofargs += _argsize(&fdesc->lprgelemdescParam[i].tdesc, tinfo);
- args = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(nrofargs+1)*sizeof(DWORD));
+ args = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nrofargs+1)*sizeof(DWORD_PTR));
if (!args)
{
hres = E_OUTOFMEMORY;
}
}
- args[0] = (DWORD)This->pUnk;
+ args[0] = (DWORD_PTR)This->pUnk;
__TRY
{
res = _invoke(
- (*((FARPROC**)args[0]))[fdesc->oVft/4],
+ (*((FARPROC**)args[0]))[fdesc->oVft / sizeof(DWORD_PTR)],
fdesc->callconv,
(xargs-args),
args
ITypeInfo *tinfo;
TMStubImpl *stub;
TYPEATTR *typeattr;
+ IUnknown *obj;
TRACE("(%s,%p,%p)\n",debugstr_guid(riid),pUnkServer,ppStub);
return hres;
}
+ /* FIXME: This is not exactly right. We should probably call QI later. */
+ hres = IUnknown_QueryInterface(pUnkServer, riid, (void**)&obj);
+ if (FAILED(hres)) {
+ WARN("Could not get %s iface: %08x\n", debugstr_guid(riid), hres);
+ obj = pUnkServer;
+ IUnknown_AddRef(obj);
+ }
+
stub = CoTaskMemAlloc(sizeof(TMStubImpl));
- if (!stub)
+ if (!stub) {
+ IUnknown_Release(obj);
return E_OUTOFMEMORY;
+ }
stub->IRpcStubBuffer_iface.lpVtbl = &tmstubvtbl;
stub->ref = 1;
stub->tinfo = tinfo;
stub->dispatch_stub = NULL;
stub->dispatch_derivative = FALSE;
stub->iid = *riid;
- hres = IRpcStubBuffer_Connect(&stub->IRpcStubBuffer_iface,pUnkServer);
+ hres = IRpcStubBuffer_Connect(&stub->IRpcStubBuffer_iface, obj);
*ppStub = &stub->IRpcStubBuffer_iface;
TRACE("IRpcStubBuffer: %p\n", stub);
if (hres)
ITypeInfo_ReleaseTypeAttr(tinfo, typeattr);
}
+ IUnknown_Release(obj);
return hres;
}
PSFacBuf_CreateStub
};
-/* This is the whole PSFactoryBuffer object, just the vtableptr */
-static const IPSFactoryBufferVtbl *lppsfac = &psfacbufvtbl;
+static IPSFactoryBuffer psfac = { &psfacbufvtbl };
/***********************************************************************
* TMARSHAL_DllGetClassObject
*/
-HRESULT TMARSHAL_DllGetClassObject(REFCLSID rclsid, REFIID iid,LPVOID *ppv)
+HRESULT TMARSHAL_DllGetClassObject(REFCLSID rclsid, REFIID iid, void **ppv)
{
- if (IsEqualIID(iid,&IID_IPSFactoryBuffer)) {
- *ppv = &lppsfac;
- return S_OK;
- }
- return E_NOINTERFACE;
+ return IPSFactoryBuffer_QueryInterface(&psfac, iid, ppv);
}
WINE_DEFAULT_DEBUG_CHANNEL(ole);
WINE_DECLARE_DEBUG_CHANNEL(typelib);
-#ifdef __REACTOS__
-/* FIXME: Vista+ */
-#define STATUS_SUCCESS ((NTSTATUS)0x00000000)
-static BOOL WINAPI GetFileInformationByHandleEx( HANDLE handle, FILE_INFO_BY_HANDLE_CLASS class,
- LPVOID info, DWORD size )
-{
- NTSTATUS status;
- IO_STATUS_BLOCK io;
-
- switch (class)
- {
- case FileBasicInfo:
- case FileStandardInfo:
- case FileRenameInfo:
- case FileDispositionInfo:
- case FileAllocationInfo:
- case FileEndOfFileInfo:
- case FileStreamInfo:
- case FileCompressionInfo:
- case FileAttributeTagInfo:
- case FileIoPriorityHintInfo:
- case FileRemoteProtocolInfo:
- case FileFullDirectoryInfo:
- case FileFullDirectoryRestartInfo:
- case FileStorageInfo:
- case FileAlignmentInfo:
- case FileIdInfo:
- case FileIdExtdDirectoryInfo:
- case FileIdExtdDirectoryRestartInfo:
- FIXME( "%p, %u, %p, %u\n", handle, class, info, size );
- SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
- return FALSE;
-
- case FileNameInfo:
- status = NtQueryInformationFile( handle, &io, info, size, FileNameInformation );
- if (status != STATUS_SUCCESS)
- {
- SetLastError( RtlNtStatusToDosError( status ) );
- return FALSE;
- }
- return TRUE;
-
- case FileIdBothDirectoryRestartInfo:
- case FileIdBothDirectoryInfo:
- status = NtQueryDirectoryFile( handle, NULL, NULL, NULL, &io, info, size,
- FileIdBothDirectoryInformation, FALSE, NULL,
- (class == FileIdBothDirectoryRestartInfo) );
- if (status != STATUS_SUCCESS)
- {
- SetLastError( RtlNtStatusToDosError( status ) );
- return FALSE;
- }
- return TRUE;
-
- default:
- SetLastError( ERROR_INVALID_PARAMETER );
- return FALSE;
- }
-}
-#endif
-
typedef struct
{
WORD offset;
* Invokes a method, or accesses a property of an object, that implements the
* interface described by the type description.
*/
-DWORD
-_invoke(FARPROC func,CALLCONV callconv, int nrargs, DWORD *args) {
+DWORD _invoke(FARPROC func, CALLCONV callconv, int nrargs, DWORD_PTR *args)
+{
DWORD res;
int stack_offset;
if (TRACE_ON(ole)) {
int i;
TRACE("Calling %p(",func);
- for (i=0;i<min(nrargs,30);i++) TRACE("%08x,",args[i]);
+ for (i=0;i<min(nrargs,30);i++) TRACE("%08lx,",args[i]);
if (nrargs > 30) TRACE("...");
TRACE(")\n");
}
switch (callconv) {
case CC_STDCALL:
case CC_CDECL:
- res = call_method( func, nrargs, args, &stack_offset );
+ res = call_method(func, nrargs, (DWORD *)args, &stack_offset);
break;
default:
FIXME("unsupported calling convention %d\n",callconv);
/* same function but returning floating point */
static double (CDECL * const call_double_method)(void*,int,const DWORD_PTR*) = (void *)call_method;
+DWORD _invoke(FARPROC func, CALLCONV callconv, int nrargs, DWORD_PTR *args)
+{
+ DWORD res;
+
+ if (TRACE_ON(ole))
+ {
+ int i;
+ TRACE("Calling %p(", func);
+ for (i=0; i<min(nrargs, 30); i++) TRACE("%016lx,", args[i]);
+ if (nrargs > 30) TRACE("...");
+ TRACE(")\n");
+ }
+
+ switch (callconv) {
+ case CC_STDCALL:
+ case CC_CDECL:
+ res = call_method(func, nrargs, args);
+ break;
+ default:
+ FIXME("unsupported calling convention %d\n", callconv);
+ res = -1;
+ break;
+ }
+
+ TRACE("returns %08x\n", res);
+ return res;
+}
+
#endif /* __x86_64__ */
static HRESULT userdefined_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
return hr;
}
-static HRESULT get_iface_guid(ITypeInfo *tinfo, const TYPEDESC *tdesc, GUID *guid)
+static HRESULT get_iface_guid(ITypeInfo *tinfo, HREFTYPE href, GUID *guid)
{
ITypeInfo *tinfo2;
TYPEATTR *tattr;
HRESULT hres;
- hres = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2);
+ hres = ITypeInfo_GetRefTypeInfo(tinfo, href, &tinfo2);
if(FAILED(hres))
return hres;
switch(tattr->typekind) {
case TKIND_ALIAS:
- hres = get_iface_guid(tinfo2, &tattr->tdescAlias, guid);
+ hres = get_iface_guid(tinfo2, tattr->tdescAlias.u.hreftype, guid);
break;
case TKIND_INTERFACE:
*guid = tattr->guid;
break;
+ case TKIND_COCLASS: {
+ unsigned int i;
+ int type_flags;
+
+ for(i = 0; i < tattr->cImplTypes; i++)
+ if(SUCCEEDED(ITypeInfo_GetImplTypeFlags(tinfo2, i, &type_flags)) &&
+ type_flags == (IMPLTYPEFLAG_FSOURCE|IMPLTYPEFLAG_FDEFAULT)) break;
+
+ if(i < tattr->cImplTypes) {
+ hres = ITypeInfo_GetRefTypeOfImplType(tinfo2, i, &href);
+ if(SUCCEEDED(hres)) hres = get_iface_guid(tinfo2, href, guid);
+ } else hres = E_UNEXPECTED;
+ break;
+ }
+
default:
ERR("Unexpected typekind %d\n", tattr->typekind);
hres = E_UNEXPECTED;
}
V_VT(&rgvarg[i]) = rgvt[i];
}
- else if (rgvt[i] == (VT_VARIANT | VT_ARRAY) && func_desc->cParamsOpt < 0 && i == func_desc->cParams-1)
+ else if ((rgvt[i] == (VT_VARIANT | VT_ARRAY) || rgvt[i] == (VT_VARIANT | VT_ARRAY | VT_BYREF)) && func_desc->cParamsOpt < 0)
{
SAFEARRAY *a;
SAFEARRAYBOUND bound;
SafeArrayDestroy(a);
break;
}
- V_ARRAY(&rgvarg[i]) = a;
+ 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))
IUnknown *userdefined_iface;
GUID guid;
- hres = get_iface_guid((ITypeInfo*)iface, tdesc->vt == VT_PTR ? tdesc->u.lptdesc : tdesc, &guid);
+ if (tdesc->vt == VT_PTR)
+ tdesc = tdesc->u.lptdesc;
+
+ hres = get_iface_guid((ITypeInfo*)iface, tdesc->u.hreftype, &guid);
if(FAILED(hres))
break;
ITypeLib * *ppTLib, UINT *pIndex)
{
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=(LPTYPELIB )(This->pTypeLib);
+ *ppTLib = (ITypeLib *)&This->pTypeLib->ITypeLib2_iface;
ITypeLib_AddRef(*ppTLib);
TRACE("returning ppTLib=%p\n", *ppTLib);
}
-
+
return S_OK;
}
projects / reactos.git / commitdiff