system/wine
system/wine
1
0
Fork 0
mirror of https://github.com/wine-mirror/wine synced 2024-07-08 20:06:18 +00:00
Code Issues Projects Releases Wiki Activity

oleaut32: Use nameless unions/structs.

Browse Source
This commit is contained in:
Alexandre Julliard 2023-07-04 12:47:11 +02:00
parent 36963b6d27
commit 374d74e843
6 changed files with 189 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
dlls/oleaut32/olefont.c
View File

@ -26,9 +26,6 @@
#include <string.h>
#define COBJMACROS
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
#include "winerror.h"
#include "windef.h"
#include "winbase.h"
@ -331,8 +328,8 @@ HRESULT WINAPI OleCreateFontIndirect(
fd.cbSizeofstruct = sizeof(fd);
fd.lpstrName = fname;
fd.cySize.s.Lo = 80000;
fd.cySize.s.Hi = 0;
fd.cySize.Lo = 80000;
fd.cySize.Hi = 0;
fd.sWeight = 0;
fd.sCharset = 0;
fd.fItalic = FALSE;
@ -586,7 +583,7 @@ static void realize_font(OLEFontImpl *This)
* Ratio is applied here relative to the standard.
*/
fontHeight = MulDiv( This->description.cySize.s.Lo, This->cyLogical*635, This->cyHimetric*18 );
fontHeight = MulDiv( This->description.cySize.Lo, This->cyLogical*635, This->cyHimetric*18 );
logFont.lfHeight = ((fontHeight%10000L)>5000L) ? (-fontHeight/10000L) - 1 :
(-fontHeight/10000L);
@ -685,10 +682,8 @@ static HRESULT WINAPI OLEFontImpl_get_Size(
* Convert realized font height in pixels to points descaled by current
* scaling ratio then scaled up by 10000.
*/
psize->s.Lo = MulDiv(this->nRealHeight,
this->cyHimetric * 72 * 10000,
this->cyLogical * 2540);
psize->s.Hi = 0;
psize->Lo = MulDiv(this->nRealHeight, this->cyHimetric * 72 * 10000, this->cyLogical * 2540);
psize->Hi = 0;
return S_OK;
}
@ -696,9 +691,9 @@ static HRESULT WINAPI OLEFontImpl_get_Size(
static HRESULT WINAPI OLEFontImpl_put_Size(IFont *iface, CY size)
{
OLEFontImpl *this = impl_from_IFont(iface);
TRACE("%p, %ld.\n", iface, size.s.Lo);
this->description.cySize.s.Hi = 0;
this->description.cySize.s.Lo = size.s.Lo;
TRACE("%p, %ld.\n", iface, size.Lo);
this->description.cySize.Hi = 0;
this->description.cySize.Lo = size.Lo;
OLEFont_SendNotify(this, DISPID_FONT_SIZE);
return S_OK;
@ -997,9 +992,9 @@ static HRESULT WINAPI OLEFontImpl_IsEqual(
if(pFontOther == NULL)
return E_POINTER;
else if (left->description.cySize.s.Lo != right->description.cySize.s.Lo)
else if (left->description.cySize.Lo != right->description.cySize.Lo)
return S_FALSE;
else if (left->description.cySize.s.Hi != right->description.cySize.s.Hi)
else if (left->description.cySize.Hi != right->description.cySize.Hi)
return S_FALSE;
else if (left->description.sWeight != right->description.sWeight)
return S_FALSE;
@ -1600,10 +1595,10 @@ static HRESULT WINAPI OLEFontImpl_Load(
if (cbRead != sizeof(WORD)) return E_FAIL;
/* Size */
IStream_Read(pLoadStream, &this->description.cySize.s.Lo, sizeof(DWORD), &cbRead);
IStream_Read(pLoadStream, &this->description.cySize.Lo, sizeof(DWORD), &cbRead);
if (cbRead != sizeof(DWORD)) return E_FAIL;
this->description.cySize.s.Hi = 0;
this->description.cySize.Hi = 0;
/* Name */
IStream_Read(pLoadStream, &string_size, sizeof(BYTE), &cbRead);
@ -1671,7 +1666,7 @@ static HRESULT WINAPI OLEFontImpl_Save(
if (written != sizeof(WORD)) return E_FAIL;
/* Size */
IStream_Write(pOutStream, &this->description.cySize.s.Lo, sizeof(DWORD), &written);
IStream_Write(pOutStream, &this->description.cySize.Lo, sizeof(DWORD), &written);
if (written != sizeof(DWORD)) return E_FAIL;
/* FontName */

74
dlls/oleaut32/olepicture.c
View File

@ -41,8 +41,6 @@
#include <string.h>
#define COBJMACROS
#define NONAMELESSUNION
#include "winerror.h"
#include "windef.h"
#include "winbase.h"
@ -201,8 +199,8 @@ static void OLEPictureImpl_SetBitmap(OLEPictureImpl *This)
BITMAP bm;
HDC hdcRef;
TRACE("bitmap handle %p\n", This->desc.u.bmp.hbitmap);
if(GetObjectW(This->desc.u.bmp.hbitmap, sizeof(bm), &bm) != sizeof(bm)) {
TRACE("bitmap handle %p\n", This->desc.bmp.hbitmap);
if(GetObjectW(This->desc.bmp.hbitmap, sizeof(bm), &bm) != sizeof(bm)) {
ERR("GetObject fails\n");
return;
}
@ -230,8 +228,8 @@ static void OLEPictureImpl_SetIcon(OLEPictureImpl * This)
{
ICONINFO infoIcon;
TRACE("icon handle %p\n", This->desc.u.icon.hicon);
if (GetIconInfo(This->desc.u.icon.hicon, &infoIcon)) {
TRACE("icon handle %p\n", This->desc.icon.hicon);
if (GetIconInfo(This->desc.icon.hicon, &infoIcon)) {
HDC hdcRef;
BITMAP bm;
@ -254,7 +252,7 @@ static void OLEPictureImpl_SetIcon(OLEPictureImpl * This)
DeleteObject(infoIcon.hbmMask);
if (infoIcon.hbmColor) DeleteObject(infoIcon.hbmColor);
} else {
ERR("GetIconInfo() fails on icon %p\n", This->desc.u.icon.hicon);
ERR("GetIconInfo() fails on icon %p\n", This->desc.icon.hicon);
}
}
@ -326,9 +324,9 @@ static HRESULT OLEPictureImpl_Construct(LPPICTDESC pictDesc, BOOL fOwn, OLEPictu
break;
case PICTYPE_METAFILE:
TRACE("metafile handle %p\n", pictDesc->u.wmf.hmeta);
newObject->himetricWidth = pictDesc->u.wmf.xExt;
newObject->himetricHeight = pictDesc->u.wmf.yExt;
TRACE("metafile handle %p\n", pictDesc->wmf.hmeta);
newObject->himetricWidth = pictDesc->wmf.xExt;
newObject->himetricHeight = pictDesc->wmf.yExt;
break;
case PICTYPE_NONE:
@ -375,18 +373,18 @@ static void OLEPictureImpl_Destroy(OLEPictureImpl* Obj)
if(Obj->fOwn) { /* We need to destroy the picture */
switch(Obj->desc.picType) {
case PICTYPE_BITMAP:
DeleteObject(Obj->desc.u.bmp.hbitmap);
DeleteObject(Obj->desc.bmp.hbitmap);
if (Obj->hbmMask != NULL) DeleteObject(Obj->hbmMask);
if (Obj->hbmXor != NULL) DeleteObject(Obj->hbmXor);
break;
case PICTYPE_METAFILE:
DeleteMetaFile(Obj->desc.u.wmf.hmeta);
DeleteMetaFile(Obj->desc.wmf.hmeta);
break;
case PICTYPE_ICON:
DestroyIcon(Obj->desc.u.icon.hicon);
DestroyIcon(Obj->desc.icon.hicon);
break;
case PICTYPE_ENHMETAFILE:
DeleteEnhMetaFile(Obj->desc.u.emf.hemf);
DeleteEnhMetaFile(Obj->desc.emf.hemf);
break;
case PICTYPE_NONE:
case PICTYPE_UNINITIALIZED:
@ -503,16 +501,16 @@ static HRESULT WINAPI OLEPictureImpl_get_Handle(IPicture *iface,
*phandle = 0;
break;
case PICTYPE_BITMAP:
*phandle = HandleToUlong(This->desc.u.bmp.hbitmap);
*phandle = HandleToUlong(This->desc.bmp.hbitmap);
break;
case PICTYPE_METAFILE:
*phandle = HandleToUlong(This->desc.u.wmf.hmeta);
*phandle = HandleToUlong(This->desc.wmf.hmeta);
break;
case PICTYPE_ICON:
*phandle = HandleToUlong(This->desc.u.icon.hicon);
*phandle = HandleToUlong(This->desc.icon.hicon);
break;
case PICTYPE_ENHMETAFILE:
*phandle = HandleToUlong(This->desc.u.emf.hemf);
*phandle = HandleToUlong(This->desc.emf.hemf);
break;
default:
FIXME("Unimplemented type %d\n", This->desc.picType);
@ -536,7 +534,7 @@ static HRESULT WINAPI OLEPictureImpl_get_hPal(IPicture *iface,
if (This->desc.picType == PICTYPE_BITMAP)
{
*phandle = HandleToUlong(This->desc.u.bmp.hpal);
*phandle = HandleToUlong(This->desc.bmp.hpal);
return S_OK;
}
@ -661,7 +659,7 @@ static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
else
{
hbmMask = 0;
hbmXor = This->desc.u.bmp.hbitmap;
hbmXor = This->desc.bmp.hbitmap;
}
render_masked_bitmap(This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, hbmMask, hbmXor);
@ -672,7 +670,7 @@ static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
{
ICONINFO info;
if (!GetIconInfo(This->desc.u.icon.hicon, &info))
if (!GetIconInfo(This->desc.icon.hicon, &info))
return E_FAIL;
render_masked_bitmap(This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, info.hbmMask, info.hbmColor);
@ -698,7 +696,7 @@ static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
SetViewportOrgEx(hdc, x, y, &prevOrg);
SetViewportExtEx(hdc, cx, cy, &prevExt);
if (!PlayMetaFile(hdc, This->desc.u.wmf.hmeta))
if (!PlayMetaFile(hdc, This->desc.wmf.hmeta))
ERR("PlayMetaFile failed!\n");
/* We're done, restore the DC to the previous settings for converting
@ -714,7 +712,7 @@ static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
case PICTYPE_ENHMETAFILE:
{
RECT rc = { x, y, x + cx, y + cy };
PlayEnhMetaFile(hdc, This->desc.u.emf.hemf, &rc);
PlayEnhMetaFile(hdc, This->desc.emf.hemf, &rc);
break;
}
@ -737,7 +735,7 @@ static HRESULT WINAPI OLEPictureImpl_set_hPal(IPicture *iface,
if (This->desc.picType == PICTYPE_BITMAP)
{
This->desc.u.bmp.hpal = ULongToHandle(hpal);
This->desc.bmp.hpal = ULongToHandle(hpal);
OLEPicture_SendNotify(This,DISPID_PICT_HPAL);
return S_OK;
}
@ -771,10 +769,10 @@ static HRESULT WINAPI OLEPictureImpl_SelectPicture(IPicture *iface,
if (phdcOut)
*phdcOut = This->hDCCur;
if (This->hDCCur) SelectObject(This->hDCCur,This->stock_bitmap);
if (hdcIn) SelectObject(hdcIn,This->desc.u.bmp.hbitmap);
if (hdcIn) SelectObject(hdcIn,This->desc.bmp.hbitmap);
This->hDCCur = hdcIn;
if (phbmpOut)
*phbmpOut = HandleToUlong(This->desc.u.bmp.hbitmap);
*phbmpOut = HandleToUlong(This->desc.bmp.hbitmap);
return S_OK;
} else {
FIXME("Don't know how to select picture type %d\n",This->desc.picType);
@ -993,7 +991,7 @@ static HRESULT OLEPictureImpl_LoadDIB(OLEPictureImpl *This, BYTE *xbuf, ULONG xr
* components which are in both
*/
hdcref = GetDC(0);
This->desc.u.bmp.hbitmap = CreateDIBitmap(
This->desc.bmp.hbitmap = CreateDIBitmap(
hdcref,
&(bi->bmiHeader),
CBM_INIT,
@ -1002,7 +1000,7 @@ static HRESULT OLEPictureImpl_LoadDIB(OLEPictureImpl *This, BYTE *xbuf, ULONG xr
DIB_RGB_COLORS
);
ReleaseDC(0, hdcref);
if (This->desc.u.bmp.hbitmap == 0)
if (This->desc.bmp.hbitmap == 0)
return E_FAIL;
This->desc.picType = PICTYPE_BITMAP;
OLEPictureImpl_SetBitmap(This);
@ -1060,7 +1058,7 @@ static HRESULT OLEPictureImpl_LoadWICSource(OLEPictureImpl *This, IWICBitmapSour
goto end;
hdcref = GetDC(0);
This->desc.u.bmp.hbitmap = CreateDIBitmap(
This->desc.bmp.hbitmap = CreateDIBitmap(
hdcref,
&bih,
CBM_INIT,
@ -1068,7 +1066,7 @@ static HRESULT OLEPictureImpl_LoadWICSource(OLEPictureImpl *This, IWICBitmapSour
(BITMAPINFO*)&bih,
DIB_RGB_COLORS);
if (This->desc.u.bmp.hbitmap == 0)
if (This->desc.bmp.hbitmap == 0)
{
hr = E_FAIL;
ReleaseDC(0, hdcref);
@ -1111,7 +1109,7 @@ static HRESULT OLEPictureImpl_LoadWICSource(OLEPictureImpl *This, IWICBitmapSour
hdcXor = CreateCompatibleDC(NULL);
hdcMask = CreateCompatibleDC(NULL);
hbmoldBmp = SelectObject(hdcBmp,This->desc.u.bmp.hbitmap);
hbmoldBmp = SelectObject(hdcBmp,This->desc.bmp.hbitmap);
hbmoldXor = SelectObject(hdcXor,This->hbmXor);
hbmoldMask = SelectObject(hdcMask,This->hbmMask);
@ -1273,7 +1271,7 @@ static HRESULT OLEPictureImpl_LoadIcon(OLEPictureImpl *This, BYTE *xbuf, ULONG x
return E_FAIL;
} else {
This->desc.picType = PICTYPE_ICON;
This->desc.u.icon.hicon = hicon;
This->desc.icon.hicon = hicon;
This->origWidth = cifd->idEntries[i].bWidth;
This->origHeight = cifd->idEntries[i].bHeight;
hdcRef = CreateCompatibleDC(0);
@ -1296,7 +1294,7 @@ static HRESULT OLEPictureImpl_LoadEnhMetafile(OLEPictureImpl *This,
GetEnhMetaFileHeader(hemf, sizeof(hdr), &hdr);
This->desc.picType = PICTYPE_ENHMETAFILE;
This->desc.u.emf.hemf = hemf;
This->desc.emf.hemf = hemf;
This->origWidth = 0;
This->origHeight = 0;
@ -1322,9 +1320,9 @@ static HRESULT OLEPictureImpl_LoadAPM(OLEPictureImpl *This,
if (!hmf) return E_FAIL;
This->desc.picType = PICTYPE_METAFILE;
This->desc.u.wmf.hmeta = hmf;
This->desc.u.wmf.xExt = 0;
This->desc.u.wmf.yExt = 0;
This->desc.wmf.hmeta = hmf;
This->desc.wmf.xExt = 0;
This->desc.wmf.yExt = 0;
This->origWidth = 0;
This->origHeight = 0;
@ -1771,7 +1769,7 @@ static HRESULT WINAPI OLEPictureImpl_Save(
case PICTYPE_ICON:
if (This->bIsDirty || !This->data) {
if (!serializeIcon(This->desc.u.icon.hicon, &pIconData, &iDataSize)) {
if (!serializeIcon(This->desc.icon.hicon, &pIconData, &iDataSize)) {
ERR("(%p,%p,%d), serializeIcon() failed\n", This, pStm, fClearDirty);
hResult = E_FAIL;
break;
@ -1791,7 +1789,7 @@ static HRESULT WINAPI OLEPictureImpl_Save(
if (This->bIsDirty || !This->data) {
switch (This->keepOrigFormat ? This->loadtime_format : BITMAP_FORMAT_BMP) {
case BITMAP_FORMAT_BMP:
serializeResult = serializeBMP(This->desc.u.bmp.hbitmap, &pIconData, &iDataSize);
serializeResult = serializeBMP(This->desc.bmp.hbitmap, &pIconData, &iDataSize);
break;
case BITMAP_FORMAT_JPEG:
FIXME("(%p,%p,%d), PICTYPE_BITMAP (format JPEG) not implemented!\n",This,pStm,fClearDirty);

14
dlls/oleaut32/olepropframe.c
View File

@ -22,8 +22,6 @@
#include <stdarg.h>
#define COBJMACROS
#define NONAMELESSUNION
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
@ -244,14 +242,14 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
property_sheet.pszCaption = lpParams->lpszCaption;
}
property_sheet.u3.phpage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
property_sheet.phpage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
lpParams->cPages*sizeof(HPROPSHEETPAGE));
property_page = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
lpParams->cPages*sizeof(IPropertyPage*));
dialogs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
lpParams->cPages*sizeof(*dialogs));
if(!property_sheet.u3.phpage || !property_page || !dialogs) {
HeapFree(GetProcessHeap(), 0, property_sheet.u3.phpage);
if(!property_sheet.phpage || !property_page || !dialogs) {
HeapFree(GetProcessHeap(), 0, property_sheet.phpage);
HeapFree(GetProcessHeap(), 0, property_page);
HeapFree(GetProcessHeap(), 0, dialogs);
return E_OUTOFMEMORY;
@ -295,11 +293,11 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
dialogs[i].template.cx = MulDiv(page_info.size.cx, 4, font_width);
dialogs[i].template.cy = MulDiv(page_info.size.cy, 8, font_height);
property_sheet_page.u.pResource = &dialogs[i].template;
property_sheet_page.pResource = &dialogs[i].template;
property_sheet_page.lParam = (LPARAM)property_page[i];
property_sheet_page.pszTitle = page_info.pszTitle;
property_sheet.u3.phpage[property_sheet.nPages++] =
property_sheet.phpage[property_sheet.nPages++] =
CreatePropertySheetPageW(&property_sheet_page);
}
@ -312,7 +310,7 @@ HRESULT WINAPI OleCreatePropertyFrameIndirect(LPOCPFIPARAMS lpParams)
HeapFree(GetProcessHeap(), 0, dialogs);
HeapFree(GetProcessHeap(), 0, property_page);
HeapFree(GetProcessHeap(), 0, property_sheet.u3.phpage);
HeapFree(GetProcessHeap(), 0, property_sheet.phpage);
return S_OK;
}

6
dlls/oleaut32/recinfo.c
View File

@ -19,8 +19,6 @@
#include <stdarg.h>
#define COBJMACROS
#define NONAMELESSUNION
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
@ -639,7 +637,7 @@ HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo* pTI, IRecordInfo** ppRecInfo
}
if(typeattr->typekind == TKIND_ALIAS) {
hres = ITypeInfo_GetRefTypeInfo(pTI, typeattr->tdescAlias.u.hreftype, &pTypeInfo);
hres = ITypeInfo_GetRefTypeInfo(pTI, typeattr->tdescAlias.hreftype, &pTypeInfo);
guid = typeattr->guid;
ITypeInfo_ReleaseTypeAttr(pTI, typeattr);
if(FAILED(hres)) {
@ -695,7 +693,7 @@ HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo* pTI, IRecordInfo** ppRecInfo
}
ret->fields[i].vt = vardesc->elemdescVar.tdesc.vt;
ret->fields[i].varkind = vardesc->varkind;
ret->fields[i].offset = vardesc->u.oInst;
ret->fields[i].offset = vardesc->oInst;
hres = ITypeInfo_GetDocumentation(pTypeInfo, vardesc->memid, &ret->fields[i].name,
NULL, NULL, NULL);
if(FAILED(hres))

244
dlls/oleaut32/typelib.c
View File

@ -54,8 +54,6 @@
#include <ctype.h>
#define COBJMACROS
#define NONAMELESSUNION
#include "winerror.h"
#include "windef.h"
#include "winbase.h"
@ -1352,18 +1350,18 @@ static void dump_TypeDesc(const TYPEDESC *pTD,char *szVarType) {
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 = %lx", pTD->u.hreftype); break;
case VT_USERDEFINED: sprintf(szVarType, "VT_USERDEFINED ref = %lx", pTD->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);
dump_TypeDesc(pTD->lptdesc, szVarType + 7);
break;
case VT_SAFEARRAY: sprintf(szVarType, "safearray of ");
dump_TypeDesc(pTD->u.lptdesc, szVarType + 13);
dump_TypeDesc(pTD->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));
pTD->lpadesc->cDims); /* FIXME print out sizes */
dump_TypeDesc(&pTD->lpadesc->tdescElem, szVarType + strlen(szVarType));
break;
default: sprintf(szVarType, "unknown(%d)", pTD->vt & VT_TYPEMASK); break;
@ -1372,7 +1370,7 @@ static void dump_TypeDesc(const TYPEDESC *pTD,char *szVarType) {
static void dump_ELEMDESC(const ELEMDESC *edesc) {
char buf[200];
USHORT flags = edesc->u.paramdesc.wParamFlags;
USHORT flags = edesc->paramdesc.wParamFlags;
dump_TypeDesc(&edesc->tdesc,buf);
MESSAGE("\t\ttdesc.vartype %d (%s)\n",edesc->tdesc.vt,buf);
MESSAGE("\t\tu.paramdesc.wParamFlags");
@ -1384,7 +1382,7 @@ static void dump_ELEMDESC(const ELEMDESC *edesc) {
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);
MESSAGE("\n\t\tu.paramdesc.lpex %p\n",edesc->paramdesc.pparamdescex);
}
static void dump_FUNCDESC(const FUNCDESC *funcdesc) {
int i;
@ -1557,7 +1555,7 @@ static void dump_VARDESC(const VARDESC *v)
{
MESSAGE("memid %ld\n",v->memid);
MESSAGE("lpstrSchema %s\n",debugstr_w(v->lpstrSchema));
MESSAGE("oInst %ld\n", v->u.oInst);
MESSAGE("oInst %ld\n", v->oInst);
dump_ELEMDESC(&(v->elemdescVar));
MESSAGE("wVarFlags %x\n",v->wVarFlags);
MESSAGE("varkind %d\n",v->varkind);
@ -1594,11 +1592,11 @@ static SIZE_T TLB_SizeTypeDesc( const TYPEDESC *tdesc, BOOL alloc_initial_space
{
case VT_PTR:
case VT_SAFEARRAY:
size += TLB_SizeTypeDesc(tdesc->u.lptdesc, TRUE);
size += TLB_SizeTypeDesc(tdesc->lptdesc, TRUE);
break;
case VT_CARRAY:
size += FIELD_OFFSET(ARRAYDESC, rgbounds[tdesc->u.lpadesc->cDims]);
size += TLB_SizeTypeDesc(&tdesc->u.lpadesc->tdescElem, FALSE);
size += FIELD_OFFSET(ARRAYDESC, rgbounds[tdesc->lpadesc->cDims]);
size += TLB_SizeTypeDesc(&tdesc->lpadesc->tdescElem, FALSE);
break;
}
return size;
@ -1619,14 +1617,14 @@ static void *TLB_CopyTypeDesc( TYPEDESC *dest, const TYPEDESC *src, void *buffer
{
case VT_PTR:
case VT_SAFEARRAY:
dest->u.lptdesc = buffer;
buffer = TLB_CopyTypeDesc(NULL, src->u.lptdesc, buffer);
dest->lptdesc = buffer;
buffer = TLB_CopyTypeDesc(NULL, src->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);
dest->lpadesc = buffer;
memcpy(dest->lpadesc, src->lpadesc, FIELD_OFFSET(ARRAYDESC, rgbounds[src->lpadesc->cDims]));
buffer = (char *)buffer + FIELD_OFFSET(ARRAYDESC, rgbounds[src->lpadesc->cDims]);
buffer = TLB_CopyTypeDesc(&dest->lpadesc->tdescElem, &src->lpadesc->tdescElem, buffer);
break;
}
return buffer;
@ -1994,15 +1992,15 @@ static HRESULT TLB_size_instance(ITypeInfoImpl *info, SYSKIND sys,
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);
for(i = 0; i < tdesc->lpadesc->cDims; ++i)
*size += tdesc->lpadesc->rgbounds[i].cElements;
hr = TLB_size_instance(info, sys, &tdesc->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);
return TLB_get_size_from_hreftype(info, tdesc->hreftype, size, align);
default:
FIXME("Unsized VT: 0x%x\n", tdesc->vt);
return E_FAIL;
@ -2474,7 +2472,7 @@ MSFT_DoFuncs(TLBContext* pcx,
paraminfo.DataType,
&elemdesc->tdesc);
elemdesc->u.paramdesc.wParamFlags = paraminfo.Flags;
elemdesc->paramdesc.wParamFlags = paraminfo.Flags;
/* name */
if (paraminfo.oName != -1)
@ -2483,14 +2481,14 @@ MSFT_DoFuncs(TLBContext* pcx,
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) &&
if ( (elemdesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) &&
(pFuncRec->FKCCIC & 0x1000) )
{
INT* pInt = (INT *)((char *)pFuncRec +
reclength -
(pFuncRec->nrargs * 4) * sizeof(INT) );
PARAMDESC* pParamDesc = &elemdesc->u.paramdesc;
PARAMDESC* pParamDesc = &elemdesc->paramdesc;
pParamDesc->pparamdescex = (PARAMDESCEX*)(ptfd->funcdesc.lprgelemdescParam+pFuncRec->nrargs)+j;
pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
@ -2499,7 +2497,7 @@ MSFT_DoFuncs(TLBContext* pcx,
pInt[j], pcx);
}
else
elemdesc->u.paramdesc.pparamdescex = NULL;
elemdesc->paramdesc.pparamdescex = NULL;
/* custom info */
if (optional > (FIELD_OFFSET(MSFT_FuncRecord, oArgCustData) +
@ -2582,11 +2580,11 @@ static void MSFT_DoVars(TLBContext *pcx, ITypeInfoImpl *pTI, int cFuncs,
&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,
ptvd->vardesc.lpvarValue = heap_alloc_zero(sizeof(VARIANT));
MSFT_ReadValue(ptvd->vardesc.lpvarValue,
pVarRec->OffsValue, pcx);
} else
ptvd->vardesc.u.oInst=pVarRec->OffsValue;
ptvd->vardesc.oInst=pVarRec->OffsValue;
recoffset += reclength;
}
}
@ -3539,18 +3537,18 @@ static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
{
/* FIXME: check safearray */
if(td[3] < 0)
pTypeLibImpl->pTypeDesc[i].u.lptdesc = &std_typedesc[td[2]];
pTypeLibImpl->pTypeDesc[i].lptdesc = &std_typedesc[td[2]];
else
pTypeLibImpl->pTypeDesc[i].u.lptdesc = &pTypeLibImpl->pTypeDesc[td[2]/8];
pTypeLibImpl->pTypeDesc[i].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*/
pTypeLibImpl->pTypeDesc[i].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]);
pTypeLibImpl->pTypeDesc[i].hreftype = MAKELONG(td[2],td[3]);
}
if(++i<cTD) MSFT_ReadLEWords(td, sizeof(td), &cx, DO_NOT_SEEK);
}
@ -3561,27 +3559,27 @@ static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
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));
MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (INT_PTR)pTypeLibImpl->pTypeDesc[i].lpadesc);
pTypeLibImpl->pTypeDesc[i].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;
pTypeLibImpl->pTypeDesc[i].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].lpadesc->tdescElem = cx.pLibInfo->pTypeDesc[td[0]/(2*sizeof(INT))];
pTypeLibImpl->pTypeDesc[i].u.lpadesc->cDims = td[2];
pTypeLibImpl->pTypeDesc[i].lpadesc->cDims = td[2];
for(j = 0; j<td[2]; j++)
{
MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements,
MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].lpadesc->rgbounds[j].cElements,
sizeof(INT), &cx, DO_NOT_SEEK);
MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound,
MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].lpadesc->rgbounds[j].lLbound,
sizeof(INT), &cx, DO_NOT_SEEK);
}
}
else
{
pTypeLibImpl->pTypeDesc[i].u.lpadesc = NULL;
pTypeLibImpl->pTypeDesc[i].lpadesc = NULL;
ERR("didn't find array description data\n");
}
}
@ -3803,19 +3801,19 @@ static WORD *SLTG_DoType(WORD *pType, char *pBlk, TYPEDESC *pTD, const sltg_ref_
while(!done) {
if((*pType & 0xe00) == 0xe00) {
pTD->vt = VT_PTR;
pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
pTD = pTD->u.lptdesc;
pTD->lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
pTD = pTD->lptdesc;
}
switch(*pType & 0x3f) {
case VT_PTR:
pTD->vt = VT_PTR;
pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
pTD = pTD->u.lptdesc;
pTD->lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
pTD = pTD->lptdesc;
break;
case VT_USERDEFINED:
pTD->vt = VT_USERDEFINED;
sltg_get_typelib_ref(ref_lookup, *(++pType) / 4, &pTD->u.hreftype);
sltg_get_typelib_ref(ref_lookup, *(++pType) / 4, &pTD->hreftype);
done = TRUE;
break;
@ -3827,12 +3825,12 @@ static WORD *SLTG_DoType(WORD *pType, char *pBlk, TYPEDESC *pTD, const sltg_ref_
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,
pTD->lpadesc = heap_alloc_zero(sizeof(ARRAYDESC) + (pSA->cDims - 1) * sizeof(SAFEARRAYBOUND));
pTD->lpadesc->cDims = pSA->cDims;
memcpy(pTD->lpadesc->rgbounds, pSA->rgsabound,
pSA->cDims * sizeof(SAFEARRAYBOUND));
pTD = &pTD->u.lpadesc->tdescElem;
pTD = &pTD->lpadesc->tdescElem;
break;
}
@ -3843,8 +3841,8 @@ static WORD *SLTG_DoType(WORD *pType, char *pBlk, TYPEDESC *pTD, const sltg_ref_
pType++;
pTD->vt = VT_SAFEARRAY;
pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
pTD = pTD->u.lptdesc;
pTD->lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
pTD = pTD->lptdesc;
break;
}
default:
@ -3862,19 +3860,19 @@ static WORD *SLTG_DoElem(WORD *pType, char *pBlk,
{
/* Handle [in/out] first */
if((*pType & 0xc000) == 0xc000)
pElem->u.paramdesc.wParamFlags = PARAMFLAG_NONE;
pElem->paramdesc.wParamFlags = PARAMFLAG_NONE;
else if(*pType & 0x8000)
pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN | PARAMFLAG_FOUT;
pElem->paramdesc.wParamFlags = PARAMFLAG_FIN | PARAMFLAG_FOUT;
else if(*pType & 0x4000)
pElem->u.paramdesc.wParamFlags = PARAMFLAG_FOUT;
pElem->paramdesc.wParamFlags = PARAMFLAG_FOUT;
else
pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN;
pElem->paramdesc.wParamFlags = PARAMFLAG_FIN;
if(*pType & 0x2000)
pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FLCID;
pElem->paramdesc.wParamFlags |= PARAMFLAG_FLCID;
if(*pType & 0x80)
pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FRETVAL;
pElem->paramdesc.wParamFlags |= PARAMFLAG_FRETVAL;
return SLTG_DoType(pType, pBlk, &pElem->tdesc, ref_lookup);
}
@ -4059,10 +4057,10 @@ static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsign
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;
pVarDesc->vardesc.lpvarValue = heap_alloc(sizeof(VARIANT));
V_VT(pVarDesc->vardesc.lpvarValue) = VT_INT;
if (pItem->flags & 0x08)
V_INT(pVarDesc->vardesc.u.lpvarValue) = pItem->byte_offs;
V_INT(pVarDesc->vardesc.lpvarValue) = pItem->byte_offs;
else {
switch (pVarDesc->vardesc.elemdescVar.tdesc.vt)
{
@ -4080,8 +4078,8 @@ static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsign
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;
V_VT(pVarDesc->vardesc.lpvarValue) = VT_BSTR;
V_BSTR(pVarDesc->vardesc.lpvarValue) = str;
break;
}
case VT_I2:
@ -4090,7 +4088,7 @@ static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsign
case VT_UI4:
case VT_INT:
case VT_UINT:
V_INT(pVarDesc->vardesc.u.lpvarValue) =
V_INT(pVarDesc->vardesc.lpvarValue) =
*(INT*)(pBlk + pItem->byte_offs);
break;
default:
@ -4100,7 +4098,7 @@ static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsign
}
else {
TRACE_(typelib)("VAR_PERINSTANCE\n");
pVarDesc->vardesc.u.oInst = pItem->byte_offs;
pVarDesc->vardesc.oInst = pItem->byte_offs;
pVarDesc->vardesc.varkind = VAR_PERINSTANCE;
}
@ -4212,7 +4210,7 @@ static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI,
/* Are we an optional param ? */
if(pFuncDesc->funcdesc.cParams - param <=
pFuncDesc->funcdesc.cParamsOpt)
pFuncDesc->funcdesc.lprgelemdescParam[param].u.paramdesc.wParamFlags |= PARAMFLAG_FOPT;
pFuncDesc->funcdesc.lprgelemdescParam[param].paramdesc.wParamFlags |= PARAMFLAG_FOPT;
if(paramName) {
pFuncDesc->pParamDesc[param].Name = SLTG_ReadName(pNameTable,
@ -4761,7 +4759,7 @@ static ULONG WINAPI ITypeLib2_fnRelease( ITypeLib2 *iface)
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[i].lpadesc);
heap_free(This->pTypeDesc);
@ -5427,7 +5425,7 @@ static HRESULT WINAPI ITypeLibComp_fnBind(
VAR_STATIC /* varkind */
};
tdesc_appobject.u.hreftype = pTypeInfo->hreftype;
tdesc_appobject.hreftype = pTypeInfo->hreftype;
tdesc_appobject.vt = VT_USERDEFINED;
TRACE("found in implicit app object: %s\n", debugstr_w(szName));
@ -5590,8 +5588,8 @@ static void typeinfo_release_funcdesc(TLBFuncDesc *func)
for (i = 0; i < func->funcdesc.cParams; ++i)
{
ELEMDESC *elemdesc = &func->funcdesc.lprgelemdescParam[i];
if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
if (elemdesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
VariantClear(&elemdesc->paramdesc.pparamdescex->varDefaultValue);
TLB_FreeCustData(&func->pParamDesc[i].custdata_list);
}
heap_free(func->funcdesc.lprgelemdescParam);
@ -5617,8 +5615,8 @@ static void ITypeInfoImpl_Destroy(ITypeInfoImpl *This)
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);
VariantClear(pVInfo->vardesc.lpvarValue);
heap_free(pVInfo->vardesc.lpvarValue);
}
TLB_FreeCustData(&pVInfo->custdata_list);
}
@ -5709,8 +5707,8 @@ static HRESULT WINAPI ITypeInfo_fnGetTypeComp( ITypeInfo2 *iface,
static SIZE_T TLB_SizeElemDesc( const ELEMDESC *elemdesc )
{
SIZE_T size = TLB_SizeTypeDesc(&elemdesc->tdesc, FALSE);
if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
size += sizeof(*elemdesc->u.paramdesc.pparamdescex);
if (elemdesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
size += sizeof(*elemdesc->paramdesc.pparamdescex);
return size;
}
@ -5718,10 +5716,10 @@ static HRESULT TLB_CopyElemDesc( const ELEMDESC *src, ELEMDESC *dest, char **buf
{
*dest = *src;
*buffer = TLB_CopyTypeDesc(&dest->tdesc, &src->tdesc, *buffer);
if (src->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
if (src->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
{
const PARAMDESCEX *pparamdescex_src = src->u.paramdesc.pparamdescex;
PARAMDESCEX *pparamdescex_dest = dest->u.paramdesc.pparamdescex = (PARAMDESCEX *)*buffer;
const PARAMDESCEX *pparamdescex_src = src->paramdesc.pparamdescex;
PARAMDESCEX *pparamdescex_dest = dest->paramdesc.pparamdescex = (PARAMDESCEX *)*buffer;
*buffer += sizeof(PARAMDESCEX);
*pparamdescex_dest = *pparamdescex_src;
pparamdescex_dest->cBytes = sizeof(PARAMDESCEX);
@ -5730,7 +5728,7 @@ static HRESULT TLB_CopyElemDesc( const ELEMDESC *src, ELEMDESC *dest, char **buf
(VARIANTARG *)&pparamdescex_src->varDefaultValue);
}
else
dest->u.paramdesc.pparamdescex = NULL;
dest->paramdesc.pparamdescex = NULL;
return S_OK;
}
@ -5746,8 +5744,8 @@ static HRESULT TLB_SanitizeVariant(VARIANT *var)
static void TLB_FreeElemDesc( ELEMDESC *elemdesc )
{
if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
if (elemdesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
VariantClear(&elemdesc->paramdesc.pparamdescex->varDefaultValue);
}
static HRESULT TLB_AllocAndInitFuncDesc( const FUNCDESC *src, FUNCDESC **dest_ptr, BOOL dispinterface )
@ -5819,7 +5817,7 @@ static HRESULT TLB_AllocAndInitFuncDesc( const FUNCDESC *src, FUNCDESC **dest_pt
/* functions that have a [retval] parameter return this value into pVarResult.
* [retval] is always the last parameter (if present) */
if (dest->cParams &&
(dest->lprgelemdescParam[dest->cParams - 1].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
(dest->lprgelemdescParam[dest->cParams - 1].paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
{
ELEMDESC *elemdesc = &dest->lprgelemdescParam[dest->cParams - 1];
if (elemdesc->tdesc.vt != VT_PTR)
@ -5833,7 +5831,7 @@ static HRESULT TLB_AllocAndInitFuncDesc( const FUNCDESC *src, FUNCDESC **dest_pt
/* the type pointed to by this [retval] becomes elemdescFunc,
* i.e. the function signature's return type.
* We are using a flat buffer so there is no danger of leaking memory */
dest->elemdescFunc.tdesc = *elemdesc->tdesc.u.lptdesc;
dest->elemdescFunc.tdesc = *elemdesc->tdesc.lptdesc;
/* remove the last parameter */
dest->cParams--;
@ -5845,7 +5843,7 @@ static HRESULT TLB_AllocAndInitFuncDesc( const FUNCDESC *src, FUNCDESC **dest_pt
/* The now-last (except [retval], removed above) parameter might be labeled [lcid].
* If so it will be supplied from Invoke(lcid), so also not via DISPPARAMS::rgvarg */
if (dest->cParams && (dest->lprgelemdescParam[dest->cParams - 1].u.paramdesc.wParamFlags & PARAMFLAG_FLCID))
if (dest->cParams && (dest->lprgelemdescParam[dest->cParams - 1].paramdesc.wParamFlags & PARAMFLAG_FLCID))
dest->cParams--;
}
@ -5857,7 +5855,7 @@ static void TLB_FreeVarDesc(VARDESC *var_desc)
{
TLB_FreeElemDesc(&var_desc->elemdescVar);
if (var_desc->varkind == VAR_CONST)
VariantClear(var_desc->u.lpvarValue);
VariantClear(var_desc->lpvarValue);
SysFreeString((BSTR)var_desc);
}
@ -5933,14 +5931,14 @@ static inline void ITypeInfoImpl_ElemDescAddHrefOffset( LPELEMDESC pElemDesc, UI
switch (pTypeDesc->vt)
{
case VT_USERDEFINED:
pTypeDesc->u.hreftype += hrefoffset;
pTypeDesc->hreftype += hrefoffset;
return;
case VT_PTR:
case VT_SAFEARRAY:
pTypeDesc = pTypeDesc->u.lptdesc;
pTypeDesc = pTypeDesc->lptdesc;
break;
case VT_CARRAY:
pTypeDesc = &pTypeDesc->u.lpadesc->tdescElem;
pTypeDesc = &pTypeDesc->lpadesc->tdescElem;
break;
default:
return;
@ -6028,11 +6026,11 @@ static HRESULT TLB_AllocAndInitVarDesc( const VARDESC *src, VARDESC **dest_ptr )
{
HRESULT hr;
dest->u.lpvarValue = (VARIANT *)buffer;
*dest->u.lpvarValue = *src->u.lpvarValue;
dest->lpvarValue = (VARIANT *)buffer;
*dest->lpvarValue = *src->lpvarValue;
buffer += sizeof(VARIANT);
VariantInit(dest->u.lpvarValue);
hr = VariantCopy(dest->u.lpvarValue, src->u.lpvarValue);
VariantInit(dest->lpvarValue);
hr = VariantCopy(dest->lpvarValue, src->lpvarValue);
if (FAILED(hr))
{
SysFreeString((BSTR)dest);
@ -6043,7 +6041,7 @@ static HRESULT TLB_AllocAndInitVarDesc( const VARDESC *src, VARDESC **dest_ptr )
if (FAILED(hr))
{
if (src->varkind == VAR_CONST)
VariantClear(dest->u.lpvarValue);
VariantClear(dest->lpvarValue);
SysFreeString((BSTR)dest);
return hr;
}
@ -6098,9 +6096,9 @@ static HRESULT typeinfo_getnames( ITypeInfo *iface, MEMBERID memid, BSTR *names,
if (dispinterface && (func_desc->funcdesc.funckind != FUNC_DISPATCH))
{
/* match the rewriting of special trailing parameters in TLB_AllocAndInitFuncDesc */
if ((params > 0) && (func_desc->funcdesc.lprgelemdescParam[params - 1].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
if ((params > 0) && (func_desc->funcdesc.lprgelemdescParam[params - 1].paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
--params; /* Invoke(pVarResult) supplies the [retval] parameter, so it's hidden from DISPPARAMS */
if ((params > 0) && (func_desc->funcdesc.lprgelemdescParam[params - 1].u.paramdesc.wParamFlags & PARAMFLAG_FLCID))
if ((params > 0) && (func_desc->funcdesc.lprgelemdescParam[params - 1].paramdesc.wParamFlags & PARAMFLAG_FLCID))
--params; /* Invoke(lcid) supplies the [lcid] parameter, so it's hidden from DISPPARAMS */
}
@ -6985,10 +6983,10 @@ static HRESULT userdefined_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc,
ITypeInfo *tinfo2 = NULL;
TYPEATTR *tattr = NULL;
hr = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2);
hr = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->hreftype, &tinfo2);
if (hr)
{
ERR("Could not get typeinfo of hreftype %lx for VT_USERDEFINED, hr %#lx.\n", tdesc->u.hreftype, hr);
ERR("Could not get typeinfo of hreftype %lx for VT_USERDEFINED, hr %#lx.\n", tdesc->hreftype, hr);
return hr;
}
hr = ITypeInfo_GetTypeAttr(tinfo2, &tattr);
@ -7051,20 +7049,20 @@ static HRESULT typedescvt_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc,
/* enforce only one level of pointer indirection */
if (!(*vt & VT_BYREF) && !(*vt & VT_ARRAY) && (tdesc->vt == VT_PTR))
{
tdesc = tdesc->u.lptdesc;
tdesc = tdesc->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)))
((tdesc->vt == VT_PTR) && (tdesc->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;
tdesc_userdefined = tdesc->lptdesc;
}
hr = userdefined_to_variantvt(tinfo, tdesc_userdefined, &vt_userdefined);
if ((hr == S_OK) &&
@ -7096,7 +7094,7 @@ static HRESULT typedescvt_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc,
break;
case VT_SAFEARRAY:
*vt |= VT_ARRAY;
hr = typedescvt_to_variantvt(tinfo, tdesc->u.lptdesc, vt);
hr = typedescvt_to_variantvt(tinfo, tdesc->lptdesc, vt);
break;
case VT_INT:
*vt |= VT_I4;
@ -7130,7 +7128,7 @@ static HRESULT get_iface_guid(ITypeInfo *tinfo, HREFTYPE href, GUID *guid)
switch(tattr->typekind) {
case TKIND_ALIAS:
hres = get_iface_guid(tinfo2, tattr->tdescAlias.u.hreftype, guid);
hres = get_iface_guid(tinfo2, tattr->tdescAlias.hreftype, guid);
break;
case TKIND_INTERFACE:
@ -7282,7 +7280,7 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
TRACE("changing args\n");
for (i = 0; i < func_desc->cParams; i++)
{
USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
USHORT wParamFlags = func_desc->lprgelemdescParam[i].paramdesc.wParamFlags;
TYPEDESC *tdesc = &func_desc->lprgelemdescParam[i].tdesc;
VARIANTARG *src_arg;
@ -7433,16 +7431,16 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
prgpvarg[i] = src_arg;
}
if((tdesc->vt == VT_USERDEFINED || (tdesc->vt == VT_PTR && tdesc->u.lptdesc->vt == VT_USERDEFINED))
if((tdesc->vt == VT_USERDEFINED || (tdesc->vt == VT_PTR && tdesc->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;
tdesc = tdesc->lptdesc;
hres = get_iface_guid((ITypeInfo*)iface, tdesc->u.hreftype, &guid);
hres = get_iface_guid((ITypeInfo*)iface, tdesc->hreftype, &guid);
if(FAILED(hres))
break;
@ -7462,7 +7460,7 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
arg = prgpvarg[i] = &rgvarg[i];
if (wParamFlags & PARAMFLAG_FHASDEFAULT)
{
hres = VariantCopy(arg, &func_desc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
hres = VariantCopy(arg, &func_desc->lprgelemdescParam[i].paramdesc.pparamdescex->varDefaultValue);
if (FAILED(hres))
break;
}
@ -7513,7 +7511,7 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
for (i = 0; i < func_desc->cParams; i++)
{
USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
USHORT wParamFlags = func_desc->lprgelemdescParam[i].paramdesc.wParamFlags;
if (wParamFlags & PARAMFLAG_FLCID)
continue;
@ -7621,7 +7619,7 @@ static HRESULT WINAPI ITypeInfo_fnInvoke(
if (SUCCEEDED(hres) && pVarResult && (func_desc->cParams == 1) &&
(func_desc->invkind & INVOKE_PROPERTYGET) &&
(func_desc->lprgelemdescParam[0].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL) &&
(func_desc->lprgelemdescParam[0].paramdesc.wParamFlags & PARAMFLAG_FRETVAL) &&
(pDispParams->cArgs != 0))
{
if (V_VT(pVarResult) == VT_DISPATCH)
@ -8717,8 +8715,8 @@ HRESULT WINAPI CreateDispTypeInfo(
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.elemdescFunc.paramdesc.wParamFlags = PARAMFLAG_NONE;
pFuncDesc->funcdesc.elemdescFunc.paramdesc.pparamdescex = NULL;
pFuncDesc->funcdesc.lprgelemdescParam = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
md->cArgs * sizeof(ELEMDESC));
pFuncDesc->pParamDesc = TLBParDesc_Constructor(md->cArgs);
@ -9489,17 +9487,17 @@ static DWORD WMSFT_append_typedesc(TYPEDESC *desc, WMSFT_TLBFile *file, DWORD *o
if(vt == VT_PTR || vt == VT_SAFEARRAY){
DWORD mix;
encoded[1] = WMSFT_append_typedesc(desc->u.lptdesc, file, &mix, out_size);
encoded[1] = WMSFT_append_typedesc(desc->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);
encoded[1] = WMSFT_append_arraydesc(desc->lpadesc, file);
*out_mix = 0x7FFE;
}else if(vt == VT_USERDEFINED){
encoded[0] = desc->vt | (0x7FFF << 16);
encoded[1] = desc->u.hreftype;
encoded[1] = desc->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);
@ -9606,7 +9604,7 @@ static DWORD WMSFT_compile_typeinfo_aux(ITypeInfoImpl *info,
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){
if(desc->funcdesc.lprgelemdescParam[j].paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT){
recorded_size += desc->funcdesc.cParams * sizeof(INT);
break;
}
@ -9682,7 +9680,7 @@ static DWORD WMSFT_compile_typeinfo_aux(ITypeInfoImpl *info,
funcrecord->FKCCIC |= 0x2000;
for(j = 0; j < desc->funcdesc.cParams; ++j){
if(desc->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT){
if(desc->funcdesc.lprgelemdescParam[j].paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT){
paramdefault_size = sizeof(INT) * desc->funcdesc.cParams;
funcrecord->funcdescsize += sizeof(PARAMDESCEX);
}
@ -9761,11 +9759,11 @@ static DWORD WMSFT_compile_typeinfo_aux(ITypeInfoImpl *info,
info->oName = desc->pParamDesc[j].Name->offset;
else
info->oName = -1;
info->Flags = desc->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags;
info->Flags = desc->funcdesc.lprgelemdescParam[j].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);
if(desc->funcdesc.lprgelemdescParam[j].paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
*paramdefault = WMSFT_encode_variant(&desc->funcdesc.lprgelemdescParam[j].paramdesc.pparamdescex->varDefaultValue, file);
else if(paramdefault_size)
*paramdefault = -1;
++paramdefault;
@ -9795,9 +9793,9 @@ static DWORD WMSFT_compile_typeinfo_aux(ITypeInfoImpl *info,
if(desc->vardesc.varkind == VAR_CONST){
varrecord->vardescsize += sizeof(VARIANT);
varrecord->OffsValue = WMSFT_encode_variant(desc->vardesc.u.lpvarValue, file);
varrecord->OffsValue = WMSFT_encode_variant(desc->vardesc.lpvarValue, file);
}else
varrecord->OffsValue = desc->vardesc.u.oInst;
varrecord->OffsValue = desc->vardesc.oInst;
/* res9? */
if(desc->HelpStringContext != 0){
@ -10756,10 +10754,10 @@ static HRESULT WINAPI ICreateTypeInfo2_fnAddFuncDesc(ICreateTypeInfo2 *iface,
heap_free(tmp_func_desc.funcdesc.lprgscode);
return hres;
}
if (tmp_func_desc.funcdesc.lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT &&
if (tmp_func_desc.funcdesc.lprgelemdescParam[i].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);
hres = TLB_SanitizeVariant(&tmp_func_desc.funcdesc.lprgelemdescParam[i].paramdesc.pparamdescex->varDefaultValue);
if (FAILED(hres)) {
heap_free(tmp_func_desc.funcdesc.lprgelemdescParam);
heap_free(tmp_func_desc.funcdesc.lprgscode);

24
dlls/oleaut32/usrmarshal.c
View File

@ -23,8 +23,6 @@
#include <string.h>
#define COBJMACROS
#define NONAMELESSUNION
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
@ -1441,12 +1439,12 @@ static void free_embedded_arraydesc(ARRAYDESC *adesc)
{
case VT_PTR:
case VT_SAFEARRAY:
free_embedded_typedesc(adesc->tdescElem.u.lptdesc);
CoTaskMemFree(adesc->tdescElem.u.lptdesc);
free_embedded_typedesc(adesc->tdescElem.lptdesc);
CoTaskMemFree(adesc->tdescElem.lptdesc);
break;
case VT_CARRAY:
free_embedded_arraydesc(adesc->tdescElem.u.lpadesc);
CoTaskMemFree(adesc->tdescElem.u.lpadesc);
free_embedded_arraydesc(adesc->tdescElem.lpadesc);
CoTaskMemFree(adesc->tdescElem.lpadesc);
break;
}
}
@ -1457,12 +1455,12 @@ static void free_embedded_typedesc(TYPEDESC *tdesc)
{
case VT_PTR:
case VT_SAFEARRAY:
free_embedded_typedesc(tdesc->u.lptdesc);
CoTaskMemFree(tdesc->u.lptdesc);
free_embedded_typedesc(tdesc->lptdesc);
CoTaskMemFree(tdesc->lptdesc);
break;
case VT_CARRAY:
free_embedded_arraydesc(tdesc->u.lpadesc);
CoTaskMemFree(tdesc->u.lpadesc);
free_embedded_arraydesc(tdesc->lpadesc);
CoTaskMemFree(tdesc->lpadesc);
break;
}
}
@ -1470,8 +1468,8 @@ static void free_embedded_typedesc(TYPEDESC *tdesc)
static void free_embedded_elemdesc(ELEMDESC *edesc)
{
free_embedded_typedesc(&edesc->tdesc);
if(edesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
CoTaskMemFree(edesc->u.paramdesc.pparamdescex);
if(edesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
CoTaskMemFree(edesc->paramdesc.pparamdescex);
}
/* ITypeComp */
@ -1999,7 +1997,7 @@ void CALLBACK ITypeInfo_ReleaseVarDesc_Proxy(
CoTaskMemFree(pVarDesc->lpstrSchema);
if(pVarDesc->varkind == VAR_CONST)
CoTaskMemFree(pVarDesc->u.lpvarValue);
CoTaskMemFree(pVarDesc->lpvarValue);
free_embedded_elemdesc(&pVarDesc->elemdescVar);
CoTaskMemFree(pVarDesc);