mirror of
git://source.winehq.org/git/wine.git
synced 2024-07-21 15:14:09 +00:00
oleaut32: Use nameless unions/structs.
This commit is contained in:
parent
36963b6d27
commit
374d74e843
|
@ -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 */
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
@ -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))
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
Loading…
Reference in a new issue