diff --git a/dlls/oleaut32/olepicture.c b/dlls/oleaut32/olepicture.c index 46a33220870..be7bb83e37b 100644 --- a/dlls/oleaut32/olepicture.c +++ b/dlls/oleaut32/olepicture.c @@ -1117,8 +1117,8 @@ static HRESULT WINAPI OLEPictureImpl_Invoke( FIXME("(dispid: %ld):Stub\n",dispIdMember); VariantInit(pVarResult); - pVarResult->vt = VT_BOOL; - pVarResult->u.boolVal = FALSE; + V_VT(pVarResult) = VT_BOOL; + V_UNION(pVarResult,boolVal) = FALSE; return S_OK; } diff --git a/dlls/oleaut32/typelib.c b/dlls/oleaut32/typelib.c index 1293752f081..9ce5a2481ce 100644 --- a/dlls/oleaut32/typelib.c +++ b/dlls/oleaut32/typelib.c @@ -760,8 +760,8 @@ static void dump_Variant(VARIANT * pvar) break; } - if (pvar->vt & VT_BYREF) - return dump_Variant(pvar->u.pvarVal); + if (V_VT(pvar) & VT_BYREF) + return dump_Variant(V_UNION(pvar,pvarVal)); } static void dump_DispParms(DISPPARAMS * pdp) @@ -947,14 +947,14 @@ static void TLB_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx ) TRACE_(typelib)("\n"); if(offset <0) { /* data is packed in here */ - pVar->vt = (offset & 0x7c000000 )>> 26; + V_VT(pVar) = (offset & 0x7c000000 )>> 26; V_UNION(pVar, iVal) = offset & 0xffff; return; } - TLB_Read(&(pVar->vt), sizeof(VARTYPE), pcx, + TLB_Read(&(V_VT(pVar)), sizeof(VARTYPE), pcx, pcx->pTblDir->pCustData.offset + offset ); - TRACE_(typelib)("Vartype = %x\n", pVar->vt); - switch(pVar->vt){ + TRACE_(typelib)("Vartype = %x\n", V_VT(pVar)); + switch (V_VT(pVar)){ case VT_EMPTY: /* FIXME: is this right? */ case VT_NULL: /* FIXME: is this right? */ case VT_I2 : /* this should not happen */ @@ -1017,7 +1017,7 @@ static void TLB_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx ) default: size=0; FIXME("VARTYPE %d is not supported, setting pointer to NULL\n", - pVar->vt); + V_VT(pVar)); } if(size>0) /* (big|small) endian correct? */ @@ -1203,8 +1203,7 @@ TLB_DoFuncs(TLBContext* pcx, paraminfo.DataType, &(*pptfd)->funcdesc.lprgelemdescParam[j].tdesc) ; - V_UNION(& ((*pptfd)->funcdesc.lprgelemdescParam[j]), - paramdesc.wParamFlags) = paraminfo.Flags; + (*pptfd)->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags = paraminfo.Flags; (*pptfd)->pParamDesc[j].Name = (void *) paraminfo.oName; @@ -1298,21 +1297,18 @@ TLB_DoFuncs(TLBContext* pcx, /* default value */ if ( (PARAMFLAG_FHASDEFAULT & - V_UNION(&((*pptfd)->funcdesc.lprgelemdescParam[j]), - paramdesc.wParamFlags)) && + (*pptfd)->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags) && ((pFuncRec->FKCCIC) & 0x1000) ) { INT* pInt = (INT *)((char *)pFuncRec + reclength - (pFuncRec->nrargs * 4 + 1) * sizeof(INT) ); - PARAMDESC* pParamDesc = &V_UNION( - & ((*pptfd)->funcdesc.lprgelemdescParam[j]), - paramdesc); + PARAMDESC* pParamDesc = & (*pptfd)->funcdesc.lprgelemdescParam[j].u.paramdesc; pParamDesc->pparamdescex = TLB_Alloc(sizeof(PARAMDESCEX)); pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX); - + TLB_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue), pInt[j], pcx); } @@ -1325,11 +1321,11 @@ TLB_DoFuncs(TLBContext* pcx, } } } - + /* scode is not used: archaic win16 stuff FIXME: right? */ (*pptfd)->funcdesc.cScodes = 0 ; (*pptfd)->funcdesc.lprgscode = NULL ; - + pptfd = & ((*pptfd)->next); recoffset += reclength; } @@ -1376,11 +1372,11 @@ static void TLB_DoVars(TLBContext *pcx, int cFuncs, int cVars, &(*pptvd)->vardesc.elemdescVar.tdesc) ; /* (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) fixme?? */ if(pVarRec->VarKind == VAR_CONST ){ - V_UNION(&((*pptvd)->vardesc),lpvarValue)=TLB_Alloc(sizeof(VARIANT)); - TLB_ReadValue(V_UNION(&((*pptvd)->vardesc),lpvarValue), + (*pptvd)->vardesc.u.lpvarValue=TLB_Alloc(sizeof(VARIANT)); + TLB_ReadValue((*pptvd)->vardesc.u.lpvarValue, pVarRec->OffsValue, pcx); - }else - V_UNION(&((*pptvd)->vardesc),oInst)=pVarRec->OffsValue; + } else + (*pptvd)->vardesc.u.oInst=pVarRec->OffsValue; pptvd=&((*pptvd)->next); recoffset += reclength; } @@ -1805,18 +1801,18 @@ static ITypeLib2* ITypeLib2_Constructor(LPVOID pLib, DWORD dwTLBLength) { /* FIXME: check safearray */ if(td[3] < 0) - V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lptdesc)= & stndTypeDesc[td[2]]; + pTypeLibImpl->pTypeDesc[i].u.lptdesc= & stndTypeDesc[td[2]]; else - V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lptdesc)= & pTypeLibImpl->pTypeDesc[td[2]/8]; + pTypeLibImpl->pTypeDesc[i].u.lptdesc= & pTypeLibImpl->pTypeDesc[td[2]/8]; } else if(td[0] == VT_CARRAY) { /* array descr table here */ - V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc) = (void *)((int) td[2]); /* temp store offset in*/ - } + pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)((int) td[2]); /* temp store offset in*/ + } else if(td[0] == VT_USERDEFINED) { - V_UNION(&(pTypeLibImpl->pTypeDesc[i]),hreftype) = MAKELONG(td[2],td[3]); + pTypeLibImpl->pTypeDesc[i].u.hreftype = MAKELONG(td[2],td[3]); } if(++ipTypeDesc[i].vt != VT_CARRAY) continue; if(tlbSegDir.pArrayDescriptions.offset>0) { - TLB_Read(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (int) V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)); - V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc) = TLB_Alloc(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1)); + TLB_Read(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (int) pTypeLibImpl->pTypeDesc[i].u.lpadesc); + pTypeLibImpl->pTypeDesc[i].u.lpadesc = TLB_Alloc(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1)); if(td[1]<0) - V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->tdescElem.vt = td[0] & VT_TYPEMASK; + pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem.vt = td[0] & VT_TYPEMASK; else - V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->tdescElem = stndTypeDesc[td[0]/8]; + pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem = stndTypeDesc[td[0]/8]; - V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->cDims = td[2]; + pTypeLibImpl->pTypeDesc[i].u.lpadesc->cDims = td[2]; for(j = 0; jpTypeDesc[i]),lpadesc)->rgbounds[j].cElements, + TLB_Read(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements, sizeof(INT), &cx, DO_NOT_SEEK); - TLB_Read(& V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->rgbounds[j].lLbound, + TLB_Read(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound, sizeof(INT), &cx, DO_NOT_SEEK); } } else { - V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc) = NULL; + pTypeLibImpl->pTypeDesc[i].u.lpadesc = NULL; ERR("didn't find array description data\n"); } } @@ -2940,10 +2936,10 @@ static HRESULT WINAPI ITypeInfo_fnInvoke( for (i=0;ifuncdesc.cParams;i++) { if (icArgs) { TRACE("set %d to disparg type %d vs %d\n",i, - pDispParams->rgvarg[i].vt, + V_VT(pDispParams->rgvarg+i), pFDesc->funcdesc.lprgelemdescParam[i].tdesc.vt ); - args[i+1] = pDispParams->rgvarg[i].u.lVal; + args[i+1] = V_UNION(pDispParams->rgvarg+i,lVal); } else { TYPEDESC *tdesc = &(pFDesc->funcdesc.lprgelemdescParam[i].tdesc); TRACE("set %d to pointer for get (type is %d)\n",i,tdesc->vt); @@ -2978,11 +2974,11 @@ static HRESULT WINAPI ITypeInfo_fnInvoke( continue; VariantInit(&pVarResult[i]); - pVarResult[i].u.intVal = args2[i]; + V_UNION(pVarResult+i,intVal) = args2[i]; if (tdesc->vt == VT_PTR) tdesc = tdesc->u.lptdesc; - pVarResult[i].vt = tdesc->vt; + V_VT(pVarResult+i) = tdesc->vt; /* HACK: VB5 likes this. * I do not know why. There is 1 example in MSDN which uses @@ -2990,9 +2986,9 @@ static HRESULT WINAPI ITypeInfo_fnInvoke( * IDispatch*.). */ if ((tdesc->vt == VT_PTR) && (dwFlags & DISPATCH_METHOD)) - pVarResult[i].vt = VT_DISPATCH; + V_VT(pVarResult+i) = VT_DISPATCH; TRACE("storing into variant: [%d] type %d, val %08x\n", - i,pVarResult[i].vt,pVarResult[i].u.intVal + i,V_VT(pVarResult+i),V_UNION(pVarResult+i,intVal) ); } } diff --git a/dlls/oleaut32/variant.c b/dlls/oleaut32/variant.c index 07985623adf..1597c49d52b 100644 --- a/dlls/oleaut32/variant.c +++ b/dlls/oleaut32/variant.c @@ -471,7 +471,7 @@ static BOOL DateToTm( DATE dateIn, DWORD dwFlags, struct tm* pTm ) static int SizeOfVariantData( VARIANT* parg ) { int size = 0; - switch( parg->vt & VT_TYPEMASK ) + switch( V_VT(parg) & VT_TYPEMASK ) { case( VT_I2 ): size = sizeof(short); @@ -514,7 +514,7 @@ static int SizeOfVariantData( VARIANT* parg ) case( VT_UNKNOWN ): case( VT_DECIMAL ): default: - FIXME("Add size information for type vt=%d\n", parg->vt & VT_TYPEMASK ); + FIXME("Add size information for type vt=%d\n", V_VT(parg) & VT_TYPEMASK ); break; } @@ -879,7 +879,7 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, { HRESULT res = S_OK; unsigned short vtFrom = 0; - vtFrom = ps->vt & VT_TYPEMASK; + vtFrom = V_VT(ps) & VT_TYPEMASK; /* Note: Since "long" and "int" values both have 4 bytes and are @@ -906,7 +906,7 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, res = VariantClear( pd ); if( res == S_OK ) { - pd->vt = VT_NULL; + V_VT(pd) = VT_NULL; } break; case( VT_I1 ): @@ -916,44 +916,44 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, res = VariantCopy( pd, ps ); break; case( VT_I2 ): - res = VarI1FromI2( ps->u.iVal, &(pd->u.cVal) ); + res = VarI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,cVal) ); break; case( VT_INT ): case( VT_I4 ): - res = VarI1FromI4( ps->u.lVal, &(pd->u.cVal) ); + res = VarI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,cVal) ); break; case( VT_UI1 ): - res = VarI1FromUI1( ps->u.bVal, &(pd->u.cVal) ); + res = VarI1FromUI1( V_UNION(ps,bVal), &V_UNION(pd,cVal) ); break; case( VT_UI2 ): - res = VarI1FromUI2( ps->u.uiVal, &(pd->u.cVal) ); + res = VarI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cVal) ); break; case( VT_UINT ): case( VT_UI4 ): - res = VarI1FromUI4( ps->u.ulVal, &(pd->u.cVal) ); + res = VarI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cVal) ); break; case( VT_R4 ): - res = VarI1FromR4( ps->u.fltVal, &(pd->u.cVal) ); + res = VarI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,cVal) ); break; case( VT_R8 ): - res = VarI1FromR8( ps->u.dblVal, &(pd->u.cVal) ); + res = VarI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,cVal) ); break; case( VT_DATE ): - res = VarI1FromDate( ps->u.date, &(pd->u.cVal) ); + res = VarI1FromDate( V_UNION(ps,date), &V_UNION(pd,cVal) ); break; case( VT_BOOL ): - res = VarI1FromBool( ps->u.boolVal, &(pd->u.cVal) ); + res = VarI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,cVal) ); break; case( VT_BSTR ): - res = VarI1FromStr( ps->u.bstrVal, lcid, 0, &(pd->u.cVal) ); + res = VarI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cVal) ); break; case( VT_CY ): - res = VarI1FromCy( ps->u.cyVal, &(pd->u.cVal) ); + res = VarI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,cVal) ); break; case( VT_DISPATCH ): - /*res = VarI1FromDisp( ps->u.pdispVal, lcid, &(pd->u.cVal) );*/ + /*res = VarI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cVal) );*/ case( VT_DECIMAL ): - /*res = VarI1FromDec( ps->u.decVal, &(pd->u.cVal) );*/ + /*res = VarI1FromDec( V_UNION(ps,decVal), &V_UNION(pd,cVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; @@ -966,47 +966,47 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, switch( vtFrom ) { case( VT_I1 ): - res = VarI2FromI1( ps->u.cVal, &(pd->u.iVal) ); + res = VarI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,iVal) ); break; case( VT_I2 ): res = VariantCopy( pd, ps ); break; case( VT_INT ): case( VT_I4 ): - res = VarI2FromI4( ps->u.lVal, &(pd->u.iVal) ); + res = VarI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,iVal) ); break; case( VT_UI1 ): - res = VarI2FromUI1( ps->u.bVal, &(pd->u.iVal) ); + res = VarI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,iVal) ); break; case( VT_UI2 ): - res = VarI2FromUI2( ps->u.uiVal, &(pd->u.iVal) ); + res = VarI2FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,iVal) ); break; case( VT_UINT ): case( VT_UI4 ): - res = VarI2FromUI4( ps->u.ulVal, &(pd->u.iVal) ); + res = VarI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,iVal) ); break; case( VT_R4 ): - res = VarI2FromR4( ps->u.fltVal, &(pd->u.iVal) ); + res = VarI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,iVal) ); break; case( VT_R8 ): - res = VarI2FromR8( ps->u.dblVal, &(pd->u.iVal) ); + res = VarI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,iVal) ); break; case( VT_DATE ): - res = VarI2FromDate( ps->u.date, &(pd->u.iVal) ); + res = VarI2FromDate( V_UNION(ps,date), &V_UNION(pd,iVal) ); break; case( VT_BOOL ): - res = VarI2FromBool( ps->u.boolVal, &(pd->u.iVal) ); + res = VarI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,iVal) ); break; case( VT_BSTR ): - res = VarI2FromStr( ps->u.bstrVal, lcid, 0, &(pd->u.iVal) ); + res = VarI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,iVal) ); break; case( VT_CY ): - res = VarI2FromCy( ps->u.cyVal, &(pd->u.iVal) ); + res = VarI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,iVal) ); break; case( VT_DISPATCH ): - /*res = VarI2FromDisp( ps->u.pdispVal, lcid, &(pd->u.iVal) );*/ + /*res = VarI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,iVal) );*/ case( VT_DECIMAL ): - /*res = VarI2FromDec( ps->u.deiVal, &(pd->u.iVal) );*/ + /*res = VarI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,iVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; @@ -1020,47 +1020,47 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, switch( vtFrom ) { case( VT_I1 ): - res = VarI4FromI1( ps->u.cVal, &(pd->u.lVal) ); + res = VarI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,lVal) ); break; case( VT_I2 ): - res = VarI4FromI2( ps->u.iVal, &(pd->u.lVal) ); + res = VarI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,lVal) ); break; case( VT_INT ): case( VT_I4 ): res = VariantCopy( pd, ps ); break; case( VT_UI1 ): - res = VarI4FromUI1( ps->u.bVal, &(pd->u.lVal) ); + res = VarI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,lVal) ); break; case( VT_UI2 ): - res = VarI4FromUI2( ps->u.uiVal, &(pd->u.lVal) ); + res = VarI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,lVal) ); break; case( VT_UINT ): case( VT_UI4 ): - res = VarI4FromUI4( ps->u.ulVal, &(pd->u.lVal) ); + res = VarI4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,lVal) ); break; case( VT_R4 ): - res = VarI4FromR4( ps->u.fltVal, &(pd->u.lVal) ); + res = VarI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,lVal) ); break; case( VT_R8 ): - res = VarI4FromR8( ps->u.dblVal, &(pd->u.lVal) ); + res = VarI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,lVal) ); break; case( VT_DATE ): - res = VarI4FromDate( ps->u.date, &(pd->u.lVal) ); + res = VarI4FromDate( V_UNION(ps,date), &V_UNION(pd,lVal) ); break; case( VT_BOOL ): - res = VarI4FromBool( ps->u.boolVal, &(pd->u.lVal) ); + res = VarI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,lVal) ); break; case( VT_BSTR ): - res = VarI4FromStr( ps->u.bstrVal, lcid, 0, &(pd->u.lVal) ); + res = VarI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,lVal) ); break; case( VT_CY ): - res = VarI4FromCy( ps->u.cyVal, &(pd->u.lVal) ); + res = VarI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,lVal) ); break; case( VT_DISPATCH ): - /*res = VarI4FromDisp( ps->u.pdispVal, lcid, &(pd->u.lVal) );*/ + /*res = VarI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,lVal) );*/ case( VT_DECIMAL ): - /*res = VarI4FromDec( ps->u.deiVal, &(pd->u.lVal) );*/ + /*res = VarI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,lVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; @@ -1073,47 +1073,47 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, switch( vtFrom ) { case( VT_I1 ): - res = VarUI1FromI1( ps->u.cVal, &(pd->u.bVal) ); + res = VarUI1FromI1( V_UNION(ps,cVal), &V_UNION(pd,bVal) ); break; case( VT_I2 ): - res = VarUI1FromI2( ps->u.iVal, &(pd->u.bVal) ); + res = VarUI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,bVal) ); break; case( VT_INT ): case( VT_I4 ): - res = VarUI1FromI4( ps->u.lVal, &(pd->u.bVal) ); + res = VarUI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,bVal) ); break; case( VT_UI1 ): res = VariantCopy( pd, ps ); break; case( VT_UI2 ): - res = VarUI1FromUI2( ps->u.uiVal, &(pd->u.bVal) ); + res = VarUI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,bVal) ); break; case( VT_UINT ): case( VT_UI4 ): - res = VarUI1FromUI4( ps->u.ulVal, &(pd->u.bVal) ); + res = VarUI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,bVal) ); break; case( VT_R4 ): - res = VarUI1FromR4( ps->u.fltVal, &(pd->u.bVal) ); + res = VarUI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,bVal) ); break; case( VT_R8 ): - res = VarUI1FromR8( ps->u.dblVal, &(pd->u.bVal) ); + res = VarUI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,bVal) ); break; case( VT_DATE ): - res = VarUI1FromDate( ps->u.date, &(pd->u.bVal) ); + res = VarUI1FromDate( V_UNION(ps,date), &V_UNION(pd,bVal) ); break; case( VT_BOOL ): - res = VarUI1FromBool( ps->u.boolVal, &(pd->u.bVal) ); + res = VarUI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,bVal) ); break; case( VT_BSTR ): - res = VarUI1FromStr( ps->u.bstrVal, lcid, 0, &(pd->u.bVal) ); + res = VarUI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,bVal) ); break; case( VT_CY ): - res = VarUI1FromCy( ps->u.cyVal, &(pd->u.bVal) ); + res = VarUI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,bVal) ); break; case( VT_DISPATCH ): - /*res = VarUI1FromDisp( ps->u.pdispVal, lcid, &(pd->u.bVal) );*/ + /*res = VarUI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,bVal) );*/ case( VT_DECIMAL ): - /*res = VarUI1FromDec( ps->u.deiVal, &(pd->u.bVal) );*/ + /*res = VarUI1FromDec( V_UNION(ps,deiVal), &V_UNION(pd,bVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; @@ -1126,47 +1126,47 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, switch( vtFrom ) { case( VT_I1 ): - res = VarUI2FromI1( ps->u.cVal, &(pd->u.uiVal) ); + res = VarUI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,uiVal) ); break; case( VT_I2 ): - res = VarUI2FromI2( ps->u.iVal, &(pd->u.uiVal) ); + res = VarUI2FromI2( V_UNION(ps,iVal), &V_UNION(pd,uiVal) ); break; case( VT_INT ): case( VT_I4 ): - res = VarUI2FromI4( ps->u.lVal, &(pd->u.uiVal) ); + res = VarUI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,uiVal) ); break; case( VT_UI1 ): - res = VarUI2FromUI1( ps->u.bVal, &(pd->u.uiVal) ); + res = VarUI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,uiVal) ); break; case( VT_UI2 ): res = VariantCopy( pd, ps ); break; case( VT_UINT ): case( VT_UI4 ): - res = VarUI2FromUI4( ps->u.ulVal, &(pd->u.uiVal) ); + res = VarUI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,uiVal) ); break; case( VT_R4 ): - res = VarUI2FromR4( ps->u.fltVal, &(pd->u.uiVal) ); + res = VarUI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,uiVal) ); break; case( VT_R8 ): - res = VarUI2FromR8( ps->u.dblVal, &(pd->u.uiVal) ); + res = VarUI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,uiVal) ); break; case( VT_DATE ): - res = VarUI2FromDate( ps->u.date, &(pd->u.uiVal) ); + res = VarUI2FromDate( V_UNION(ps,date), &V_UNION(pd,uiVal) ); break; case( VT_BOOL ): - res = VarUI2FromBool( ps->u.boolVal, &(pd->u.uiVal) ); + res = VarUI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,uiVal) ); break; case( VT_BSTR ): - res = VarUI2FromStr( ps->u.bstrVal, lcid, 0, &(pd->u.uiVal) ); + res = VarUI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,uiVal) ); break; case( VT_CY ): - res = VarUI2FromCy( ps->u.cyVal, &(pd->u.uiVal) ); + res = VarUI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,uiVal) ); break; case( VT_DISPATCH ): - /*res = VarUI2FromDisp( ps->u.pdispVal, lcid, &(pd->u.uiVal) );*/ + /*res = VarUI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,uiVal) );*/ case( VT_DECIMAL ): - /*res = VarUI2FromDec( ps->u.deiVal, &(pd->u.uiVal) );*/ + /*res = VarUI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,uiVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; @@ -1180,46 +1180,46 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, switch( vtFrom ) { case( VT_I1 ): - res = VarUI4FromI1( ps->u.cVal, &(pd->u.ulVal) ); + res = VarUI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,ulVal) ); break; case( VT_I2 ): - res = VarUI4FromI2( ps->u.iVal, &(pd->u.ulVal) ); + res = VarUI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,ulVal) ); break; case( VT_INT ): case( VT_I4 ): - res = VarUI4FromI4( ps->u.lVal, &(pd->u.ulVal) ); + res = VarUI4FromI4( V_UNION(ps,lVal), &V_UNION(pd,ulVal) ); break; case( VT_UI1 ): - res = VarUI4FromUI1( ps->u.bVal, &(pd->u.ulVal) ); + res = VarUI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,ulVal) ); break; case( VT_UI2 ): - res = VarUI4FromUI2( ps->u.uiVal, &(pd->u.ulVal) ); + res = VarUI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,ulVal) ); break; case( VT_UI4 ): res = VariantCopy( pd, ps ); break; case( VT_R4 ): - res = VarUI4FromR4( ps->u.fltVal, &(pd->u.ulVal) ); + res = VarUI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,ulVal) ); break; case( VT_R8 ): - res = VarUI4FromR8( ps->u.dblVal, &(pd->u.ulVal) ); + res = VarUI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,ulVal) ); break; case( VT_DATE ): - res = VarUI4FromDate( ps->u.date, &(pd->u.ulVal) ); + res = VarUI4FromDate( V_UNION(ps,date), &V_UNION(pd,ulVal) ); break; case( VT_BOOL ): - res = VarUI4FromBool( ps->u.boolVal, &(pd->u.ulVal) ); + res = VarUI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,ulVal) ); break; case( VT_BSTR ): - res = VarUI4FromStr( ps->u.bstrVal, lcid, 0, &(pd->u.ulVal) ); + res = VarUI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,ulVal) ); break; case( VT_CY ): - res = VarUI4FromCy( ps->u.cyVal, &(pd->u.ulVal) ); + res = VarUI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,ulVal) ); break; case( VT_DISPATCH ): - /*res = VarUI4FromDisp( ps->u.pdispVal, lcid, &(pd->u.ulVal) );*/ + /*res = VarUI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,ulVal) );*/ case( VT_DECIMAL ): - /*res = VarUI4FromDec( ps->u.deiVal, &(pd->u.ulVal) );*/ + /*res = VarUI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,ulVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; @@ -1232,47 +1232,47 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, switch( vtFrom ) { case( VT_I1 ): - res = VarR4FromI1( ps->u.cVal, &(pd->u.fltVal) ); + res = VarR4FromI1( V_UNION(ps,cVal), &V_UNION(pd,fltVal) ); break; case( VT_I2 ): - res = VarR4FromI2( ps->u.iVal, &(pd->u.fltVal) ); + res = VarR4FromI2( V_UNION(ps,iVal), &V_UNION(pd,fltVal) ); break; case( VT_INT ): case( VT_I4 ): - res = VarR4FromI4( ps->u.lVal, &(pd->u.fltVal) ); + res = VarR4FromI4( V_UNION(ps,lVal), &V_UNION(pd,fltVal) ); break; case( VT_UI1 ): - res = VarR4FromUI1( ps->u.bVal, &(pd->u.fltVal) ); + res = VarR4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,fltVal) ); break; case( VT_UI2 ): - res = VarR4FromUI2( ps->u.uiVal, &(pd->u.fltVal) ); + res = VarR4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,fltVal) ); break; case( VT_UINT ): case( VT_UI4 ): - res = VarR4FromUI4( ps->u.ulVal, &(pd->u.fltVal) ); + res = VarR4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,fltVal) ); break; case( VT_R4 ): res = VariantCopy( pd, ps ); break; case( VT_R8 ): - res = VarR4FromR8( ps->u.dblVal, &(pd->u.fltVal) ); + res = VarR4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,fltVal) ); break; case( VT_DATE ): - res = VarR4FromDate( ps->u.date, &(pd->u.fltVal) ); + res = VarR4FromDate( V_UNION(ps,date), &V_UNION(pd,fltVal) ); break; case( VT_BOOL ): - res = VarR4FromBool( ps->u.boolVal, &(pd->u.fltVal) ); + res = VarR4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,fltVal) ); break; case( VT_BSTR ): - res = VarR4FromStr( ps->u.bstrVal, lcid, 0, &(pd->u.fltVal) ); + res = VarR4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,fltVal) ); break; case( VT_CY ): - res = VarR4FromCy( ps->u.cyVal, &(pd->u.fltVal) ); + res = VarR4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,fltVal) ); break; case( VT_DISPATCH ): - /*res = VarR4FromDisp( ps->u.pdispVal, lcid, &(pd->u.fltVal) );*/ + /*res = VarR4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,fltVal) );*/ case( VT_DECIMAL ): - /*res = VarR4FromDec( ps->u.deiVal, &(pd->u.fltVal) );*/ + /*res = VarR4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,fltVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; @@ -1285,47 +1285,47 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, switch( vtFrom ) { case( VT_I1 ): - res = VarR8FromI1( ps->u.cVal, &(pd->u.dblVal) ); + res = VarR8FromI1( V_UNION(ps,cVal), &V_UNION(pd,dblVal) ); break; case( VT_I2 ): - res = VarR8FromI2( ps->u.iVal, &(pd->u.dblVal) ); + res = VarR8FromI2( V_UNION(ps,iVal), &V_UNION(pd,dblVal) ); break; case( VT_INT ): case( VT_I4 ): - res = VarR8FromI4( ps->u.lVal, &(pd->u.dblVal) ); + res = VarR8FromI4( V_UNION(ps,lVal), &V_UNION(pd,dblVal) ); break; case( VT_UI1 ): - res = VarR8FromUI1( ps->u.bVal, &(pd->u.dblVal) ); + res = VarR8FromUI1( V_UNION(ps,bVal), &V_UNION(pd,dblVal) ); break; case( VT_UI2 ): - res = VarR8FromUI2( ps->u.uiVal, &(pd->u.dblVal) ); + res = VarR8FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,dblVal) ); break; case( VT_UINT ): case( VT_UI4 ): - res = VarR8FromUI4( ps->u.ulVal, &(pd->u.dblVal) ); + res = VarR8FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,dblVal) ); break; case( VT_R4 ): - res = VarR8FromR4( ps->u.fltVal, &(pd->u.dblVal) ); + res = VarR8FromR4( V_UNION(ps,fltVal), &V_UNION(pd,dblVal) ); break; case( VT_R8 ): res = VariantCopy( pd, ps ); break; case( VT_DATE ): - res = VarR8FromDate( ps->u.date, &(pd->u.dblVal) ); + res = VarR8FromDate( V_UNION(ps,date), &V_UNION(pd,dblVal) ); break; case( VT_BOOL ): - res = VarR8FromBool( ps->u.boolVal, &(pd->u.dblVal) ); + res = VarR8FromBool( V_UNION(ps,boolVal), &V_UNION(pd,dblVal) ); break; case( VT_BSTR ): - res = VarR8FromStr( ps->u.bstrVal, lcid, 0, &(pd->u.dblVal) ); + res = VarR8FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,dblVal) ); break; case( VT_CY ): - res = VarR8FromCy( ps->u.cyVal, &(pd->u.dblVal) ); + res = VarR8FromCy( V_UNION(ps,cyVal), &V_UNION(pd,dblVal) ); break; case( VT_DISPATCH ): - /*res = VarR8FromDisp( ps->u.pdispVal, lcid, &(pd->u.dblVal) );*/ + /*res = VarR8FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,dblVal) );*/ case( VT_DECIMAL ): - /*res = VarR8FromDec( ps->u.deiVal, &(pd->u.dblVal) );*/ + /*res = VarR8FromDec( V_UNION(ps,deiVal), &V_UNION(pd,dblVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; @@ -1338,51 +1338,51 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, switch( vtFrom ) { case( VT_I1 ): - res = VarDateFromI1( ps->u.cVal, &(pd->u.date) ); + res = VarDateFromI1( V_UNION(ps,cVal), &V_UNION(pd,date) ); break; case( VT_I2 ): - res = VarDateFromI2( ps->u.iVal, &(pd->u.date) ); + res = VarDateFromI2( V_UNION(ps,iVal), &V_UNION(pd,date) ); break; case( VT_INT ): - res = VarDateFromInt( ps->u.intVal, &(pd->u.date) ); + res = VarDateFromInt( V_UNION(ps,intVal), &V_UNION(pd,date) ); break; case( VT_I4 ): - res = VarDateFromI4( ps->u.lVal, &(pd->u.date) ); + res = VarDateFromI4( V_UNION(ps,lVal), &V_UNION(pd,date) ); break; case( VT_UI1 ): - res = VarDateFromUI1( ps->u.bVal, &(pd->u.date) ); + res = VarDateFromUI1( V_UNION(ps,bVal), &V_UNION(pd,date) ); break; case( VT_UI2 ): - res = VarDateFromUI2( ps->u.uiVal, &(pd->u.date) ); + res = VarDateFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,date) ); break; case( VT_UINT ): - res = VarDateFromUint( ps->u.uintVal, &(pd->u.date) ); + res = VarDateFromUint( V_UNION(ps,uintVal), &V_UNION(pd,date) ); break; case( VT_UI4 ): - res = VarDateFromUI4( ps->u.ulVal, &(pd->u.date) ); + res = VarDateFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,date) ); break; case( VT_R4 ): - res = VarDateFromR4( ps->u.fltVal, &(pd->u.date) ); + res = VarDateFromR4( V_UNION(ps,fltVal), &V_UNION(pd,date) ); break; case( VT_R8 ): - res = VarDateFromR8( ps->u.dblVal, &(pd->u.date) ); + res = VarDateFromR8( V_UNION(ps,dblVal), &V_UNION(pd,date) ); break; case( VT_DATE ): res = VariantCopy( pd, ps ); break; case( VT_BOOL ): - res = VarDateFromBool( ps->u.boolVal, &(pd->u.date) ); + res = VarDateFromBool( V_UNION(ps,boolVal), &V_UNION(pd,date) ); break; case( VT_BSTR ): - res = VarDateFromStr( ps->u.bstrVal, lcid, 0, &(pd->u.date) ); + res = VarDateFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,date) ); break; case( VT_CY ): - res = VarDateFromCy( ps->u.cyVal, &(pd->u.date) ); + res = VarDateFromCy( V_UNION(ps,cyVal), &V_UNION(pd,date) ); break; case( VT_DISPATCH ): - /*res = VarDateFromDisp( ps->u.pdispVal, lcid, &(pd->u.date) );*/ + /*res = VarDateFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,date) );*/ case( VT_DECIMAL ): - /*res = VarDateFromDec( ps->u.deiVal, &(pd->u.date) );*/ + /*res = VarDateFromDec( V_UNION(ps,deiVal), &V_UNION(pd,date) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; @@ -1395,51 +1395,51 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, switch( vtFrom ) { case( VT_I1 ): - res = VarBoolFromI1( ps->u.cVal, &(pd->u.boolVal) ); + res = VarBoolFromI1( V_UNION(ps,cVal), &V_UNION(pd,boolVal) ); break; case( VT_I2 ): - res = VarBoolFromI2( ps->u.iVal, &(pd->u.boolVal) ); + res = VarBoolFromI2( V_UNION(ps,iVal), &V_UNION(pd,boolVal) ); break; case( VT_INT ): - res = VarBoolFromInt( ps->u.intVal, &(pd->u.boolVal) ); + res = VarBoolFromInt( V_UNION(ps,intVal), &V_UNION(pd,boolVal) ); break; case( VT_I4 ): - res = VarBoolFromI4( ps->u.lVal, &(pd->u.boolVal) ); + res = VarBoolFromI4( V_UNION(ps,lVal), &V_UNION(pd,boolVal) ); break; case( VT_UI1 ): - res = VarBoolFromUI1( ps->u.bVal, &(pd->u.boolVal) ); + res = VarBoolFromUI1( V_UNION(ps,bVal), &V_UNION(pd,boolVal) ); break; case( VT_UI2 ): - res = VarBoolFromUI2( ps->u.uiVal, &(pd->u.boolVal) ); + res = VarBoolFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,boolVal) ); break; case( VT_UINT ): - res = VarBoolFromUint( ps->u.uintVal, &(pd->u.boolVal) ); + res = VarBoolFromUint( V_UNION(ps,uintVal), &V_UNION(pd,boolVal) ); break; case( VT_UI4 ): - res = VarBoolFromUI4( ps->u.ulVal, &(pd->u.boolVal) ); + res = VarBoolFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,boolVal) ); break; case( VT_R4 ): - res = VarBoolFromR4( ps->u.fltVal, &(pd->u.boolVal) ); + res = VarBoolFromR4( V_UNION(ps,fltVal), &V_UNION(pd,boolVal) ); break; case( VT_R8 ): - res = VarBoolFromR8( ps->u.dblVal, &(pd->u.boolVal) ); + res = VarBoolFromR8( V_UNION(ps,dblVal), &V_UNION(pd,boolVal) ); break; case( VT_DATE ): - res = VarBoolFromDate( ps->u.date, &(pd->u.boolVal) ); + res = VarBoolFromDate( V_UNION(ps,date), &V_UNION(pd,boolVal) ); break; case( VT_BOOL ): res = VariantCopy( pd, ps ); break; case( VT_BSTR ): - res = VarBoolFromStr( ps->u.bstrVal, lcid, 0, &(pd->u.boolVal) ); + res = VarBoolFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,boolVal) ); break; case( VT_CY ): - res = VarBoolFromCy( ps->u.cyVal, &(pd->u.boolVal) ); + res = VarBoolFromCy( V_UNION(ps,cyVal), &V_UNION(pd,boolVal) ); break; case( VT_DISPATCH ): - /*res = VarBoolFromDisp( ps->u.pdispVal, lcid, &(pd->u.boolVal) );*/ + /*res = VarBoolFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,boolVal) );*/ case( VT_DECIMAL ): - /*res = VarBoolFromDec( ps->u.deiVal, &(pd->u.boolVal) );*/ + /*res = VarBoolFromDec( V_UNION(ps,deiVal), &V_UNION(pd,boolVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; @@ -1452,57 +1452,57 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, switch( vtFrom ) { case( VT_EMPTY ): - if ((pd->u.bstrVal = SysAllocStringLen(NULL, 0))) + if ((V_UNION(pd,bstrVal) = SysAllocStringLen(NULL, 0))) res = S_OK; else res = E_OUTOFMEMORY; break; case( VT_I1 ): - res = VarBstrFromI1( ps->u.cVal, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromI1( V_UNION(ps,cVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_I2 ): - res = VarBstrFromI2( ps->u.iVal, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromI2( V_UNION(ps,iVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_INT ): - res = VarBstrFromInt( ps->u.intVal, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromInt( V_UNION(ps,intVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_I4 ): - res = VarBstrFromI4( ps->u.lVal, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromI4( V_UNION(ps,lVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_UI1 ): - res = VarBstrFromUI1( ps->u.bVal, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromUI1( V_UNION(ps,bVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_UI2 ): - res = VarBstrFromUI2( ps->u.uiVal, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromUI2( V_UNION(ps,uiVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_UINT ): - res = VarBstrFromUint( ps->u.uintVal, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromUint( V_UNION(ps,uintVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_UI4 ): - res = VarBstrFromUI4( ps->u.ulVal, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromUI4( V_UNION(ps,ulVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_R4 ): - res = VarBstrFromR4( ps->u.fltVal, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromR4( V_UNION(ps,fltVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_R8 ): - res = VarBstrFromR8( ps->u.dblVal, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromR8( V_UNION(ps,dblVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_DATE ): - res = VarBstrFromDate( ps->u.date, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromDate( V_UNION(ps,date), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_BOOL ): - res = VarBstrFromBool( ps->u.boolVal, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromBool( V_UNION(ps,boolVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_BSTR ): res = VariantCopy( pd, ps ); break; case( VT_CY ): - res = VarBstrFromCy( ps->u.cyVal, lcid, 0, &(pd->u.bstrVal) ); + res = VarBstrFromCy( V_UNION(ps,cyVal), lcid, 0, &V_UNION(pd,bstrVal) ); break; case( VT_DISPATCH ): - /*res = VarBstrFromDisp( ps->u.pdispVal, lcid, 0, &(pd->u.bstrVal) );*/ + /*res = VarBstrFromDisp( V_UNION(ps,pdispVal), lcid, 0, &(pd,bstrVal) );*/ case( VT_DECIMAL ): - /*res = VarBstrFromDec( ps->u.deiVal, lcid, 0, &(pd->u.bstrVal) );*/ + /*res = VarBstrFromDec( V_UNION(ps,deiVal), lcid, 0, &(pd,bstrVal) );*/ case( VT_UNKNOWN ): default: res = DISP_E_TYPEMISMATCH; @@ -1515,51 +1515,51 @@ static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, switch( vtFrom ) { case( VT_I1 ): - res = VarCyFromI1( ps->u.cVal, &(pd->u.cyVal) ); + res = VarCyFromI1( V_UNION(ps,cVal), &V_UNION(pd,cyVal) ); break; case( VT_I2 ): - res = VarCyFromI2( ps->u.iVal, &(pd->u.cyVal) ); + res = VarCyFromI2( V_UNION(ps,iVal), &V_UNION(pd,cyVal) ); break; case( VT_INT ): - res = VarCyFromInt( ps->u.intVal, &(pd->u.cyVal) ); + res = VarCyFromInt( V_UNION(ps,intVal), &V_UNION(pd,cyVal) ); break; case( VT_I4 ): - res = VarCyFromI4( ps->u.lVal, &(pd->u.cyVal) ); + res = VarCyFromI4( V_UNION(ps,lVal), &V_UNION(pd,cyVal) ); break; case( VT_UI1 ): - res = VarCyFromUI1( ps->u.bVal, &(pd->u.cyVal) ); + res = VarCyFromUI1( V_UNION(ps,bVal), &V_UNION(pd,cyVal) ); break; case( VT_UI2 ): - res = VarCyFromUI2( ps->u.uiVal, &(pd->u.cyVal) ); + res = VarCyFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cyVal) ); break; case( VT_UINT ): - res = VarCyFromUint( ps->u.uintVal, &(pd->u.cyVal) ); + res = VarCyFromUint( V_UNION(ps,uintVal), &V_UNION(pd,cyVal) ); break; case( VT_UI4 ): - res = VarCyFromUI4( ps->u.ulVal, &(pd->u.cyVal) ); + res = VarCyFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cyVal) ); break; case( VT_R4 ): - res = VarCyFromR4( ps->u.fltVal, &(pd->u.cyVal) ); + res = VarCyFromR4( V_UNION(ps,fltVal), &V_UNION(pd,cyVal) ); break; case( VT_R8 ): - res = VarCyFromR8( ps->u.dblVal, &(pd->u.cyVal) ); + res = VarCyFromR8( V_UNION(ps,dblVal), &V_UNION(pd,cyVal) ); break; case( VT_DATE ): - res = VarCyFromDate( ps->u.date, &(pd->u.cyVal) ); + res = VarCyFromDate( V_UNION(ps,date), &V_UNION(pd,cyVal) ); break; case( VT_BOOL ): - res = VarCyFromBool( ps->u.date, &(pd->u.cyVal) ); + res = VarCyFromBool( V_UNION(ps,date), &V_UNION(pd,cyVal) ); break; case( VT_CY ): res = VariantCopy( pd, ps ); break; case( VT_BSTR ): - res = VarCyFromStr( ps->u.bstrVal, lcid, 0, &(pd->u.cyVal) ); + res = VarCyFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cyVal) ); break; case( VT_DISPATCH ): - /*res = VarCyFromDisp( ps->u.pdispVal, lcid, &(pd->u.cyVal) );*/ + /*res = VarCyFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cyVal) );*/ case( VT_DECIMAL ): - /*res = VarCyFromDec( ps->u.deiVal, &(pd->u.cyVal) );*/ + /*res = VarCyFromDec( V_UNION(ps,deiVal), &V_UNION(pd,cyVal) );*/ break; case( VT_UNKNOWN ): default: @@ -1678,7 +1678,7 @@ void WINAPI VariantInit(VARIANTARG* pvarg) TRACE("(%p),stub\n",pvarg); memset(pvarg, 0, sizeof (VARIANTARG)); - pvarg->vt = VT_EMPTY; + V_VT(pvarg) = VT_EMPTY; return; } @@ -1696,38 +1696,38 @@ HRESULT WINAPI VariantClear(VARIANTARG* pvarg) HRESULT res = S_OK; TRACE("(%p)\n",pvarg); - res = ValidateVariantType( pvarg->vt ); + res = ValidateVariantType( V_VT(pvarg) ); if( res == S_OK ) { - if( !( pvarg->vt & VT_BYREF ) ) + if( !( V_VT(pvarg) & VT_BYREF ) ) { /* * The VT_ARRAY flag is a special case of a safe array. */ - if ( (pvarg->vt & VT_ARRAY) != 0) + if ( (V_VT(pvarg) & VT_ARRAY) != 0) { - SafeArrayDestroy(pvarg->u.parray); + SafeArrayDestroy(V_UNION(pvarg,parray)); } else { - switch( pvarg->vt & VT_TYPEMASK ) + switch( V_VT(pvarg) & VT_TYPEMASK ) { case( VT_BSTR ): - SysFreeString( pvarg->u.bstrVal ); + SysFreeString( V_UNION(pvarg,bstrVal) ); break; case( VT_DISPATCH ): - if(pvarg->u.pdispVal!=NULL) - ICOM_CALL(Release,pvarg->u.pdispVal); + if(V_UNION(pvarg,pdispVal)!=NULL) + ICOM_CALL(Release,V_UNION(pvarg,pdispVal)); break; case( VT_VARIANT ): - VariantClear(pvarg->u.pvarVal); + VariantClear(V_UNION(pvarg,pvarVal)); break; case( VT_UNKNOWN ): - if(pvarg->u.punkVal!=NULL) - ICOM_CALL(Release,pvarg->u.punkVal); + if(V_UNION(pvarg,punkVal)!=NULL) + ICOM_CALL(Release,V_UNION(pvarg,punkVal)); break; case( VT_SAFEARRAY ): - SafeArrayDestroy(pvarg->u.parray); + SafeArrayDestroy(V_UNION(pvarg,parray)); break; default: break; @@ -1739,7 +1739,7 @@ HRESULT WINAPI VariantClear(VARIANTARG* pvarg) * Empty all the fields and mark the type as empty. */ memset(pvarg, 0, sizeof (VARIANTARG)); - pvarg->vt = VT_EMPTY; + V_VT(pvarg) = VT_EMPTY; } return res; @@ -1756,7 +1756,7 @@ HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, VARIANTARG* pvargSrc) TRACE("(%p, %p)\n", pvargDest, pvargSrc); - res = ValidateVariantType( pvargSrc->vt ); + res = ValidateVariantType( V_VT(pvargSrc) ); /* If the pointer are to the same variant we don't need * to do anything. @@ -1767,22 +1767,22 @@ HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, VARIANTARG* pvargSrc) if( res == S_OK ) { - if( pvargSrc->vt & VT_BYREF ) + if( V_VT(pvargSrc) & VT_BYREF ) { /* In the case of byreference we only need * to copy the pointer. */ - pvargDest->u = pvargSrc->u; - pvargDest->vt = pvargSrc->vt; + pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3; + V_VT(pvargDest) = V_VT(pvargSrc); } else { /* * The VT_ARRAY flag is another way to designate a safe array. */ - if (pvargSrc->vt & VT_ARRAY) + if (V_VT(pvargSrc) & VT_ARRAY) { - SafeArrayCopy(pvargSrc->u.parray, &pvargDest->u.parray); + SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray)); } else { @@ -1792,34 +1792,34 @@ HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, VARIANTARG* pvargSrc) * if VT_DISPATCH or VT_IUNKNOWN AddReff is * called to increment the object's reference count. */ - switch( pvargSrc->vt & VT_TYPEMASK ) + switch( V_VT(pvargSrc) & VT_TYPEMASK ) { case( VT_BSTR ): - pvargDest->u.bstrVal = SysAllocString( pvargSrc->u.bstrVal ); + V_UNION(pvargDest,bstrVal) = SysAllocString( V_UNION(pvargSrc,bstrVal) ); break; case( VT_DISPATCH ): - pvargDest->u.pdispVal = pvargSrc->u.pdispVal; - if (pvargDest->u.pdispVal!=NULL) - ICOM_CALL(AddRef,pvargDest->u.pdispVal); + V_UNION(pvargDest,pdispVal) = V_UNION(pvargSrc,pdispVal); + if (V_UNION(pvargDest,pdispVal)!=NULL) + ICOM_CALL(AddRef,V_UNION(pvargDest,pdispVal)); break; case( VT_VARIANT ): - VariantCopy(pvargDest->u.pvarVal,pvargSrc->u.pvarVal); + VariantCopy(V_UNION(pvargDest,pvarVal),V_UNION(pvargSrc,pvarVal)); break; case( VT_UNKNOWN ): - pvargDest->u.punkVal = pvargSrc->u.punkVal; - if (pvargDest->u.pdispVal!=NULL) - ICOM_CALL(AddRef,pvargDest->u.punkVal); + V_UNION(pvargDest,punkVal) = V_UNION(pvargSrc,punkVal); + if (V_UNION(pvargDest,pdispVal)!=NULL) + ICOM_CALL(AddRef,V_UNION(pvargDest,punkVal)); break; case( VT_SAFEARRAY ): - SafeArrayCopy(pvargSrc->u.parray, &pvargDest->u.parray); + SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray)); break; default: - pvargDest->u = pvargSrc->u; + pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3; break; } } - pvargDest->vt = pvargSrc->vt; + V_VT(pvargDest) = V_VT(pvargSrc); } } } @@ -1840,12 +1840,12 @@ HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc) TRACE("(%p, %p)\n", pvargDest, pvargSrc); - res = ValidateVariantType( pvargSrc->vt ); + res = ValidateVariantType( V_VT(pvargSrc) ); if( res != S_OK ) return res; - if( pvargSrc->vt & VT_BYREF ) + if( V_VT(pvargSrc) & VT_BYREF ) { VARIANTARG varg; VariantInit( &varg ); @@ -1869,9 +1869,9 @@ HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc) /* * The VT_ARRAY flag is another way to designate a safearray variant. */ - if ( pvargSrc->vt & VT_ARRAY) + if ( V_VT(pvargSrc) & VT_ARRAY) { - SafeArrayCopy(*pvargSrc->u.pparray, &pvargDest->u.parray); + SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray)); } else { @@ -1881,10 +1881,10 @@ HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc) /* Get the variant type. */ - switch( pvargSrc->vt & VT_TYPEMASK ) + switch( V_VT(pvargSrc) & VT_TYPEMASK ) { case( VT_BSTR ): - pvargDest->u.bstrVal = SysAllocString( *(pvargSrc->u.pbstrVal) ); + V_UNION(pvargDest,bstrVal) = SysAllocString( *(V_UNION(pvargSrc,pbstrVal)) ); break; case( VT_DISPATCH ): break; @@ -1897,7 +1897,7 @@ HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc) * other inner variant the E_INVALIDARG error is * returned. */ - if( pvargSrc->wReserved1 & PROCESSING_INNER_VARIANT ) + if( pvargSrc->n1.n2.wReserved1 & PROCESSING_INNER_VARIANT ) { /* If we get here we are attempting to deference * an inner variant that that is itself contained @@ -1911,37 +1911,37 @@ HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc) * We will set this flag in the inner variant * that will be passed to the VariantCopyInd function. */ - (pvargSrc->u.pvarVal)->wReserved1 |= PROCESSING_INNER_VARIANT; + (V_UNION(pvargSrc,pvarVal))->n1.n2.wReserved1 |= PROCESSING_INNER_VARIANT; /* Dereference the inner variant. */ - res = VariantCopyInd( pvargDest, pvargSrc->u.pvarVal ); + res = VariantCopyInd( pvargDest, V_UNION(pvargSrc,pvarVal) ); /* We must also copy its type, I think. */ - pvargSrc->vt = pvargSrc->u.pvarVal->vt; + V_VT(pvargSrc) = V_VT(V_UNION(pvargSrc,pvarVal)); } } break; case( VT_UNKNOWN ): break; case( VT_SAFEARRAY ): - SafeArrayCopy(*pvargSrc->u.pparray, &pvargDest->u.parray); + SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray)); break; default: /* This is a by reference Variant which means that the union * part of the Variant contains a pointer to some data of - * type "pvargSrc->vt & VT_TYPEMASK". + * type "V_VT(pvargSrc) & VT_TYPEMASK". * We will deference this data in a generic fashion using * the void pointer "Variant.u.byref". * We will copy this data into the union of the destination * Variant. */ - memcpy( &pvargDest->u, pvargSrc->u.byref, SizeOfVariantData( pvargSrc ) ); + memcpy( &pvargDest->n1.n2, V_UNION(pvargSrc,byref), SizeOfVariantData( pvargSrc ) ); break; } } - pvargDest->vt = pvargSrc->vt & VT_TYPEMASK; + V_VT(pvargDest) = V_VT(pvargSrc) & VT_TYPEMASK; } } @@ -1980,7 +1980,7 @@ HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc, /* validate our source argument. */ - res = ValidateVariantType( pvargSrc->vt ); + res = ValidateVariantType( V_VT(pvargSrc) ); /* validate the vartype. */ @@ -2006,7 +2006,7 @@ HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc, if( res == S_OK ) { - if( pvargSrc->vt & VT_BYREF ) + if( V_VT(pvargSrc) & VT_BYREF ) { /* Convert the source variant to a "byvalue" variant. */ @@ -2036,7 +2036,7 @@ HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc, /* set the type of the destination */ if ( res == S_OK ) - pvargDest->vt = vt; + V_VT(pvargDest) = vt; return res; } @@ -4388,13 +4388,13 @@ HRESULT WINAPI VarNumFromParseNum(NUMPARSE * pnumprs, BYTE * rgbDig, VariantInit(pvar); if (dwVtBits & VTBIT_I4) { - pvar->vt = VT_I4; - pvar->u.intVal = xint; + V_VT(pvar) = VT_I4; + V_UNION(pvar,intVal) = xint; return S_OK; } if (dwVtBits & VTBIT_R8) { - pvar->vt = VT_R8; - pvar->u.dblVal = xint; + V_VT(pvar) = VT_R8; + V_UNION(pvar,dblVal) = xint; return S_OK; } else { FIXME("vtbitmask is unsupported %lx\n",dwVtBits); diff --git a/include/oleauto.h b/include/oleauto.h index 105df84bfe6..5fa9e9b39ef 100644 --- a/include/oleauto.h +++ b/include/oleauto.h @@ -111,11 +111,11 @@ SafeArrayRedim(struct tagSAFEARRAY *psa, struct tagSAFEARRAYBOUND *psaboundNew); /* These are macros that help accessing the VARIANT date type. */ -#ifdef __cplusplus -#define V_UNION(A, B) ((A)->B) -#define V_VT(A) ((A)->vt) +#if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION) +#define V_UNION(A, B) ((A)->n1.n2.n3.B) +#define V_VT(A) ((A)->n1.n2.vt) #else -#define V_UNION(A, B) ((A)->u.B) +#define V_UNION(A, B) ((A)->B) #define V_VT(A) ((A)->vt) #endif /* cplusplus */ diff --git a/include/wine/obj_oleaut.h b/include/wine/obj_oleaut.h index 04c5c0cd205..83677b91ed7 100644 --- a/include/wine/obj_oleaut.h +++ b/include/wine/obj_oleaut.h @@ -114,67 +114,81 @@ typedef CY CURRENCY; * * E_OUTOFMEMORY : Memory could not be allocated for the conversion. * DISP_E_ARRAYISLOCKED : The variant contains an array that is locked. */ +#if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION) +#define __VARIANT_NAME_1 n1 +#define __VARIANT_NAME_2 n2 +#define __VARIANT_NAME_3 n3 +#else +#define __tagVARIANT +#define __VARIANT_NAME_1 +#define __VARIANT_NAME_2 +#define __VARIANT_NAME_3 +#endif typedef struct tagVARIANT VARIANT, *LPVARIANT; typedef struct tagVARIANT VARIANTARG, *LPVARIANTARG; -struct tagVARIANT { - VARTYPE vt; - WORD wReserved1; - WORD wReserved2; - WORD wReserved3; - union /* DUMMYUNIONNAME */ - { - /* By value. */ - CHAR cVal; - USHORT uiVal; - ULONG ulVal; - INT intVal; - UINT uintVal; - BYTE bVal; - short iVal; - long lVal; - float fltVal; - double dblVal; - VARIANT_BOOL boolVal; - SCODE scode; - DATE date; - BSTR bstrVal; - CY cyVal; - /* FIXME: This is not supposed to be at this level - * See bug #181 in bugzilla - * DECIMAL decVal; - */ - IUnknown* punkVal; - IDispatch* pdispVal; - SAFEARRAY* parray; +struct tagVARIANT +{ + union + { + struct __tagVARIANT + { + VARTYPE vt; + WORD wReserved1; + WORD wReserved2; + WORD wReserved3; + union /* DUMMYUNIONNAME */ + { + /* B y value. */ + CHAR cVal; + USHORT uiVal; + ULONG ulVal; + INT intVal; + UINT uintVal; + BYTE bVal; + short iVal; + long lVal; + float fltVal; + double dblVal; + VARIANT_BOOL boolVal; + SCODE scode; + DATE date; + BSTR bstrVal; + CY cyVal; + IUnknown* punkVal; + IDispatch* pdispVal; + SAFEARRAY* parray; - /* By reference */ - CHAR* pcVal; - USHORT* puiVal; - ULONG* pulVal; - INT* pintVal; - UINT* puintVal; - BYTE* pbVal; - short* piVal; - long* plVal; - float* pfltVal; - double* pdblVal; - VARIANT_BOOL* pboolVal; - SCODE* pscode; - DATE* pdate; - BSTR* pbstrVal; - VARIANT* pvarVal; - PVOID byref; - CY* pcyVal; - DECIMAL* pdecVal; - IUnknown** ppunkVal; - IDispatch** ppdispVal; - SAFEARRAY** pparray; - } DUMMYUNIONNAME; + /* By reference */ + CHAR* pcVal; + USHORT* puiVal; + ULONG* pulVal; + INT* pintVal; + UINT* puintVal; + BYTE* pbVal; + short* piVal; + long* plVal; + float* pfltVal; + double* pdblVal; + VARIANT_BOOL* pboolVal; + SCODE* pscode; + DATE* pdate; + BSTR* pbstrVal; + VARIANT* pvarVal; + PVOID byref; + CY* pcyVal; + DECIMAL* pdecVal; + IUnknown** ppunkVal; + IDispatch** ppdispVal; + SAFEARRAY** pparray; + } __VARIANT_NAME_3; + } __VARIANT_NAME_2; + DECIMAL decVal; + } __VARIANT_NAME_1; }; - + typedef LONG DISPID; typedef DWORD HREFTYPE; typedef DISPID MEMBERID;