Changeset 6575 for trunk/src


Ignore:
Timestamp:
Aug 23, 2001, 8:11:21 PM (24 years ago)
Author:
sandervl
Message:

Wine updates

Location:
trunk/src/oleaut32
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/oleaut32/oleaut32.def

    r5856 r6575  
    1 ;/* $Id: oleaut32.def,v 1.6 2001-06-01 07:50:02 sandervl Exp $ */
     1;/* $Id: oleaut32.def,v 1.7 2001-08-23 18:11:20 sandervl Exp $ */
    22LIBRARY OLAUTOS2 INITINSTANCE
    33DESCRIPTION 'Odin32 System DLL - OleAut32'
    … …  
    295295OleLoadPicturePath = _OleLoadPicturePath@24  @424
    296296OleLoadPictureEx   = _OleLoadPictureEx@32    @425
     297
     298;Win98 and higher (NT4.0sp4)
     299;426 stub GetRecordInfoFromGuids ; stdcall (ptr long long long ptr ptr)
     300;427 stub GetRecordInfoFromTypeInfo ; stdcall (ptr ptr)
     301;428 stub OleLoadPictureFileEx
     302;429 stub SafeArrayAllocDescriptorEx
     303;430 stub SafeArrayCreateEx
     304;431 stub SafeArrayCreateVectorEx
     305;432 stub SafeArrayGetIID
     306;433 stub SafeArrayGetRecordInfo
     307;434 stub SafeArraySetIID
     308;435 stub SafeArraySetRecordInfo
     309;436 stub VarAbs ; stdcall (ptr ptr)
     310;437 stub VarAdd ; stdcall (ptr ptr ptr)
     311;438 stub VarAnd ; stdcall (ptr ptr ptr)
     312VarBstrCat          = _VarBstrCat@12                    @439
     313VarBstrCmp          = _VarBstrCmp@16                    @440
     314;441 stub VarCat ; stdcall (ptr ptr ptr)
     315;442 stub VarCmp ; stdcall (ptr ptr long long)
     316;443 stub VarCyAbs
     317;444 stub VarCyAdd
     318;445 stub VarCyCmp
     319;446 stub VarCyCmpR8
     320;447 stub VarCyFix
     321;448 stub VarCyInt
     322;449 stub VarCyMul
     323;450 stub VarCyMulI4
     324;451 stub VarCyNeg
     325;452 stub VarCyRound
     326;453 stub VarCySub
     327;454 stub VarDateFromUdateEx ; stdcall (ptr long long ptr)
     328;455 stub VarDecAbs ; stdcall (ptr ptr)
     329;456 stub VarDecAdd ; stdcall (ptr ptr ptr)
     330;457 stub VarDecCmp ; stdcall (ptr ptr)
     331;458 stub VarDecCmpR8 ; stdcall (ptr double)
     332;459 stub VarDecDiv ; stdcall (ptr ptr ptr)
     333;460 stub VarDecFix ; stdcall (ptr ptr)
     334;461 stub VarDecInt ; stdcall (ptr ptr)
     335;462 stub VarDecMul ; stdcall (ptr ptr ptr)
     336;463 stub VarDecNeg ; stdcall (ptr ptr)
     337;464 stub VarDecRound ; stdcall (ptr long ptr)
     338;465 stub VarDecSub ; stdcall (ptr ptr ptr)
     339;466 stub VarDiv ; stdcall (ptr ptr ptr)
     340;467 stub VarEqv ; stdcall (ptr ptr ptr)
     341;468 stub VarFix ; stdcall (ptr ptr)
     342;469 stub VarFormat ; stdcall (ptr ptr long long long ptr)
     343;470 stub VarFormatCurrency ; stdcall (ptr long long long long long ptr)
     344;471 stub VarFormatDateTime ; stdcall (ptr long long ptr)
     345;472 stub VarFormatFromTokens ; stdcall (ptr ptr ptr long ptr long)
     346;473 stub VarFormatNumber ; stdcall (ptr long long long long long ptr)
     347;474 stub VarFormatPercent ; stdcall (ptr long long long long long ptr)
     348;475 stub VarIdiv ; stdcall (ptr ptr ptr)
     349;476 stub VarImp ; stdcall (ptr ptr ptr)
     350;477 stub VarInt ; stdcall (ptr ptr)
     351;478 stub VarMod ; stdcall (ptr ptr ptr)
     352;479 stub VarMonthName ; stdcall (long long long ptr)
     353;480 stub VarMul ; stdcall (ptr ptr ptr)
     354;481 stub VarNeg ; stdcall (ptr ptr)
     355;482 stub VarNot ; stdcall (ptr ptr)
     356;483 stub VarOr ; stdcall (ptr ptr ptr)
     357;484 stub VarPow ; stdcall (ptr ptr ptr)
     358;485 stub VarR4CmpR8
     359;486 stub VarR8Pow ; stdcall (double double ptr)
     360;487 stub VarR8Round ; stdcall (double long ptr)
     361;488 stub VarRound ; stdcall (ptr long ptr)
     362;489 stub VarSub ; stdcall (ptr ptr ptr)
     363;490 stub VarTokenizeFormatString ; stdcall (ptr ptr long long long long ptr)
     364;491 stub VarWeekdayName ; stdcall (long long long long ptr)
     365;492 stub VarXor ; stdcall (ptr ptr ptr)

  • trunk/src/oleaut32/olefont.c

    r4837 r6575  
    2020#include "wine/unicode.h"
    2121#include "oleauto.h"    /* for SysAllocString(....) */
     22#include "wine/obj_base.h"
    2223#include "wine/obj_olefont.h"
    2324#include "wine/obj_storage.h"
    … …  
    956957{
    957958  OLEFontImpl* newObject = 0;
     959  LOGFONTW logFont;
     960  INT      fontHeight;
     961  CY       cySize;
    958962  _ICOM_THIS(OLEFontImpl, iface);
    959963  TRACE("(%p)->(%p)\n", this, ppfont);
    … …  
    974978  *newObject = *this;
    975979
    976   /*
    977    * That new object starts with a reference count of 1
    978    */
     980  /* We need to alloc new memory for the string, otherwise
     981   * we free memory twice.
     982   */
     983  newObject->description.lpstrName = HeapAlloc(
     984        GetProcessHeap(),0,
     985        (1+strlenW(this->description.lpstrName))*2
     986  );
     987  /* We need to clone the HFONT too. This is just cut & paste from above */
     988  IFont_get_Size(iface, &cySize);
     989
     990  fontHeight = MulDiv(cySize.s.Lo, 2540L, 72L);
     991  fontHeight = MulDiv(fontHeight, this->cyLogical,this->cyHimetric);
     992
     993  memset(&logFont, 0, sizeof(LOGFONTW));
     994
     995  logFont.lfHeight          = ((fontHeight%10000L)>5000L) ? (-fontHeight/10000L)-1 :
     996                                                            (-fontHeight/10000L);
     997  logFont.lfItalic          = this->description.fItalic;
     998  logFont.lfUnderline       = this->description.fUnderline;
     999  logFont.lfStrikeOut       = this->description.fStrikethrough;
     1000  logFont.lfWeight          = this->description.sWeight;
     1001  logFont.lfCharSet         = this->description.sCharset;
     1002  logFont.lfOutPrecision    = OUT_CHARACTER_PRECIS;
     1003  logFont.lfClipPrecision   = CLIP_DEFAULT_PRECIS;
     1004  logFont.lfQuality         = DEFAULT_QUALITY;
     1005  logFont.lfPitchAndFamily  = DEFAULT_PITCH;
     1006  strcpyW(logFont.lfFaceName,this->description.lpstrName);
     1007
     1008  newObject->gdiFont = CreateFontIndirectW(&logFont);
     1009
     1010
     1011  /* The cloned object starts with a reference count of 1 */
    9791012  newObject->ref          = 1;
    9801013
    … …  
    12031236{
    12041237  _ICOM_THIS_From_IDispatch(IFont, iface);
    1205   FIXME("(%p):Stub\n", this);
    1206 
    1207   return E_NOTIMPL;
     1238  FIXME("%p->(%ld,%s,%lx,%x), stub!\n", this,dispIdMember,debugstr_guid(riid),lcid,
     1239    wFlags
     1240  );
     1241  return S_OK;
    12081242}
    12091243
    … …  
    15931627}
    15941628
     1629/*******************************************************************************
     1630 * StdFont ClassFactory
     1631 */
     1632typedef struct
     1633{
     1634    /* IUnknown fields */
     1635    ICOM_VFIELD(IClassFactory);
     1636    DWORD                       ref;
     1637} IClassFactoryImpl;
     1638
     1639static HRESULT WINAPI
     1640SFCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
     1641        ICOM_THIS(IClassFactoryImpl,iface);
     1642
     1643        FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
     1644        return E_NOINTERFACE;
     1645}
     1646
     1647static ULONG WINAPI
     1648SFCF_AddRef(LPCLASSFACTORY iface) {
     1649        ICOM_THIS(IClassFactoryImpl,iface);
     1650        return ++(This->ref);
     1651}
     1652
     1653static ULONG WINAPI SFCF_Release(LPCLASSFACTORY iface) {
     1654        ICOM_THIS(IClassFactoryImpl,iface);
     1655        /* static class, won't be  freed */
     1656        return --(This->ref);
     1657}
     1658
     1659static HRESULT WINAPI SFCF_CreateInstance(
     1660        LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
     1661) {
     1662        ICOM_THIS(IClassFactoryImpl,iface);
     1663
     1664        if (IsEqualGUID(riid,&IID_IFont)) {
     1665            FONTDESC fd;
     1666
     1667            WCHAR fname[] = { 'S','y','s','t','e','m',0 };
     1668
     1669            fd.cbSizeofstruct = sizeof(fd);
     1670            fd.lpstrName      = fname;
     1671            fd.cySize.s.Lo    = 80000;
     1672            fd.cySize.s.Hi    = 0;
     1673            fd.sWeight        = 0;
     1674            fd.sCharset       = 0;
     1675            fd.fItalic        = 0;
     1676            fd.fUnderline     = 0;
     1677            fd.fStrikethrough = 0;
     1678            return OleCreateFontIndirect(&fd,riid,ppobj);
     1679        }
     1680
     1681        FIXME("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
     1682        return E_NOINTERFACE;
     1683}
     1684
     1685static HRESULT WINAPI SFCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
     1686        ICOM_THIS(IClassFactoryImpl,iface);
     1687        FIXME("(%p)->(%d),stub!\n",This,dolock);
     1688        return S_OK;
     1689}
     1690
     1691static ICOM_VTABLE(IClassFactory) SFCF_Vtbl = {
     1692        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
     1693        SFCF_QueryInterface,
     1694        SFCF_AddRef,
     1695        SFCF_Release,
     1696        SFCF_CreateInstance,
     1697        SFCF_LockServer
     1698};
     1699static IClassFactoryImpl STDFONT_CF = {&SFCF_Vtbl, 1 };
     1700
     1701void _get_STDFONT_CF(LPVOID *ppv) { *ppv = (LPVOID)&STDFONT_CF; }

  • trunk/src/oleaut32/olepicture.c

    r6504 r6575  
    900900    jpeg_finish_decompress(&jd);
    901901    jpeg_destroy_decompress(&jd);
    902     hdcref = CreateCompatibleDC(0);
     902    hdcref = GetDC(0);
    903903    This->desc.u.bmp.hbitmap=CreateDIBitmap(
    904904            hdcref,
    … …  
    928928     * components which are in both
    929929     */
    930     hdcref = CreateCompatibleDC(0);
     930    hdcref = GetDC(0);
    931931    This->desc.u.bmp.hbitmap = CreateDIBitmap(
    932932        hdcref,
    … …  
    11351135
    11361136  VariantInit(pVarResult);
    1137   pVarResult->vt = VT_BOOL;
    1138   pVarResult->u.boolVal = FALSE;
     1137  V_VT(pVarResult) = VT_BOOL;
     1138  V_UNION(pVarResult,boolVal) = FALSE;
    11391139  return S_OK;
    11401140}

  • trunk/src/oleaut32/stubs.cpp

    r6504 r6575  
    1 /* $Id: stubs.cpp,v 1.10 2001-08-10 19:22:25 sandervl Exp $ */
     1/* $Id: stubs.cpp,v 1.11 2001-08-23 18:11:21 sandervl Exp $ */
    22/*
    33 * Win32 COM/OLE stubs for OS/2
    … …  
    4545}
    4646
    47 //*****************************************************************************
    48 //*****************************************************************************
    49 INT WIN32API VariantTimeToDosDateTime(DOUBLE vtime, USHORT * pwDosDate, USHORT * pwDosTime)
    50 {
    51     dprintf(("OLEAUT32: VariantTimeToDosDateTime - stub"));
    52     return 0;
    53 }
    5447
    5548//*****************************************************************************
    … …  
    6154}
    6255
    63 //*****************************************************************************
    64 //*****************************************************************************
    65 typedef struct {
    66     INT   cDig;
    67     ULONG dwInFlags;
    68     ULONG dwOutFlags;
    69     INT   cchUsed;
    70     INT   nBaseShift;
    71     INT   nPwr10;
    72 } NUMPARSE;
    73 
    74 HRESULT WIN32API VarParseNumFromStr
    75    (OLECHAR * strIn,
    76    LCID lcid,
    77    ULONG dwFlags,
    78    NUMPARSE * pnumprs,
    79    BYTE * rgbDig)
    80 {
    81     dprintf(("OLEAUT32: VarParseNumFromStr - stub"));
    82     return S_OK;
    83 }
    84 
    85 //*****************************************************************************
    86 //*****************************************************************************
    87 HRESULT WIN32API VarNumFromParseNum
    88    (NUMPARSE * pnumprs,
    89    BYTE * rgbDig,
    90    ULONG dwVtBits,
    91    VARIANT * pvar)
    92 {
    93     dprintf(("OLEAUT32: VarNumFromParseNum - stub"));
    94     return S_OK;
    95 }
    9656
    9757//*****************************************************************************
    … …  
    197157//*****************************************************************************
    198158//*****************************************************************************
    199 INT     WIN32API SystemTimeToVariantTime(LPSYSTEMTIME lpSystemTime, DOUBLE *pvtime)
    200 {
    201     dprintf(("OLEAUT32: SystemTimeToVariantTime - stub"));
    202     return 0;
    203 }
    204 
    205 //*****************************************************************************
    206 //*****************************************************************************
    207 INT     WIN32API VariantTimeToSystemTime(DOUBLE vtime, LPSYSTEMTIME lpSystemTime)
    208 {
    209     dprintf(("OLEAUT32: VariantTimeToSystemTime - stub"));
    210     return 0;
    211 }
    212 
    213 //*****************************************************************************
    214 //*****************************************************************************
    215159HRESULT WIN32API VarDecFromUI1(BYTE bIn, DECIMAL *pdecOut)
    216160{
    … …  
    437381//*****************************************************************************
    438382//*****************************************************************************
    439 typedef struct
    440 {
    441     SYSTEMTIME st;
    442     USHORT  wDayOfYear;
    443 } UDATE;
    444 
    445 HRESULT WIN32API VarDateFromUdate(UDATE *pudateIn, ULONG dwFlags, DATE *pdateOut)
    446 {
    447     dprintf(("OLEAUT32: VarDateFromUdate - stub"));
    448     return S_OK;
    449 }
    450 
    451 //*****************************************************************************
    452 //*****************************************************************************
    453 HRESULT WIN32API VarUdateFromDate(DATE dateIn, ULONG dwFlags, UDATE *pudateOut)
    454 {
    455     dprintf(("OLEAUT32: VarUdateFromDate - stub"));
    456     return S_OK;
    457 }
    458383
    459384//*****************************************************************************

  • trunk/src/oleaut32/typelib.c

    r6512 r6575  
    4141 *
    4242 */
    43 
    4443#ifdef __WIN32OS2__
    4544#define HAVE_FLOAT_H
    … …  
    6665
    6766#include "debugtools.h"
    68 
    6967
    7068DEFAULT_DEBUG_CHANNEL(ole);
    … …  
    158156    char    szPath[dwPathLen];
    159157#endif
    160 
    161158    if ( !HIWORD(guid) )
    162159    {
    … …  
    257254}
    258255#endif
     256
    259257/******************************************************************************
    260258 *              LoadTypeLib     [OLEAUT32.161]
    … …  
    802800    }       
    803801
    804     if (pvar->vt & VT_BYREF)
    805       return dump_Variant(pvar->u.pvarVal);
     802    if (V_VT(pvar) & VT_BYREF)
     803      return dump_Variant(V_UNION(pvar,pvarVal));
    806804}
    807805
    … …  
    10071005
    10081006    if(offset <0) { /* data is packed in here */
    1009         pVar->vt = (offset & 0x7c000000 )>> 26;
     1007        V_VT(pVar) = (offset & 0x7c000000 )>> 26;
    10101008        V_UNION(pVar, iVal) = offset & 0xffff;
    10111009        return;
    10121010    }
    1013     TLB_Read(&(pVar->vt), sizeof(VARTYPE), pcx,
     1011    TLB_Read(&(V_VT(pVar)), sizeof(VARTYPE), pcx,
    10141012        pcx->pTblDir->pCustData.offset + offset );
    1015     TRACE_(typelib)("Vartype = %x\n", pVar->vt);
    1016     switch(pVar->vt){
     1013    TRACE_(typelib)("Vartype = %x\n", V_VT(pVar));
     1014    switch (V_VT(pVar)){
    10171015        case VT_EMPTY:  /* FIXME: is this right? */
    10181016        case VT_NULL:   /* FIXME: is this right? */
    … …  
    10771075            size=0;
    10781076            FIXME("VARTYPE %d is not supported, setting pointer to NULL\n",
    1079                 pVar->vt);
     1077                V_VT(pVar));
    10801078    }
    10811079
    … …  
    12631261                             &(*pptfd)->funcdesc.lprgelemdescParam[j].tdesc) ;
    12641262
    1265                 V_UNION(& ((*pptfd)->funcdesc.lprgelemdescParam[j]),
    1266                         paramdesc.wParamFlags) = paraminfo.Flags;
     1263                (*pptfd)->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags = paraminfo.Flags;
    12671264
    12681265                (*pptfd)->pParamDesc[j].Name = (void *) paraminfo.oName;
    … …  
    13581355                /* default value */
    13591356                if ( (PARAMFLAG_FHASDEFAULT &
    1360                       V_UNION(&((*pptfd)->funcdesc.lprgelemdescParam[j]),
    1361                               paramdesc.wParamFlags)) &&
     1357                      (*pptfd)->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags) &&
    13621358                     ((pFuncRec->FKCCIC) & 0x1000) )
    13631359                {
    … …  
    13661362                                   (pFuncRec->nrargs * 4 + 1) * sizeof(INT) );
    13671363
    1368                     PARAMDESC* pParamDesc = &V_UNION(
    1369                                   & ((*pptfd)->funcdesc.lprgelemdescParam[j]),
    1370                                   paramdesc);
     1364                    PARAMDESC* pParamDesc = & (*pptfd)->funcdesc.lprgelemdescParam[j].u.paramdesc;
    13711365
    13721366                    pParamDesc->pparamdescex = TLB_Alloc(sizeof(PARAMDESCEX));
    13731367                    pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
    1374                    
     1368
    13751369                    TLB_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue),
    13761370                        pInt[j], pcx);
    … …  
    13851379           }
    13861380        }
    1387        
     1381
    13881382        /* scode is not used: archaic win16 stuff FIXME: right? */
    13891383        (*pptfd)->funcdesc.cScodes   = 0 ;
    13901384        (*pptfd)->funcdesc.lprgscode = NULL ;
    1391        
     1385
    13921386        pptfd      = & ((*pptfd)->next);
    13931387        recoffset += reclength;
    … …  
    14361430/*   (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) fixme?? */
    14371431        if(pVarRec->VarKind == VAR_CONST ){
    1438             V_UNION(&((*pptvd)->vardesc),lpvarValue)=TLB_Alloc(sizeof(VARIANT));
    1439             TLB_ReadValue(V_UNION(&((*pptvd)->vardesc),lpvarValue),
     1432            (*pptvd)->vardesc.u.lpvarValue=TLB_Alloc(sizeof(VARIANT));
     1433            TLB_ReadValue((*pptvd)->vardesc.u.lpvarValue,
    14401434                pVarRec->OffsValue, pcx);
    1441         }else
    1442             V_UNION(&((*pptvd)->vardesc),oInst)=pVarRec->OffsValue;
     1435        } else
     1436            (*pptvd)->vardesc.u.oInst=pVarRec->OffsValue;
    14431437        pptvd=&((*pptvd)->next);
    14441438        recoffset += reclength;
    … …  
    18651859                /* FIXME: check safearray */
    18661860                if(td[3] < 0)
    1867                     V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lptdesc)= & stndTypeDesc[td[2]];
     1861                    pTypeLibImpl->pTypeDesc[i].u.lptdesc= & stndTypeDesc[td[2]];
    18681862                else
    1869                     V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lptdesc)= & pTypeLibImpl->pTypeDesc[td[2]/8];
     1863                    pTypeLibImpl->pTypeDesc[i].u.lptdesc= & pTypeLibImpl->pTypeDesc[td[2]/8];
    18701864            }
    18711865            else if(td[0] == VT_CARRAY)
    18721866            {
    18731867                /* array descr table here */
    1874                 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc) = (void *)((int) td[2]);  /* temp store offset in*/
    1875             }                             
     1868                pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)((int) td[2]);  /* temp store offset in*/
     1869            }
    18761870            else if(td[0] == VT_USERDEFINED)
    18771871            {
    1878                 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),hreftype) = MAKELONG(td[2],td[3]);
     1872                pTypeLibImpl->pTypeDesc[i].u.hreftype = MAKELONG(td[2],td[3]);
    18791873            }
    18801874            if(++i<cTD) TLB_Read(td, sizeof(td), &cx, DO_NOT_SEEK);
    … …  
    18871881            if(tlbSegDir.pArrayDescriptions.offset>0)
    18881882            {
    1889                 TLB_Read(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (int) V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc));
    1890                 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc) = TLB_Alloc(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
     1883                TLB_Read(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (int) pTypeLibImpl->pTypeDesc[i].u.lpadesc);
     1884                pTypeLibImpl->pTypeDesc[i].u.lpadesc = TLB_Alloc(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
    18911885
    18921886                if(td[1]<0)
    1893                     V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->tdescElem.vt = td[0] & VT_TYPEMASK;
     1887                    pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem.vt = td[0] & VT_TYPEMASK;
    18941888                else
    1895                     V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->tdescElem = stndTypeDesc[td[0]/8];
    1896 
    1897                 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->cDims = td[2];
     1889                    pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem = stndTypeDesc[td[0]/8];
     1890
     1891                pTypeLibImpl->pTypeDesc[i].u.lpadesc->cDims = td[2];
    18981892
    18991893                for(j = 0; j<td[2]; j++)
    19001894                {
    1901                     TLB_Read(& V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->rgbounds[j].cElements,
     1895                    TLB_Read(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements,
    19021896                        sizeof(INT), &cx, DO_NOT_SEEK);
    1903                     TLB_Read(& V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->rgbounds[j].lLbound,
     1897                    TLB_Read(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound,
    19041898                        sizeof(INT), &cx, DO_NOT_SEEK);
    19051899                }
    … …  
    19071901            else
    19081902            {
    1909                 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc) = NULL;
     1903                pTypeLibImpl->pTypeDesc[i].u.lpadesc = NULL;
    19101904                ERR("didn't find array description data\n");
    19111905            }
    … …  
    30163010                if (i<pDispParams->cArgs) {
    30173011                    TRACE("set %d to disparg type %d vs %d\n",i,
    3018                             pDispParams->rgvarg[i].vt,
     3012                            V_VT(pDispParams->rgvarg+i),
    30193013                            pFDesc->funcdesc.lprgelemdescParam[i].tdesc.vt
    30203014                    );
    3021                     args[i+1] = pDispParams->rgvarg[i].u.lVal;
     3015                    args[i+1] = V_UNION(pDispParams->rgvarg+i,lVal);
    30223016                } else {
    30233017                    TYPEDESC *tdesc = &(pFDesc->funcdesc.lprgelemdescParam[i].tdesc);
    … …  
    30543048
    30553049                    VariantInit(&pVarResult[i]);
    3056                     pVarResult[i].u.intVal = args2[i];
     3050                    V_UNION(pVarResult+i,intVal) = args2[i];
    30573051
    30583052                    if (tdesc->vt == VT_PTR)
    30593053                        tdesc = tdesc->u.lptdesc;
    3060                     pVarResult[i].vt = tdesc->vt;
     3054                    V_VT(pVarResult+i) = tdesc->vt;
    30613055
    30623056                    /* HACK: VB5 likes this.
    … …  
    30663060                     */
    30673061                    if ((tdesc->vt == VT_PTR) && (dwFlags & DISPATCH_METHOD))
    3068                         pVarResult[i].vt = VT_DISPATCH;
     3062                        V_VT(pVarResult+i) = VT_DISPATCH;
    30693063                    TRACE("storing into variant: [%d] type %d, val %08x\n",
    3070                             i,pVarResult[i].vt,pVarResult[i].u.intVal
     3064                            i,V_VT(pVarResult+i),V_UNION(pVarResult+i,intVal)
    30713065                    );
    30723066                }

  • trunk/src/oleaut32/variant.c

    r6507 r6575  
    2020 *   - The parsing does not accept as many formats as the Windows implementation.
    2121 */
    22 
    2322#ifdef __WIN32OS2__
    2423#define HAVE_FLOAT_H
    … …  
    121120 *
    122121 ******************************************************************************/
    123 static BOOL DateTimeStringToTm( OLECHAR* strIn, LCID lcid, struct tm* pTm )
     122static BOOL DateTimeStringToTm( OLECHAR* strIn, DWORD dwFlags, struct tm* pTm )
    124123{
    125124        BOOL res = FALSE;
    … …  
    147146                        if( ParseDateTime( strDateTime, lowstr, field, ftype, MAXDATEFIELDS, &nf) == 0 )
    148147                        {
    149                                 if( lcid & VAR_DATEVALUEONLY )
     148                                if( dwFlags & VAR_DATEVALUEONLY )
    150149                                {
    151150                                        /* Get the date information.
    … …  
    165164                                        }
    166165                                }
    167                                 if( lcid & VAR_TIMEVALUEONLY )
     166                                if( dwFlags & VAR_TIMEVALUEONLY )
    168167                                {
    169168                                        /* Get time information only.
    … …  
    338337 * Returns TRUE if successful.
    339338 */
    340 static BOOL DateToTm( DATE dateIn, LCID lcid, struct tm* pTm )
     339static BOOL DateToTm( DATE dateIn, DWORD dwFlags, struct tm* pTm )
    341340{
    342341        /* Do not process dates smaller than January 1, 1900.
    … …  
    350349                memset(pTm,0,sizeof(*pTm));
    351350       
    352                 /* Because of the nature of DATE format witch
     351                /* Because of the nature of DATE format which
    353352                 * associates 2.0 to January 1, 1900. We will
    354353                 * remove 1.0 from the whole part of the DATE
    355354                 * so that in the following code 1.0
    356355                 * will correspond to January 1, 1900.
    357                  * This simplyfies the processing of the DATE value.
     356                 * This simplifies the processing of the DATE value.
    358357                 */
    359358                dateIn -= 1.0;
    … …  
    362361                decimalPart = fmod( dateIn, wholePart );
    363362
    364                 if( !(lcid & VAR_TIMEVALUEONLY) )
     363                if( !(dwFlags & VAR_TIMEVALUEONLY) )
    365364                {
    366365                        int nDay = 0;
    367366                        int leapYear = 0;
    368367                        double yearsSince1900 = 0;
    369                         /* Start at 1900, this where the DATE time 0.0 starts.
     368                        /* Start at 1900, this is where the DATE time 0.0 starts.
    370369                         */
    371370                        pTm->tm_year = 1900;
    … …  
    383382                        }
    384383
    385                         /* find what day of that year does the "wholePart" corresponds to.
     384                        /* find what day of that year the "wholePart" corresponds to.
    386385                         * Note: nDay is in [1-366] format
    387386                         */
    388387                        nDay = (int) ( wholePart - floor( yearsSince1900 * DAYS_IN_ONE_YEAR ) );
    389388                        /* Set the tm_yday value.
    390                          * Note: The day is must be converted from [1-366] to [0-365]
     389                         * Note: The day must be converted from [1-366] to [0-365]
    391390                         */
    392391                        /*pTm->tm_yday = nDay - 1;*/
    393                         /* find which mount this day corresponds to.
     392                        /* find which month this day corresponds to.
    394393                         */
    395394                        if( nDay <= 31 )
    … …  
    454453                        }
    455454                }
    456                 if( !(lcid & VAR_DATEVALUEONLY) )
     455                if( !(dwFlags & VAR_DATEVALUEONLY) )
    457456                {
    458457                        /* find the number of seconds in this day.
    … …  
    479478{
    480479    int size = 0;
    481     switch( parg->vt & VT_TYPEMASK )
     480    switch( V_VT(parg) & VT_TYPEMASK )
    482481    {
    483482    case( VT_I2 ):
    … …  
    522521    case( VT_DECIMAL ):
    523522    default:
    524         FIXME("Add size information for type vt=%d\n", parg->vt & VT_TYPEMASK );
     523        FIXME("Add size information for type vt=%d\n", V_VT(parg) & VT_TYPEMASK );
    525524        break;
    526525    }
    … …  
    879878 * This function dispatches execution to the proper conversion API
    880879 * to do the necessary coercion.
     880 *
     881 * FIXME: Passing down dwFlags to the conversion functions is wrong, this
     882 *        is a different flagmask. Check MSDN.
    881883 */
    882884static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, VARTYPE vt )
    … …  
    884886        HRESULT res = S_OK;
    885887        unsigned short vtFrom = 0;
    886         vtFrom = ps->vt & VT_TYPEMASK;
     888        vtFrom = V_VT(ps) & VT_TYPEMASK;
     889
    887890       
    888891        /* Note: Since "long" and "int" values both have 4 bytes and are
    … …  
    910913        if( res == S_OK )
    911914        {
    912             pd->vt = VT_NULL;
     915            V_VT(pd) = VT_NULL;
    913916        }
    914917        break;
    … …  
    920923            break;
    921924                case( VT_I2 ):
    922                         res = VarI1FromI2( ps->u.iVal, &(pd->u.cVal) );
     925                        res = VarI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,cVal) );
    923926                        break;
    924927                case( VT_INT ):
    925928                case( VT_I4 ):
    926                         res = VarI1FromI4( ps->u.lVal, &(pd->u.cVal) );
     929                        res = VarI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,cVal) );
    927930                        break;
    928931                case( VT_UI1 ):
    929                         res = VarI1FromUI1( ps->u.bVal, &(pd->u.cVal) );
     932                        res = VarI1FromUI1( V_UNION(ps,bVal), &V_UNION(pd,cVal) );
    930933                        break;
    931934                case( VT_UI2 ):
    932                         res = VarI1FromUI2( ps->u.uiVal, &(pd->u.cVal) );
     935                        res = VarI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cVal) );
    933936                        break;
    934937                case( VT_UINT ):
    935938                case( VT_UI4 ):
    936                         res = VarI1FromUI4( ps->u.ulVal, &(pd->u.cVal) );
     939                        res = VarI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cVal) );
    937940                        break;
    938941                case( VT_R4 ):
    939                         res = VarI1FromR4( ps->u.fltVal, &(pd->u.cVal) );
     942                        res = VarI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,cVal) );
    940943                        break;
    941944                case( VT_R8 ):
    942                         res = VarI1FromR8( ps->u.dblVal, &(pd->u.cVal) );
     945                        res = VarI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,cVal) );
    943946                        break;
    944947                case( VT_DATE ):
    945                         res = VarI1FromDate( ps->u.date, &(pd->u.cVal) );
     948                        res = VarI1FromDate( V_UNION(ps,date), &V_UNION(pd,cVal) );
    946949                        break;
    947950                case( VT_BOOL ):
    948                         res = VarI1FromBool( ps->u.boolVal, &(pd->u.cVal) );
     951                        res = VarI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,cVal) );
    949952                        break;
    950953                case( VT_BSTR ):
    951                         res = VarI1FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.cVal) );
     954                        res = VarI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cVal) );
    952955                        break;
    953956                case( VT_CY ):
    954              res = VarI1FromCy( ps->u.cyVal, &(pd->u.cVal) );
     957                        res = VarI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,cVal) );
     958                        break;
    955959                case( VT_DISPATCH ):
    956                         /*res = VarI1FromDisp32( ps->u.pdispVal, lcid, &(pd->u.cVal) );*/
     960                        /*res = VarI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cVal) );*/
     961                case( VT_DECIMAL ):
     962                        /*res = VarI1FromDec( V_UNION(ps,decVal), &V_UNION(pd,cVal) );*/
    957963                case( VT_UNKNOWN ):
    958                         /*res = VarI1From32( ps->u.lVal, &(pd->u.cVal) );*/
    959                 case( VT_DECIMAL ):
    960                         /*res = VarI1FromDec32( ps->u.decVal, &(pd->u.cVal) );*/
    961964                default:
    962965                        res = DISP_E_TYPEMISMATCH;
    … …  
    970973                {
    971974                case( VT_I1 ):
    972                         res = VarI2FromI1( ps->u.cVal, &(pd->u.iVal) );
     975                        res = VarI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,iVal) );
    973976                        break;
    974977        case( VT_I2 ):
    … …  
    977980                case( VT_INT ):
    978981                case( VT_I4 ):
    979                         res = VarI2FromI4( ps->u.lVal, &(pd->u.iVal) );
     982                        res = VarI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,iVal) );
    980983                        break;
    981984                case( VT_UI1 ):
    982                         res = VarI2FromUI1( ps->u.bVal, &(pd->u.iVal) );
     985                        res = VarI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,iVal) );
    983986                        break;
    984987                case( VT_UI2 ):
    985                         res = VarI2FromUI2( ps->u.uiVal, &(pd->u.iVal) );
     988                        res = VarI2FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,iVal) );
    986989                        break;
    987990                case( VT_UINT ):
    988991                case( VT_UI4 ):
    989                         res = VarI2FromUI4( ps->u.ulVal, &(pd->u.iVal) );
     992                        res = VarI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,iVal) );
    990993                        break;
    991994                case( VT_R4 ):
    992                         res = VarI2FromR4( ps->u.fltVal, &(pd->u.iVal) );
     995                        res = VarI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,iVal) );
    993996                        break;
    994997                case( VT_R8 ):
    995                         res = VarI2FromR8( ps->u.dblVal, &(pd->u.iVal) );
     998                        res = VarI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,iVal) );
    996999                        break;
    9971000                case( VT_DATE ):
    998                         res = VarI2FromDate( ps->u.date, &(pd->u.iVal) );
     1001                        res = VarI2FromDate( V_UNION(ps,date), &V_UNION(pd,iVal) );
    9991002                        break;
    10001003                case( VT_BOOL ):
    1001                         res = VarI2FromBool( ps->u.boolVal, &(pd->u.iVal) );
     1004                        res = VarI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,iVal) );
    10021005                        break;
    10031006                case( VT_BSTR ):
    1004                         res = VarI2FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.iVal) );
     1007                        res = VarI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,iVal) );
    10051008                        break;
    10061009                case( VT_CY ):
    1007              res = VarI2FromCy( ps->u.cyVal, &(pd->u.iVal) );
     1010                        res = VarI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,iVal) );
     1011                        break;
    10081012                case( VT_DISPATCH ):
    1009                         /*res = VarI2FromDisp32( ps->u.pdispVal, lcid, &(pd->u.iVal) );*/
     1013                        /*res = VarI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,iVal) );*/
     1014                case( VT_DECIMAL ):
     1015                        /*res = VarI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,iVal) );*/
    10101016                case( VT_UNKNOWN ):
    1011                         /*res = VarI2From32( ps->u.lVal, &(pd->u.iVal) );*/
    1012                 case( VT_DECIMAL ):
    1013                         /*res = VarI2FromDec32( ps->u.deiVal, &(pd->u.iVal) );*/
    10141017                default:
    10151018                        res = DISP_E_TYPEMISMATCH;
    … …  
    10241027                {
    10251028                case( VT_I1 ):
    1026                         res = VarI4FromI1( ps->u.cVal, &(pd->u.lVal) );
     1029                        res = VarI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,lVal) );
    10271030                        break;
    10281031                case( VT_I2 ):
    1029                         res = VarI4FromI2( ps->u.iVal, &(pd->u.lVal) );
     1032                        res = VarI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,lVal) );
    10301033            break;
    10311034        case( VT_INT ):
    … …  
    10371040            break;
    10381041                case( VT_UI1 ):
    1039                         res = VarI4FromUI1( ps->u.bVal, &(pd->u.lVal) );
     1042                        res = VarI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,lVal) );
    10401043                        break;
    10411044                case( VT_UI2 ):
    1042                         res = VarI4FromUI2( ps->u.uiVal, &(pd->u.lVal) );
     1045                        res = VarI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,lVal) );
    10431046                        break;
    10441047                case( VT_UINT ):
    10451048                case( VT_UI4 ):
    1046                         res = VarI4FromUI4( ps->u.ulVal, &(pd->u.lVal) );
     1049                        res = VarI4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,lVal) );
    10471050                        break;
    10481051                case( VT_R4 ):
    1049                         res = VarI4FromR4( ps->u.fltVal, &(pd->u.lVal) );
     1052                        res = VarI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,lVal) );
    10501053                        break;
    10511054                case( VT_R8 ):
    1052                         res = VarI4FromR8( ps->u.dblVal, &(pd->u.lVal) );
     1055                        res = VarI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,lVal) );
    10531056                        break;
    10541057                case( VT_DATE ):
    1055                         res = VarI4FromDate( ps->u.date, &(pd->u.lVal) );
     1058                        res = VarI4FromDate( V_UNION(ps,date), &V_UNION(pd,lVal) );
    10561059                        break;
    10571060                case( VT_BOOL ):
    1058                         res = VarI4FromBool( ps->u.boolVal, &(pd->u.lVal) );
     1061                        res = VarI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,lVal) );
    10591062                        break;
    10601063                case( VT_BSTR ):
    1061                         res = VarI4FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.lVal) );
     1064                        res = VarI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,lVal) );
    10621065                        break;
    10631066                case( VT_CY ):
    1064              res = VarI4FromCy( ps->u.cyVal, &(pd->u.lVal) );
     1067                        res = VarI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,lVal) );
     1068                        break;
    10651069                case( VT_DISPATCH ):
    1066                         /*res = VarI4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.lVal) );*/
     1070                        /*res = VarI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,lVal) );*/
     1071                case( VT_DECIMAL ):
     1072                        /*res = VarI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,lVal) );*/
    10671073                case( VT_UNKNOWN ):
    1068                         /*res = VarI4From32( ps->u.lVal, &(pd->u.lVal) );*/
    1069                 case( VT_DECIMAL ):
    1070                         /*res = VarI4FromDec32( ps->u.deiVal, &(pd->u.lVal) );*/
    10711074                default:
    10721075                        res = DISP_E_TYPEMISMATCH;
    … …  
    10801083                {
    10811084                case( VT_I1 ):
    1082                         res = VarUI1FromI1( ps->u.cVal, &(pd->u.bVal) );
     1085                        res = VarUI1FromI1( V_UNION(ps,cVal), &V_UNION(pd,bVal) );
    10831086                        break;
    10841087                case( VT_I2 ):
    1085                         res = VarUI1FromI2( ps->u.iVal, &(pd->u.bVal) );
     1088                        res = VarUI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,bVal) );
    10861089                        break;
    10871090                case( VT_INT ):
    10881091                case( VT_I4 ):
    1089                         res = VarUI1FromI4( ps->u.lVal, &(pd->u.bVal) );
     1092                        res = VarUI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,bVal) );
    10901093                        break;
    10911094        case( VT_UI1 ):
    … …  
    10931096            break;
    10941097                case( VT_UI2 ):
    1095                         res = VarUI1FromUI2( ps->u.uiVal, &(pd->u.bVal) );
     1098                        res = VarUI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,bVal) );
    10961099                        break;
    10971100                case( VT_UINT ):
    10981101                case( VT_UI4 ):
    1099                         res = VarUI1FromUI4( ps->u.ulVal, &(pd->u.bVal) );
     1102                        res = VarUI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,bVal) );
    11001103                        break;
    11011104                case( VT_R4 ):
    1102                         res = VarUI1FromR4( ps->u.fltVal, &(pd->u.bVal) );
     1105                        res = VarUI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,bVal) );
    11031106                        break;
    11041107                case( VT_R8 ):
    1105                         res = VarUI1FromR8( ps->u.dblVal, &(pd->u.bVal) );
     1108                        res = VarUI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,bVal) );
    11061109                        break;
    11071110                case( VT_DATE ):
    1108                         res = VarUI1FromDate( ps->u.date, &(pd->u.bVal) );
     1111                        res = VarUI1FromDate( V_UNION(ps,date), &V_UNION(pd,bVal) );
    11091112                        break;
    11101113                case( VT_BOOL ):
    1111                         res = VarUI1FromBool( ps->u.boolVal, &(pd->u.bVal) );
     1114                        res = VarUI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,bVal) );
    11121115                        break;
    11131116                case( VT_BSTR ):
    1114                         res = VarUI1FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.bVal) );
     1117                        res = VarUI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,bVal) );
    11151118                        break;
    11161119                case( VT_CY ):
    1117              res = VarUI1FromCy( ps->u.cyVal, &(pd->u.bVal) );
     1120                        res = VarUI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,bVal) );
     1121                        break;
    11181122                case( VT_DISPATCH ):
    1119                         /*res = VarUI1FromDisp32( ps->u.pdispVal, lcid, &(pd->u.bVal) );*/
     1123                        /*res = VarUI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,bVal) );*/
     1124                case( VT_DECIMAL ):
     1125                        /*res = VarUI1FromDec( V_UNION(ps,deiVal), &V_UNION(pd,bVal) );*/
    11201126                case( VT_UNKNOWN ):
    1121                         /*res = VarUI1From32( ps->u.lVal, &(pd->u.bVal) );*/
    1122                 case( VT_DECIMAL ):
    1123                         /*res = VarUI1FromDec32( ps->u.deiVal, &(pd->u.bVal) );*/
    11241127                default:
    11251128                        res = DISP_E_TYPEMISMATCH;
    … …  
    11331136                {
    11341137                case( VT_I1 ):
    1135                         res = VarUI2FromI1( ps->u.cVal, &(pd->u.uiVal) );
     1138                        res = VarUI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,uiVal) );
    11361139                        break;
    11371140                case( VT_I2 ):
    1138                         res = VarUI2FromI2( ps->u.iVal, &(pd->u.uiVal) );
     1141                        res = VarUI2FromI2( V_UNION(ps,iVal), &V_UNION(pd,uiVal) );
    11391142                        break;
    11401143                case( VT_INT ):
    11411144                case( VT_I4 ):
    1142                         res = VarUI2FromI4( ps->u.lVal, &(pd->u.uiVal) );
     1145                        res = VarUI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,uiVal) );
    11431146                        break;
    11441147                case( VT_UI1 ):
    1145                         res = VarUI2FromUI1( ps->u.bVal, &(pd->u.uiVal) );
     1148                        res = VarUI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,uiVal) );
    11461149                        break;
    11471150        case( VT_UI2 ):
    … …  
    11501153                case( VT_UINT ):
    11511154                case( VT_UI4 ):
    1152                         res = VarUI2FromUI4( ps->u.ulVal, &(pd->u.uiVal) );
     1155                        res = VarUI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,uiVal) );
    11531156                        break;
    11541157                case( VT_R4 ):
    1155                         res = VarUI2FromR4( ps->u.fltVal, &(pd->u.uiVal) );
     1158                        res = VarUI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,uiVal) );
    11561159                        break;
    11571160                case( VT_R8 ):
    1158                         res = VarUI2FromR8( ps->u.dblVal, &(pd->u.uiVal) );
     1161                        res = VarUI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,uiVal) );
    11591162                        break;
    11601163                case( VT_DATE ):
    1161                         res = VarUI2FromDate( ps->u.date, &(pd->u.uiVal) );
     1164                        res = VarUI2FromDate( V_UNION(ps,date), &V_UNION(pd,uiVal) );
    11621165                        break;
    11631166                case( VT_BOOL ):
    1164                         res = VarUI2FromBool( ps->u.boolVal, &(pd->u.uiVal) );
     1167                        res = VarUI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,uiVal) );
    11651168                        break;
    11661169                case( VT_BSTR ):
    1167                         res = VarUI2FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.uiVal) );
     1170                        res = VarUI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,uiVal) );
    11681171                        break;
    11691172                case( VT_CY ):
    1170              res = VarUI2FromCy( ps->u.cyVal, &(pd->u.uiVal) );
     1173                        res = VarUI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,uiVal) );
     1174                        break;
    11711175                case( VT_DISPATCH ):
    1172                         /*res = VarUI2FromDisp32( ps->u.pdispVal, lcid, &(pd->u.uiVal) );*/
     1176                        /*res = VarUI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,uiVal) );*/
     1177                case( VT_DECIMAL ):
     1178                        /*res = VarUI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,uiVal) );*/
    11731179                case( VT_UNKNOWN ):
    1174                         /*res = VarUI2From32( ps->u.lVal, &(pd->u.uiVal) );*/
    1175                 case( VT_DECIMAL ):
    1176                         /*res = VarUI2FromDec32( ps->u.deiVal, &(pd->u.uiVal) );*/
    11771180                default:
    11781181                        res = DISP_E_TYPEMISMATCH;
    … …  
    11871190                {
    11881191                case( VT_I1 ):
    1189                         res = VarUI4FromI1( ps->u.cVal, &(pd->u.ulVal) );
     1192                        res = VarUI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,ulVal) );
    11901193                        break;
    11911194                case( VT_I2 ):
    1192                         res = VarUI4FromI2( ps->u.iVal, &(pd->u.ulVal) );
     1195                        res = VarUI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,ulVal) );
    11931196                        break;
    11941197                case( VT_INT ):
    11951198                case( VT_I4 ):
    1196                         res = VarUI4FromI4( ps->u.lVal, &(pd->u.ulVal) );
     1199                        res = VarUI4FromI4( V_UNION(ps,lVal), &V_UNION(pd,ulVal) );
    11971200                        break;
    11981201                case( VT_UI1 ):
    1199                         res = VarUI4FromUI1( ps->u.bVal, &(pd->u.ulVal) );
     1202                        res = VarUI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,ulVal) );
    12001203                        break;
    12011204                case( VT_UI2 ):
    1202                         res = VarUI4FromUI2( ps->u.uiVal, &(pd->u.ulVal) );
     1205                        res = VarUI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,ulVal) );
    12031206                        break;
    12041207        case( VT_UI4 ):
    … …  
    12061209            break;
    12071210                case( VT_R4 ):
    1208                         res = VarUI4FromR4( ps->u.fltVal, &(pd->u.ulVal) );
     1211                        res = VarUI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,ulVal) );
    12091212                        break;
    12101213                case( VT_R8 ):
    1211                         res = VarUI4FromR8( ps->u.dblVal, &(pd->u.ulVal) );
     1214                        res = VarUI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,ulVal) );
    12121215                        break;
    12131216                case( VT_DATE ):
    1214                         res = VarUI4FromDate( ps->u.date, &(pd->u.ulVal) );
     1217                        res = VarUI4FromDate( V_UNION(ps,date), &V_UNION(pd,ulVal) );
    12151218                        break;
    12161219                case( VT_BOOL ):
    1217                         res = VarUI4FromBool( ps->u.boolVal, &(pd->u.ulVal) );
     1220                        res = VarUI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,ulVal) );
    12181221                        break;
    12191222                case( VT_BSTR ):
    1220                         res = VarUI4FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.ulVal) );
     1223                        res = VarUI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,ulVal) );
    12211224                        break;
    12221225                case( VT_CY ):
    1223              res = VarUI4FromCy( ps->u.cyVal, &(pd->u.ulVal) );
     1226                        res = VarUI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,ulVal) );
     1227                        break;
    12241228                case( VT_DISPATCH ):
    1225                         /*res = VarUI4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.ulVal) );*/
     1229                        /*res = VarUI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,ulVal) );*/
     1230                case( VT_DECIMAL ):
     1231                        /*res = VarUI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,ulVal) );*/
    12261232                case( VT_UNKNOWN ):
    1227                         /*res = VarUI4From32( ps->u.lVal, &(pd->u.ulVal) );*/
    1228                 case( VT_DECIMAL ):
    1229                         /*res = VarUI4FromDec32( ps->u.deiVal, &(pd->u.ulVal) );*/
    12301233                default:
    12311234                        res = DISP_E_TYPEMISMATCH;
    … …  
    12391242                {
    12401243                case( VT_I1 ):
    1241                         res = VarR4FromI1( ps->u.cVal, &(pd->u.fltVal) );
     1244                        res = VarR4FromI1( V_UNION(ps,cVal), &V_UNION(pd,fltVal) );
    12421245                        break;
    12431246                case( VT_I2 ):
    1244                         res = VarR4FromI2( ps->u.iVal, &(pd->u.fltVal) );
     1247                        res = VarR4FromI2( V_UNION(ps,iVal), &V_UNION(pd,fltVal) );
    12451248                        break;
    12461249                case( VT_INT ):
    12471250                case( VT_I4 ):
    1248                         res = VarR4FromI4( ps->u.lVal, &(pd->u.fltVal) );
     1251                        res = VarR4FromI4( V_UNION(ps,lVal), &V_UNION(pd,fltVal) );
    12491252                        break;
    12501253                case( VT_UI1 ):
    1251                         res = VarR4FromUI1( ps->u.bVal, &(pd->u.fltVal) );
     1254                        res = VarR4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,fltVal) );
    12521255                        break;
    12531256                case( VT_UI2 ):
    1254                         res = VarR4FromUI2( ps->u.uiVal, &(pd->u.fltVal) );
     1257                        res = VarR4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,fltVal) );
    12551258                        break;
    12561259                case( VT_UINT ):
    12571260                case( VT_UI4 ):
    1258                         res = VarR4FromUI4( ps->u.ulVal, &(pd->u.fltVal) );
     1261                        res = VarR4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,fltVal) );
    12591262                        break;
    12601263        case( VT_R4 ):
    … …  
    12621265            break;
    12631266                case( VT_R8 ):
    1264                         res = VarR4FromR8( ps->u.dblVal, &(pd->u.fltVal) );
     1267                        res = VarR4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,fltVal) );
    12651268                        break;
    12661269                case( VT_DATE ):
    1267                         res = VarR4FromDate( ps->u.date, &(pd->u.fltVal) );
     1270                        res = VarR4FromDate( V_UNION(ps,date), &V_UNION(pd,fltVal) );
    12681271                        break;
    12691272                case( VT_BOOL ):
    1270                         res = VarR4FromBool( ps->u.boolVal, &(pd->u.fltVal) );
     1273                        res = VarR4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,fltVal) );
    12711274                        break;
    12721275                case( VT_BSTR ):
    1273                         res = VarR4FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.fltVal) );
     1276                        res = VarR4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,fltVal) );
    12741277                        break;
    12751278                case( VT_CY ):
    1276              res = VarR4FromCy( ps->u.cyVal, &(pd->u.fltVal) );
     1279                        res = VarR4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,fltVal) );
     1280                        break;
    12771281                case( VT_DISPATCH ):
    1278                         /*res = VarR4FromDisp32( ps->u.pdispVal, lcid, &(pd->u.fltVal) );*/
     1282                        /*res = VarR4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,fltVal) );*/
     1283                case( VT_DECIMAL ):
     1284                        /*res = VarR4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,fltVal) );*/
    12791285                case( VT_UNKNOWN ):
    1280                         /*res = VarR4From32( ps->u.lVal, &(pd->u.fltVal) );*/
    1281                 case( VT_DECIMAL ):
    1282                         /*res = VarR4FromDec32( ps->u.deiVal, &(pd->u.fltVal) );*/
    12831286                default:
    12841287                        res = DISP_E_TYPEMISMATCH;
    … …  
    12921295                {
    12931296                case( VT_I1 ):
    1294                         res = VarR8FromI1( ps->u.cVal, &(pd->u.dblVal) );
     1297                        res = VarR8FromI1( V_UNION(ps,cVal), &V_UNION(pd,dblVal) );
    12951298                        break;
    12961299                case( VT_I2 ):
    1297                         res = VarR8FromI2( ps->u.iVal, &(pd->u.dblVal) );
     1300                        res = VarR8FromI2( V_UNION(ps,iVal), &V_UNION(pd,dblVal) );
    12981301                        break;
    12991302                case( VT_INT ):
    13001303                case( VT_I4 ):
    1301                         res = VarR8FromI4( ps->u.lVal, &(pd->u.dblVal) );
     1304                        res = VarR8FromI4( V_UNION(ps,lVal), &V_UNION(pd,dblVal) );
    13021305                        break;
    13031306                case( VT_UI1 ):
    1304                         res = VarR8FromUI1( ps->u.bVal, &(pd->u.dblVal) );
     1307                        res = VarR8FromUI1( V_UNION(ps,bVal), &V_UNION(pd,dblVal) );
    13051308                        break;
    13061309                case( VT_UI2 ):
    1307                         res = VarR8FromUI2( ps->u.uiVal, &(pd->u.dblVal) );
     1310                        res = VarR8FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,dblVal) );
    13081311                        break;
    13091312                case( VT_UINT ):
    13101313                case( VT_UI4 ):
    1311                         res = VarR8FromUI4( ps->u.ulVal, &(pd->u.dblVal) );
     1314                        res = VarR8FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,dblVal) );
    13121315                        break;
    13131316                case( VT_R4 ):
    1314                         res = VarR8FromR4( ps->u.fltVal, &(pd->u.dblVal) );
     1317                        res = VarR8FromR4( V_UNION(ps,fltVal), &V_UNION(pd,dblVal) );
    13151318                        break;
    13161319        case( VT_R8 ):
    … …  
    13181321            break;
    13191322                case( VT_DATE ):
    1320                         res = VarR8FromDate( ps->u.date, &(pd->u.dblVal) );
     1323                        res = VarR8FromDate( V_UNION(ps,date), &V_UNION(pd,dblVal) );
    13211324                        break;
    13221325                case( VT_BOOL ):
    1323                         res = VarR8FromBool( ps->u.boolVal, &(pd->u.dblVal) );
     1326                        res = VarR8FromBool( V_UNION(ps,boolVal), &V_UNION(pd,dblVal) );
    13241327                        break;
    13251328                case( VT_BSTR ):
    1326                         res = VarR8FromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.dblVal) );
     1329                        res = VarR8FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,dblVal) );
    13271330                        break;
    13281331                case( VT_CY ):
    1329              res = VarR8FromCy( ps->u.cyVal, &(pd->u.dblVal) );
     1332                        res = VarR8FromCy( V_UNION(ps,cyVal), &V_UNION(pd,dblVal) );
     1333                        break;
    13301334                case( VT_DISPATCH ):
    1331                         /*res = VarR8FromDisp32( ps->u.pdispVal, lcid, &(pd->u.dblVal) );*/
     1335                        /*res = VarR8FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,dblVal) );*/
     1336                case( VT_DECIMAL ):
     1337                        /*res = VarR8FromDec( V_UNION(ps,deiVal), &V_UNION(pd,dblVal) );*/
    13321338                case( VT_UNKNOWN ):
    1333                         /*res = VarR8From32( ps->u.lVal, &(pd->u.dblVal) );*/
    1334                 case( VT_DECIMAL ):
    1335                         /*res = VarR8FromDec32( ps->u.deiVal, &(pd->u.dblVal) );*/
    13361339                default:
    13371340                        res = DISP_E_TYPEMISMATCH;
    … …  
    13451348                {
    13461349                case( VT_I1 ):
    1347                         res = VarDateFromI1( ps->u.cVal, &(pd->u.date) );
     1350                        res = VarDateFromI1( V_UNION(ps,cVal), &V_UNION(pd,date) );
    13481351                        break;
    13491352                case( VT_I2 ):
    1350                         res = VarDateFromI2( ps->u.iVal, &(pd->u.date) );
     1353                        res = VarDateFromI2( V_UNION(ps,iVal), &V_UNION(pd,date) );
    13511354                        break;
    13521355                case( VT_INT ):
    1353                         res = VarDateFromInt( ps->u.intVal, &(pd->u.date) );
     1356                        res = VarDateFromInt( V_UNION(ps,intVal), &V_UNION(pd,date) );
    13541357                        break;
    13551358                case( VT_I4 ):
    1356                         res = VarDateFromI4( ps->u.lVal, &(pd->u.date) );
     1359                        res = VarDateFromI4( V_UNION(ps,lVal), &V_UNION(pd,date) );
    13571360                        break;
    13581361                case( VT_UI1 ):
    1359                         res = VarDateFromUI1( ps->u.bVal, &(pd->u.date) );
     1362                        res = VarDateFromUI1( V_UNION(ps,bVal), &V_UNION(pd,date) );
    13601363                        break;
    13611364                case( VT_UI2 ):
    1362                         res = VarDateFromUI2( ps->u.uiVal, &(pd->u.date) );
     1365                        res = VarDateFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,date) );
    13631366                        break;
    13641367                case( VT_UINT ):
    1365                         res = VarDateFromUint( ps->u.uintVal, &(pd->u.date) );
     1368                        res = VarDateFromUint( V_UNION(ps,uintVal), &V_UNION(pd,date) );
    13661369                        break;
    13671370                case( VT_UI4 ):
    1368                         res = VarDateFromUI4( ps->u.ulVal, &(pd->u.date) );
     1371                        res = VarDateFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,date) );
    13691372                        break;
    13701373                case( VT_R4 ):
    1371                         res = VarDateFromR4( ps->u.fltVal, &(pd->u.date) );
     1374                        res = VarDateFromR4( V_UNION(ps,fltVal), &V_UNION(pd,date) );
    13721375                        break;
    13731376                case( VT_R8 ):
    1374                         res = VarDateFromR8( ps->u.dblVal, &(pd->u.date) );
     1377                        res = VarDateFromR8( V_UNION(ps,dblVal), &V_UNION(pd,date) );
    13751378                        break;
    13761379        case( VT_DATE ):
    … …  
    13781381            break;
    13791382                case( VT_BOOL ):
    1380                         res = VarDateFromBool( ps->u.boolVal, &(pd->u.date) );
     1383                        res = VarDateFromBool( V_UNION(ps,boolVal), &V_UNION(pd,date) );
    13811384                        break;
    13821385                case( VT_BSTR ):
    1383                         res = VarDateFromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.date) );
     1386                        res = VarDateFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,date) );
    13841387                        break;
    13851388                case( VT_CY ):
    1386              res = VarDateFromCy( ps->u.cyVal, &(pd->u.date) );
     1389                        res = VarDateFromCy( V_UNION(ps,cyVal), &V_UNION(pd,date) );
     1390                        break;
    13871391                case( VT_DISPATCH ):
    1388                         /*res = VarDateFromDisp32( ps->u.pdispVal, lcid, &(pd->u.date) );*/
     1392                        /*res = VarDateFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,date) );*/
     1393                case( VT_DECIMAL ):
     1394                        /*res = VarDateFromDec( V_UNION(ps,deiVal), &V_UNION(pd,date) );*/
    13891395                case( VT_UNKNOWN ):
    1390                         /*res = VarDateFrom32( ps->u.lVal, &(pd->u.date) );*/
    1391                 case( VT_DECIMAL ):
    1392                         /*res = VarDateFromDec32( ps->u.deiVal, &(pd->u.date) );*/
    13931396                default:
    13941397                        res = DISP_E_TYPEMISMATCH;
    … …  
    14021405                {
    14031406                case( VT_I1 ):
    1404                         res = VarBoolFromI1( ps->u.cVal, &(pd->u.boolVal) );
     1407                        res = VarBoolFromI1( V_UNION(ps,cVal), &V_UNION(pd,boolVal) );
    14051408                        break;
    14061409                case( VT_I2 ):
    1407                         res = VarBoolFromI2( ps->u.iVal, &(pd->u.boolVal) );
     1410                        res = VarBoolFromI2( V_UNION(ps,iVal), &V_UNION(pd,boolVal) );
    14081411                        break;
    14091412                case( VT_INT ):
    1410                         res = VarBoolFromInt( ps->u.intVal, &(pd->u.boolVal) );
     1413                        res = VarBoolFromInt( V_UNION(ps,intVal), &V_UNION(pd,boolVal) );
    14111414                        break;
    14121415                case( VT_I4 ):
    1413                         res = VarBoolFromI4( ps->u.lVal, &(pd->u.boolVal) );
     1416                        res = VarBoolFromI4( V_UNION(ps,lVal), &V_UNION(pd,boolVal) );
    14141417                        break;
    14151418                case( VT_UI1 ):
    1416                         res = VarBoolFromUI1( ps->u.bVal, &(pd->u.boolVal) );
     1419                        res = VarBoolFromUI1( V_UNION(ps,bVal), &V_UNION(pd,boolVal) );
    14171420                        break;
    14181421                case( VT_UI2 ):
    1419                         res = VarBoolFromUI2( ps->u.uiVal, &(pd->u.boolVal) );
     1422                        res = VarBoolFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,boolVal) );
    14201423                        break;
    14211424                case( VT_UINT ):
    1422                         res = VarBoolFromUint( ps->u.uintVal, &(pd->u.boolVal) );
     1425                        res = VarBoolFromUint( V_UNION(ps,uintVal), &V_UNION(pd,boolVal) );
    14231426                        break;
    14241427                case( VT_UI4 ):
    1425                         res = VarBoolFromUI4( ps->u.ulVal, &(pd->u.boolVal) );
     1428                        res = VarBoolFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,boolVal) );
    14261429                        break;
    14271430                case( VT_R4 ):
    1428                         res = VarBoolFromR4( ps->u.fltVal, &(pd->u.boolVal) );
     1431                        res = VarBoolFromR4( V_UNION(ps,fltVal), &V_UNION(pd,boolVal) );
    14291432                        break;
    14301433                case( VT_R8 ):
    1431                         res = VarBoolFromR8( ps->u.dblVal, &(pd->u.boolVal) );
     1434                        res = VarBoolFromR8( V_UNION(ps,dblVal), &V_UNION(pd,boolVal) );
    14321435                        break;
    14331436                case( VT_DATE ):
    1434                         res = VarBoolFromDate( ps->u.date, &(pd->u.boolVal) );
     1437                        res = VarBoolFromDate( V_UNION(ps,date), &V_UNION(pd,boolVal) );
    14351438                        break;
    14361439        case( VT_BOOL ):
    … …  
    14381441            break;
    14391442                case( VT_BSTR ):
    1440                         res = VarBoolFromStr( ps->u.bstrVal, lcid, dwFlags, &(pd->u.boolVal) );
     1443                        res = VarBoolFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,boolVal) );
    14411444                        break;
    14421445                case( VT_CY ):
    1443              res = VarBoolFromCy( ps->u.cyVal, &(pd->u.boolVal) );
     1446                        res = VarBoolFromCy( V_UNION(ps,cyVal), &V_UNION(pd,boolVal) );
     1447                        break;
    14441448                case( VT_DISPATCH ):
    1445                         /*res = VarBoolFromDisp32( ps->u.pdispVal, lcid, &(pd->u.boolVal) );*/
     1449                        /*res = VarBoolFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,boolVal) );*/
     1450                case( VT_DECIMAL ):
     1451                        /*res = VarBoolFromDec( V_UNION(ps,deiVal), &V_UNION(pd,boolVal) );*/
    14461452                case( VT_UNKNOWN ):
    1447                         /*res = VarBoolFrom32( ps->u.lVal, &(pd->u.boolVal) );*/
    1448                 case( VT_DECIMAL ):
    1449                         /*res = VarBoolFromDec32( ps->u.deiVal, &(pd->u.boolVal) );*/
    14501453                default:
    14511454                        res = DISP_E_TYPEMISMATCH;
    … …  
    14591462                {
    14601463                case( VT_EMPTY ):
    1461                         if ((pd->u.bstrVal = SysAllocStringLen(NULL, 0)))
     1464                        if ((V_UNION(pd,bstrVal) = SysAllocStringLen(NULL, 0)))
    14621465                                res = S_OK;
    14631466                        else
    … …  
    14651468                        break;
    14661469                case( VT_I1 ):
    1467                         res = VarBstrFromI1( ps->u.cVal, lcid, dwFlags, &(pd->u.bstrVal) );
     1470                        res = VarBstrFromI1( V_UNION(ps,cVal), lcid, 0, &V_UNION(pd,bstrVal) );
    14681471                        break;
    14691472                case( VT_I2 ):
    1470                         res = VarBstrFromI2( ps->u.iVal, lcid, dwFlags, &(pd->u.bstrVal) );
     1473                        res = VarBstrFromI2( V_UNION(ps,iVal), lcid, 0, &V_UNION(pd,bstrVal) );
    14711474                        break;
    14721475                case( VT_INT ):
    1473                         res = VarBstrFromInt( ps->u.intVal, lcid, dwFlags, &(pd->u.bstrVal) );
     1476                        res = VarBstrFromInt( V_UNION(ps,intVal), lcid, 0, &V_UNION(pd,bstrVal) );
    14741477                        break;
    14751478                case( VT_I4 ):
    1476                         res = VarBstrFromI4( ps->u.lVal, lcid, dwFlags, &(pd->u.bstrVal) );
     1479                        res = VarBstrFromI4( V_UNION(ps,lVal), lcid, 0, &V_UNION(pd,bstrVal) );
    14771480                        break;
    14781481                case( VT_UI1 ):
    1479                         res = VarBstrFromUI1( ps->u.bVal, lcid, dwFlags, &(pd->u.bstrVal) );
     1482                        res = VarBstrFromUI1( V_UNION(ps,bVal), lcid, 0, &V_UNION(pd,bstrVal) );
    14801483                        break;
    14811484                case( VT_UI2 ):
    1482                         res = VarBstrFromUI2( ps->u.uiVal, lcid, dwFlags, &(pd->u.bstrVal) );
     1485                        res = VarBstrFromUI2( V_UNION(ps,uiVal), lcid, 0, &V_UNION(pd,bstrVal) );
    14831486                        break;
    14841487                case( VT_UINT ):
    1485                         res = VarBstrFromUint( ps->u.uintVal, lcid, dwFlags, &(pd->u.bstrVal) );
     1488                        res = VarBstrFromUint( V_UNION(ps,uintVal), lcid, 0, &V_UNION(pd,bstrVal) );
    14861489                        break;
    14871490                case( VT_UI4 ):
    1488                         res = VarBstrFromUI4( ps->u.ulVal, lcid, dwFlags, &(pd->u.bstrVal) );
     1491                        res = VarBstrFromUI4( V_UNION(ps,ulVal), lcid, 0, &V_UNION(pd,bstrVal) );
    14891492                        break;
    14901493                case( VT_R4 ):
    1491                         res = VarBstrFromR4( ps->u.fltVal, lcid, dwFlags, &(pd->u.bstrVal) );
     1494                        res = VarBstrFromR4( V_UNION(ps,fltVal), lcid, 0, &V_UNION(pd,bstrVal) );
    14921495                        break;
    14931496                case( VT_R8 ):
    1494                         res = VarBstrFromR8( ps->u.dblVal, lcid, dwFlags, &(pd->u.bstrVal) );
     1497                        res = VarBstrFromR8( V_UNION(ps,dblVal), lcid, 0, &V_UNION(pd,bstrVal) );
    14951498                        break;
    14961499                case( VT_DATE ):
    1497                         res = VarBstrFromDate( ps->u.date, lcid, dwFlags, &(pd->u.bstrVal) );
     1500                        res = VarBstrFromDate( V_UNION(ps,date), lcid, 0, &V_UNION(pd,bstrVal) );
    14981501                        break;
    14991502                case( VT_BOOL ):
    1500                         res = VarBstrFromBool( ps->u.boolVal, lcid, dwFlags, &(pd->u.bstrVal) );
    1501                         break;
    1502         case( VT_BSTR ):
    1503             res = VariantCopy( pd, ps );
    1504             break;
     1503                        res = VarBstrFromBool( V_UNION(ps,boolVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1504                        break;
     1505                case( VT_BSTR ):
     1506                        res = VariantCopy( pd, ps );
     1507                        break;
    15051508                case( VT_CY ):
    1506              /*res = VarBstrFromCy32( ps->u.cyVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
     1509                        res = VarBstrFromCy( V_UNION(ps,cyVal), lcid, 0, &V_UNION(pd,bstrVal) );
     1510                        break;
    15071511                case( VT_DISPATCH ):
    1508                         /*res = VarBstrFromDisp32( ps->u.pdispVal, lcid, lcid, dwFlags, &(pd->u.bstrVal) );*/
     1512                        /*res = VarBstrFromDisp( V_UNION(ps,pdispVal), lcid, 0, &(pd,bstrVal) );*/
     1513                case( VT_DECIMAL ):
     1514                        /*res = VarBstrFromDec( V_UNION(ps,deiVal), lcid, 0, &(pd,bstrVal) );*/
    15091515                case( VT_UNKNOWN ):
    1510                         /*res = VarBstrFrom32( ps->u.lVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
    1511                 case( VT_DECIMAL ):
    1512                         /*res = VarBstrFromDec32( ps->u.deiVal, lcid, dwFlags, &(pd->u.bstrVal) );*/
    15131516                default:
    15141517                        res = DISP_E_TYPEMISMATCH;
    … …  
    15221525          {
    15231526          case( VT_I1 ):
    1524              res = VarCyFromI1( ps->u.cVal, &(pd->u.cyVal) );
     1527             res = VarCyFromI1( V_UNION(ps,cVal), &V_UNION(pd,cyVal) );
    15251528             break;
    15261529          case( VT_I2 ):
    1527              res = VarCyFromI2( ps->u.iVal, &(pd->u.cyVal) );
     1530             res = VarCyFromI2( V_UNION(ps,iVal), &V_UNION(pd,cyVal) );
    15281531             break;
    15291532          case( VT_INT ):
    1530              res = VarCyFromInt( ps->u.intVal, &(pd->u.cyVal) );
     1533             res = VarCyFromInt( V_UNION(ps,intVal), &V_UNION(pd,cyVal) );
    15311534             break;
    15321535          case( VT_I4 ):
    1533              res = VarCyFromI4( ps->u.lVal, &(pd->u.cyVal) );
     1536             res = VarCyFromI4( V_UNION(ps,lVal), &V_UNION(pd,cyVal) );
    15341537             break;
    15351538          case( VT_UI1 ):
    1536              res = VarCyFromUI1( ps->u.bVal, &(pd->u.cyVal) );
     1539             res = VarCyFromUI1( V_UNION(ps,bVal), &V_UNION(pd,cyVal) );
    15371540             break;
    15381541          case( VT_UI2 ):
    1539              res = VarCyFromUI2( ps->u.uiVal, &(pd->u.cyVal) );
     1542             res = VarCyFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cyVal) );
    15401543             break;
    15411544          case( VT_UINT ):
    1542              res = VarCyFromUint( ps->u.uintVal, &(pd->u.cyVal) );
     1545             res = VarCyFromUint( V_UNION(ps,uintVal), &V_UNION(pd,cyVal) );
    15431546             break;
    15441547          case( VT_UI4 ):
    1545              res = VarCyFromUI4( ps->u.ulVal, &(pd->u.cyVal) );
     1548             res = VarCyFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cyVal) );
    15461549             break;
    15471550          case( VT_R4 ):
    1548              res = VarCyFromR4( ps->u.fltVal, &(pd->u.cyVal) );
     1551             res = VarCyFromR4( V_UNION(ps,fltVal), &V_UNION(pd,cyVal) );
    15491552             break;
    15501553          case( VT_R8 ):
    1551              res = VarCyFromR8( ps->u.dblVal, &(pd->u.cyVal) );
     1554             res = VarCyFromR8( V_UNION(ps,dblVal), &V_UNION(pd,cyVal) );
    15521555             break;
    15531556          case( VT_DATE ):
    1554              res = VarCyFromDate( ps->u.date, &(pd->u.cyVal) );
     1557             res = VarCyFromDate( V_UNION(ps,date), &V_UNION(pd,cyVal) );
    15551558             break;
    15561559          case( VT_BOOL ):
    1557              res = VarCyFromBool( ps->u.date, &(pd->u.cyVal) );
     1560             res = VarCyFromBool( V_UNION(ps,date), &V_UNION(pd,cyVal) );
    15581561             break;
    15591562          case( VT_CY ):
    … …  
    15611564             break;
    15621565          case( VT_BSTR ):
    1563              /*res = VarCyFromStr32( ps->u.bstrVal, lcid, dwFlags, &(pd->u.cyVal) );*/
     1566             res = VarCyFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cyVal) );
     1567             break;
    15641568          case( VT_DISPATCH ):
    1565              /*res = VarCyFromDisp32( ps->u.pdispVal, lcid, &(pd->u.boolVal) );*/
     1569             /*res = VarCyFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cyVal) );*/
     1570          case( VT_DECIMAL ):
     1571             /*res = VarCyFromDec( V_UNION(ps,deiVal), &V_UNION(pd,cyVal) );*/
     1572             break;
    15661573          case( VT_UNKNOWN ):
    1567              /*res = VarCyFrom32( ps->u.lVal, &(pd->u.boolVal) );*/
    1568           case( VT_DECIMAL ):
    1569              /*res = VarCyFromDec32( ps->u.deiVal, &(pd->u.boolVal) );*/
    15701574          default:
    15711575             res = DISP_E_TYPEMISMATCH;
    … …  
    16841688
    16851689  memset(pvarg, 0, sizeof (VARIANTARG));
    1686   pvarg->vt = VT_EMPTY;
     1690  V_VT(pvarg) = VT_EMPTY;
    16871691
    16881692  return;
    … …  
    17021706  TRACE("(%p)\n",pvarg);
    17031707
    1704   res = ValidateVariantType( pvarg->vt );
     1708  res = ValidateVariantType( V_VT(pvarg) );
    17051709  if( res == S_OK )
    17061710  {
    1707     if( !( pvarg->vt & VT_BYREF ) )
     1711    if( !( V_VT(pvarg) & VT_BYREF ) )
    17081712    {
    17091713      /*
    17101714       * The VT_ARRAY flag is a special case of a safe array.
    17111715       */
    1712       if ( (pvarg->vt & VT_ARRAY) != 0)
     1716      if ( (V_VT(pvarg) & VT_ARRAY) != 0)
    17131717      {
    1714         SafeArrayDestroy(pvarg->u.parray);
     1718        SafeArrayDestroy(V_UNION(pvarg,parray));
    17151719      }
    17161720      else
    17171721      {
    1718         switch( pvarg->vt & VT_TYPEMASK )
     1722        switch( V_VT(pvarg) & VT_TYPEMASK )
    17191723        {
    17201724          case( VT_BSTR ):
    1721             SysFreeString( pvarg->u.bstrVal );
     1725            SysFreeString( V_UNION(pvarg,bstrVal) );
    17221726            break;
    17231727          case( VT_DISPATCH ):
    1724             if(pvarg->u.pdispVal!=NULL)
    1725               ICOM_CALL(Release,pvarg->u.pdispVal);
     1728            if(V_UNION(pvarg,pdispVal)!=NULL)
     1729              ICOM_CALL(Release,V_UNION(pvarg,pdispVal));
    17261730            break;
    17271731          case( VT_VARIANT ):
    1728             VariantClear(pvarg->u.pvarVal);
     1732            VariantClear(V_UNION(pvarg,pvarVal));
    17291733            break;
    17301734          case( VT_UNKNOWN ):
    1731             if(pvarg->u.punkVal!=NULL)
    1732               ICOM_CALL(Release,pvarg->u.punkVal);
     1735            if(V_UNION(pvarg,punkVal)!=NULL)
     1736              ICOM_CALL(Release,V_UNION(pvarg,punkVal));
    17331737            break;
    17341738          case( VT_SAFEARRAY ):
    1735             SafeArrayDestroy(pvarg->u.parray);
     1739            SafeArrayDestroy(V_UNION(pvarg,parray));
    17361740            break;
    17371741          default:
    … …  
    17451749     */
    17461750    memset(pvarg, 0, sizeof (VARIANTARG));
    1747     pvarg->vt = VT_EMPTY;
     1751    V_VT(pvarg) = VT_EMPTY;
    17481752  }
    17491753
    … …  
    17621766  TRACE("(%p, %p)\n", pvargDest, pvargSrc);
    17631767
    1764   res = ValidateVariantType( pvargSrc->vt );
     1768  res = ValidateVariantType( V_VT(pvargSrc) );
    17651769
    17661770  /* If the pointer are to the same variant we don't need
    … …  
    17731777    if( res == S_OK )
    17741778    {
    1775       if( pvargSrc->vt & VT_BYREF )
     1779      if( V_VT(pvargSrc) & VT_BYREF )
    17761780      {
    17771781        /* In the case of byreference we only need
    17781782         * to copy the pointer.
    17791783         */
    1780         pvargDest->u = pvargSrc->u;
    1781         pvargDest->vt = pvargSrc->vt;
     1784        pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
     1785        V_VT(pvargDest) = V_VT(pvargSrc);
    17821786      }
    17831787      else
    … …  
    17861790         * The VT_ARRAY flag is another way to designate a safe array.
    17871791         */
    1788         if (pvargSrc->vt & VT_ARRAY)
    1789         {
    1790           SafeArrayCopy(pvargSrc->u.parray, &pvargDest->u.parray);
     1792        if (V_VT(pvargSrc) & VT_ARRAY)
     1793        {
     1794          SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
    17911795        }
    17921796        else
    … …  
    17981802           * called to increment the object's reference count.
    17991803           */
    1800           switch( pvargSrc->vt & VT_TYPEMASK )
     1804          switch( V_VT(pvargSrc) & VT_TYPEMASK )
    18011805          {
    18021806            case( VT_BSTR ):
    1803               pvargDest->u.bstrVal = SysAllocString( pvargSrc->u.bstrVal );
     1807              V_UNION(pvargDest,bstrVal) = SysAllocString( V_UNION(pvargSrc,bstrVal) );
    18041808              break;
    18051809            case( VT_DISPATCH ):
    1806               pvargDest->u.pdispVal = pvargSrc->u.pdispVal;
    1807               if (pvargDest->u.pdispVal!=NULL)
    1808                 ICOM_CALL(AddRef,pvargDest->u.pdispVal);
     1810              V_UNION(pvargDest,pdispVal) = V_UNION(pvargSrc,pdispVal);
     1811              if (V_UNION(pvargDest,pdispVal)!=NULL)
     1812                ICOM_CALL(AddRef,V_UNION(pvargDest,pdispVal));
    18091813              break;
    18101814            case( VT_VARIANT ):
    1811               VariantCopy(pvargDest->u.pvarVal,pvargSrc->u.pvarVal);
     1815              VariantCopy(V_UNION(pvargDest,pvarVal),V_UNION(pvargSrc,pvarVal));
    18121816              break;
    18131817            case( VT_UNKNOWN ):
    1814               pvargDest->u.punkVal = pvargSrc->u.punkVal;
    1815               if (pvargDest->u.pdispVal!=NULL)
    1816                 ICOM_CALL(AddRef,pvargDest->u.punkVal);
     1818              V_UNION(pvargDest,punkVal) = V_UNION(pvargSrc,punkVal);
     1819              if (V_UNION(pvargDest,pdispVal)!=NULL)
     1820                ICOM_CALL(AddRef,V_UNION(pvargDest,punkVal));
    18171821              break;
    18181822            case( VT_SAFEARRAY ):
    1819               SafeArrayCopy(pvargSrc->u.parray, &pvargDest->u.parray);
     1823              SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
    18201824              break;
    18211825            default:
    1822               pvargDest->u = pvargSrc->u;
     1826              pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
    18231827              break;
    18241828          }
    18251829        }
    18261830       
    1827         pvargDest->vt = pvargSrc->vt;
     1831        V_VT(pvargDest) = V_VT(pvargSrc);
    18281832      }     
    18291833    }
    … …  
    18461850  TRACE("(%p, %p)\n", pvargDest, pvargSrc);
    18471851
    1848   res = ValidateVariantType( pvargSrc->vt );
     1852  res = ValidateVariantType( V_VT(pvargSrc) );
    18491853
    18501854  if( res != S_OK )
    18511855    return res;
    18521856 
    1853   if( pvargSrc->vt & VT_BYREF )
     1857  if( V_VT(pvargSrc) & VT_BYREF )
    18541858  {
    18551859    VARIANTARG varg;
    … …  
    18751879         * The VT_ARRAY flag is another way to designate a safearray variant.
    18761880         */
    1877         if ( pvargSrc->vt & VT_ARRAY)
    1878         {
    1879           SafeArrayCopy(*pvargSrc->u.pparray, &pvargDest->u.parray);
     1881        if ( V_VT(pvargSrc) & VT_ARRAY)
     1882        {
     1883          SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
    18801884        }
    18811885        else
    … …  
    18871891          /* Get the variant type.
    18881892           */
    1889           switch( pvargSrc->vt & VT_TYPEMASK )
     1893          switch( V_VT(pvargSrc) & VT_TYPEMASK )
    18901894          {
    18911895            case( VT_BSTR ):
    1892               pvargDest->u.bstrVal = SysAllocString( *(pvargSrc->u.pbstrVal) );
     1896              V_UNION(pvargDest,bstrVal) = SysAllocString( *(V_UNION(pvargSrc,pbstrVal)) );
    18931897              break;
    18941898            case( VT_DISPATCH ):
    … …  
    19031907                 * returned.
    19041908                 */
    1905                 if( pvargSrc->wReserved1 & PROCESSING_INNER_VARIANT )
     1909                if( pvargSrc->n1.n2.wReserved1 & PROCESSING_INNER_VARIANT )
    19061910                {
    19071911                  /* If we get here we are attempting to deference
    … …  
    19171921                   * that will be passed to the VariantCopyInd function.
    19181922                   */
    1919                   (pvargSrc->u.pvarVal)->wReserved1 |= PROCESSING_INNER_VARIANT;
     1923                  (V_UNION(pvargSrc,pvarVal))->n1.n2.wReserved1 |= PROCESSING_INNER_VARIANT;
    19201924                 
    19211925                  /* Dereference the inner variant.
    19221926                   */
    1923                   res = VariantCopyInd( pvargDest, pvargSrc->u.pvarVal );
     1927                  res = VariantCopyInd( pvargDest, V_UNION(pvargSrc,pvarVal) );
    19241928                  /* We must also copy its type, I think.
    19251929                   */
    1926                   pvargSrc->vt = pvargSrc->u.pvarVal->vt;
     1930                  V_VT(pvargSrc) = V_VT(V_UNION(pvargSrc,pvarVal));
    19271931                }
    19281932              }
    … …  
    19311935              break;
    19321936            case( VT_SAFEARRAY ):
    1933               SafeArrayCopy(*pvargSrc->u.pparray, &pvargDest->u.parray);
     1937              SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
    19341938              break;
    19351939            default:
    19361940              /* This is a by reference Variant which means that the union
    19371941               * part of the Variant contains a pointer to some data of
    1938                * type "pvargSrc->vt & VT_TYPEMASK".
     1942               * type "V_VT(pvargSrc) & VT_TYPEMASK".
    19391943               * We will deference this data in a generic fashion using
    19401944               * the void pointer "Variant.u.byref".
    … …  
    19421946               * Variant.
    19431947               */
    1944               memcpy( &pvargDest->u, pvargSrc->u.byref, SizeOfVariantData( pvargSrc ) );
     1948              memcpy( &pvargDest->n1.n2, V_UNION(pvargSrc,byref), SizeOfVariantData( pvargSrc ) );
    19451949              break;
    19461950          }
    19471951        }
    19481952       
    1949         pvargDest->vt = pvargSrc->vt & VT_TYPEMASK;
     1953        V_VT(pvargDest) = V_VT(pvargSrc) & VT_TYPEMASK;
    19501954      }
    19511955    }
    … …  
    19861990        /* validate our source argument.
    19871991         */
    1988         res = ValidateVariantType( pvargSrc->vt );
     1992        res = ValidateVariantType( V_VT(pvargSrc) );
    19891993
    19901994        /* validate the vartype.
    … …  
    20122016        if( res == S_OK )
    20132017        {
    2014                 if( pvargSrc->vt & VT_BYREF )
     2018                if( V_VT(pvargSrc) & VT_BYREF )
    20152019                {
    20162020                        /* Convert the source variant to a "byvalue" variant.
    … …  
    20422046         */
    20432047        if ( res == S_OK )
    2044                 pvargDest->vt = vt;
     2048                V_VT(pvargDest) = vt;
    20452049
    20462050        return res;
    … …  
    22132217
    22142218/******************************************************************************
    2215  *              VarUI1FromStr           [OLEAUT32.54]
     2219 *              VarUI1FromStr           [OLEAUT32.136]
    22162220 */
    22172221HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
    … …  
    23692373
    23702374/******************************************************************************
    2371  *              VarI2FromI1             [OLEAUT32.48]
     2375 *              VarI2FromI1             [OLEAUT32.205]
    23722376 */
    23732377HRESULT WINAPI VarI2FromI1(CHAR cIn, short* psOut)
    … …  
    24002404
    24012405/******************************************************************************
    2402  *              VarI2FromUI4            [OLEAUT32.49]
     2406 *              VarI2FromUI4            [OLEAUT32.207]
    24032407 */
    24042408HRESULT WINAPI VarI2FromUI4(ULONG ulIn, short* psOut)
    … …  
    28362840
    28372841/******************************************************************************
    2838  *              VarR8FromUI1            [OLEAUT32.68]
     2842 *              VarR8FromUI1            [OLEAUT32.78]
    28392843 */
    28402844HRESULT WINAPI VarR8FromUI1(BYTE bIn, double* pdblOut)
    … …  
    28482852
    28492853/******************************************************************************
    2850  *              VarR8FromI2             [OLEAUT32.69]
     2854 *              VarR8FromI2             [OLEAUT32.79]
    28512855 */
    28522856HRESULT WINAPI VarR8FromI2(short sIn, double* pdblOut)
    … …  
    28602864
    28612865/******************************************************************************
    2862  *              VarR8FromI4             [OLEAUT32.70]
     2866 *              VarR8FromI4             [OLEAUT32.80]
    28632867 */
    28642868HRESULT WINAPI VarR8FromI4(LONG lIn, double* pdblOut)
    … …  
    29862990
    29872991/******************************************************************************
    2988  *              VarDateFromUI1          [OLEAUT32.]
     2992 *              VarDateFromUI1          [OLEAUT32.88]
    29892993 */
    29902994HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut)
    … …  
    29983002
    29993003/******************************************************************************
    3000  *              VarDateFromI2           [OLEAUT32.222]
     3004 *              VarDateFromI2           [OLEAUT32.89]
    30013005 */
    30023006HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut)
    … …  
    30943098    TRACE("( %p, %lx, %lx, %p ), stub\n", strIn, lcid, dwFlags, pdateOut );
    30953099
    3096     if( DateTimeStringToTm( strIn, lcid, &TM ) )
     3100    if( DateTimeStringToTm( strIn, dwFlags, &TM ) )
    30973101    {
    30983102        if( TmToDATE( &TM, pdateOut ) == FALSE )
    … …  
    32563260 *
    32573261 * The date is implemented using an 8 byte floating-point number.
    3258  * Days are represented by whole numbers increments starting with 0.00 has
     3262 * Days are represented by whole numbers increments starting with 0.00 as
    32593263 * being December 30 1899, midnight.
    32603264 * The hours are expressed as the fractional part of the number.
    … …  
    32883292    TRACE("( %f, %ld, %ld, %p ), stub\n", dateIn, lcid, dwFlags, pbstrOut );
    32893293
    3290     if( DateToTm( dateIn, lcid, &TM ) == FALSE )
     3294    if( DateToTm( dateIn, dwFlags, &TM ) == FALSE )
    32913295                        {
    32923296        return E_INVALIDARG;
    … …  
    42864290 * Convert signed char to currency
    42874291 */
    4288 HRESULT WINAPI VarCyFromI1(CHAR cIn, CY* pcyOut) {
     4292HRESULT WINAPI VarCyFromI1(signed char cIn, CY* pcyOut) {
    42894293   if (cIn < 0) pcyOut->s.Hi = -1;
    42904294   else pcyOut->s.Hi = 0;
    … …  
    43414345}
    43424346
     4347
     4348/**********************************************************************
     4349 *              VarParseNumFromStr [OLEAUT32.46]
     4350 */
     4351HRESULT WINAPI VarParseNumFromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags,
     4352                                  NUMPARSE * pnumprs, BYTE * rgbDig)
     4353{
     4354    int i,lastent=0;
     4355    int cDig;
     4356    FIXME("(%s,flags=%lx,....), partial stub!\n",debugstr_w(strIn),dwFlags);
     4357    FIXME("numparse: cDig=%d, InFlags=%lx\n",pnumprs->cDig,pnumprs->dwInFlags);
     4358
     4359    /* The other struct components are to be set by us */
     4360
     4361    memset(rgbDig,0,pnumprs->cDig);
     4362
     4363    cDig = 0;
     4364    for (i=0; strIn[i] ;i++) {
     4365        if ((strIn[i]>='0') && (strIn[i]<='9')) {
     4366            if (pnumprs->cDig > cDig) {
     4367                *(rgbDig++)=strIn[i]-'0';
     4368                cDig++;
     4369                lastent = i;
     4370            }
     4371        }
     4372    }
     4373    pnumprs->cDig       = cDig;
     4374
     4375    /* FIXME: Just patching some values in */
     4376    pnumprs->nPwr10     = 0;
     4377    pnumprs->nBaseShift = 0;
     4378    pnumprs->cchUsed    = lastent;
     4379    pnumprs->dwOutFlags = NUMPRS_DECIMAL;
     4380    return S_OK;
     4381}
     4382
     4383
     4384/**********************************************************************
     4385 *              VarNumFromParseNum [OLEAUT32.47]
     4386 */
     4387HRESULT WINAPI VarNumFromParseNum(NUMPARSE * pnumprs, BYTE * rgbDig,
     4388                                  ULONG dwVtBits, VARIANT * pvar)
     4389{
     4390    DWORD xint;
     4391    int i;
     4392    FIXME("(,dwVtBits=%lx,....), partial stub!\n",dwVtBits);
     4393
     4394    xint = 0;
     4395    for (i=0;i<pnumprs->cDig;i++)
     4396        xint = xint*10 + rgbDig[i];
     4397
     4398    VariantInit(pvar);
     4399    if (dwVtBits & VTBIT_I4) {
     4400        V_VT(pvar) = VT_I4;
     4401        V_UNION(pvar,intVal) = xint;
     4402        return S_OK;
     4403    }
     4404    if (dwVtBits & VTBIT_R8) {
     4405        V_VT(pvar) = VT_R8;
     4406        V_UNION(pvar,dblVal) = xint;
     4407        return S_OK;
     4408    } else {
     4409        FIXME("vtbitmask is unsupported %lx\n",dwVtBits);
     4410        return E_FAIL;
     4411    }
     4412}
     4413
     4414
     4415/**********************************************************************
     4416 *              VariantTimeToDosDateTime [OLEAUT32.??]
     4417 * Convert variant representation of time to the date and time representation
     4418 * stored in dos.
     4419 */
     4420INT WINAPI VariantTimeToDosDateTime(DATE pvtime, USHORT *wDosDate, USHORT *wDosTime)
     4421{
     4422    struct tm t;
     4423    wDosTime = 0;
     4424    wDosDate = 0;
     4425
     4426    TRACE("( 0x%x, 0x%x, 0x%p ), stub\n", *wDosDate, *wDosTime, &pvtime );
     4427
     4428    if (DateToTm(pvtime, 0, &t) < 0) return 0;
     4429
     4430    *wDosTime = *wDosTime | (t.tm_sec / 2);
     4431    *wDosTime = *wDosTime | (t.tm_min << 5);
     4432    *wDosTime = *wDosTime | (t.tm_hour << 11);
     4433
     4434    *wDosDate = *wDosDate | t.tm_mday ;
     4435    *wDosDate = *wDosDate | t.tm_mon << 5;
     4436    *wDosDate = *wDosDate | ((t.tm_year - 1980) << 9) ;
     4437
     4438    return 1;
     4439}
     4440
     4441
     4442HRESULT WINAPI SystemTimeToVariantTime( LPSYSTEMTIME  lpSystemTime, double *pvtime )
     4443{
     4444    static const BYTE Days_Per_Month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
     4445    static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
     4446
     4447    struct tm t;
     4448
     4449    TRACE(" %d/%d/%d %d:%d:%d\n",
     4450          lpSystemTime->wMonth, lpSystemTime->wDay,
     4451          lpSystemTime->wYear, lpSystemTime->wHour,
     4452          lpSystemTime->wMinute, lpSystemTime->wSecond);
     4453
     4454    if (lpSystemTime->wYear >= 1900)
     4455    {
     4456        t.tm_sec = lpSystemTime->wSecond;
     4457        t.tm_min = lpSystemTime->wMinute;
     4458        t.tm_hour = lpSystemTime->wHour;
     4459
     4460        t.tm_mday = lpSystemTime->wDay;
     4461        t.tm_mon = lpSystemTime->wMonth;
     4462        t.tm_year = lpSystemTime->wYear;
     4463
     4464        return TmToDATE( &t, pvtime );
     4465    }
     4466    else
     4467    {
     4468        t.tm_sec = lpSystemTime->wSecond;
     4469        t.tm_min = lpSystemTime->wMinute;
     4470        t.tm_hour = lpSystemTime->wHour;
     4471
     4472        if (isleap(lpSystemTime->wYear) )
     4473            t.tm_mday = Days_Per_Month_LY[13 - lpSystemTime->wMonth] - lpSystemTime->wDay;
     4474        else
     4475            t.tm_mday = Days_Per_Month[13 - lpSystemTime->wMonth] - lpSystemTime->wDay;
     4476
     4477        t.tm_mon = 13 - lpSystemTime->wMonth;
     4478        t.tm_year = 1900 + 1899 - lpSystemTime->wYear;
     4479
     4480        TmToDATE( &t, pvtime );
     4481
     4482        *pvtime *= -1;
     4483
     4484        return 1;
     4485    }
     4486
     4487    return 0;
     4488}
     4489
     4490HRESULT WINAPI VariantTimeToSystemTime( double vtime, LPSYSTEMTIME  lpSystemTime )
     4491{
     4492    double t = 0, timeofday = 0;
     4493
     4494    static const BYTE Days_Per_Month[] =    {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
     4495    static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
     4496
     4497    /* The Month_Code is used to find the Day of the Week (LY = LeapYear)*/
     4498    static const BYTE Month_Code[] =    {0, 1, 4, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6};
     4499    static const BYTE Month_Code_LY[] = {0, 0, 3, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6};
     4500
     4501    /* The Century_Code is used to find the Day of the Week */
     4502    static const BYTE Century_Code[]  = {0, 6, 4, 2};
     4503
     4504    struct tm r;
     4505
     4506    TRACE(" Variant = %f SYSTEMTIME ptr %p", vtime, lpSystemTime);
     4507
     4508    if (vtime >= 0)
     4509    {
     4510
     4511        if (DateToTm(vtime, 0, &r ) <= 0) return 0;
     4512
     4513        lpSystemTime->wSecond = r.tm_sec;
     4514        lpSystemTime->wMinute = r.tm_min;
     4515        lpSystemTime->wHour = r.tm_hour;
     4516        lpSystemTime->wDay = r.tm_mday;
     4517        lpSystemTime->wMonth = r.tm_mon;
     4518
     4519        if (lpSystemTime->wMonth == 12)
     4520            lpSystemTime->wMonth = 1;
     4521        else
     4522            lpSystemTime->wMonth++;
     4523
     4524        lpSystemTime->wYear = r.tm_year;
     4525    }
     4526    else
     4527    {
     4528        vtime = -1*vtime;
     4529
     4530        if (DateToTm(vtime, 0, &r ) <= 0) return 0;
     4531
     4532        lpSystemTime->wSecond = r.tm_sec;
     4533        lpSystemTime->wMinute = r.tm_min;
     4534        lpSystemTime->wHour = r.tm_hour;
     4535
     4536        lpSystemTime->wMonth = 13 - r.tm_mon;
     4537
     4538        if (lpSystemTime->wMonth == 1)
     4539            lpSystemTime->wMonth = 12;
     4540        else
     4541            lpSystemTime->wMonth--;
     4542
     4543        lpSystemTime->wYear = 1899 - (r.tm_year - 1900);
     4544
     4545        if (!isleap(lpSystemTime->wYear) )
     4546            lpSystemTime->wDay = Days_Per_Month[13 - lpSystemTime->wMonth] - r.tm_mday;
     4547        else
     4548            lpSystemTime->wDay = Days_Per_Month_LY[13 - lpSystemTime->wMonth] - r.tm_mday;
     4549
     4550
     4551    }
     4552
     4553    if (!isleap(lpSystemTime->wYear))
     4554    {
     4555        /*
     4556          (Century_Code+Month_Code+Year_Code+Day) % 7
     4557
     4558          The century code repeats every 400 years , so the array
     4559          works out like this,
     4560
     4561          Century_Code[0] is for 16th/20th Centry
     4562          Century_Code[1] is for 17th/21th Centry
     4563          Century_Code[2] is for 18th/22th Centry
     4564          Century_Code[3] is for 19th/23th Centry
     4565
     4566          The year code is found with the formula (year + (year / 4))
     4567          the "year" must be between 0 and 99 .
     4568
     4569          The Month Code (Month_Code[1]) starts with January and
     4570          ends with December.
     4571        */
     4572
     4573        lpSystemTime->wDayOfWeek = (
     4574            Century_Code[(( (lpSystemTime->wYear+100) - lpSystemTime->wYear%100) /100) %4]+
     4575            ((lpSystemTime->wYear%100)+(lpSystemTime->wYear%100)/4)+
     4576            Month_Code[lpSystemTime->wMonth]+
     4577            lpSystemTime->wDay) % 7;
     4578
     4579        if (lpSystemTime->wDayOfWeek == 0) lpSystemTime->wDayOfWeek = 7;
     4580        else lpSystemTime->wDayOfWeek -= 1;
     4581    }
     4582    else
     4583    {
     4584        lpSystemTime->wDayOfWeek = (
     4585            Century_Code[(((lpSystemTime->wYear+100) - lpSystemTime->wYear%100)/100)%4]+
     4586            ((lpSystemTime->wYear%100)+(lpSystemTime->wYear%100)/4)+
     4587            Month_Code_LY[lpSystemTime->wMonth]+
     4588            lpSystemTime->wDay) % 7;
     4589
     4590        if (lpSystemTime->wDayOfWeek == 0) lpSystemTime->wDayOfWeek = 7;
     4591        else lpSystemTime->wDayOfWeek -= 1;
     4592    }
     4593
     4594    t = floor(vtime);
     4595    timeofday = vtime - t;
     4596
     4597    lpSystemTime->wMilliseconds = (timeofday
     4598                                   - lpSystemTime->wHour*(1/24)
     4599                                   - lpSystemTime->wMinute*(1/1440)
     4600                                   - lpSystemTime->wSecond*(1/86400) )*(1/5184000);
     4601
     4602    return 1;
     4603}
     4604
     4605HRESULT WINAPI VarUdateFromDate( DATE datein, ULONG dwFlags, UDATE *pudateout)
     4606{
     4607    HRESULT i = 0;
     4608    static const BYTE Days_Per_Month[] =    {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
     4609    static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
     4610
     4611    TRACE("DATE = %f\n", (double)datein);
     4612    i = VariantTimeToSystemTime(datein, &(pudateout->st) );
     4613
     4614    if (i)
     4615    {
     4616        pudateout->wDayOfYear = 0;
     4617
     4618        if (isleap(pudateout->st.wYear))
     4619        {
     4620            for (i =1; i<pudateout->st.wMonth; i++)
     4621                pudateout->wDayOfYear += Days_Per_Month[i];
     4622        }
     4623        else
     4624        {
     4625            for (i =1; i<pudateout->st.wMonth; i++)
     4626                pudateout->wDayOfYear += Days_Per_Month_LY[i];
     4627        }
     4628
     4629        pudateout->wDayOfYear += pudateout->st.wDay;
     4630        dwFlags = 0; /*VAR_VALIDDATE*/
     4631    }
     4632    else dwFlags = 0;
     4633
     4634    return i;
     4635}
     4636
     4637HRESULT WINAPI VarDateFromUdate(UDATE *pudateout,
     4638                                ULONG dwFlags, DATE *datein)
     4639{
     4640    HRESULT i;
     4641    double t = 0;
     4642    TRACE(" %d/%d/%d %d:%d:%d\n",
     4643          pudateout->st.wMonth, pudateout->st.wDay,
     4644          pudateout->st.wYear, pudateout->st.wHour,
     4645          pudateout->st.wMinute, pudateout->st.wSecond);
     4646
     4647
     4648    i = SystemTimeToVariantTime(&(pudateout->st), &t);
     4649    *datein = t;
     4650
     4651    if (i) dwFlags = 0; /*VAR_VALIDDATE*/
     4652    else dwFlags = 0;
     4653
     4654    return i;
     4655}
     4656
     4657
     4658/**********************************************************************
     4659 *              VarBstrCmp [OLEAUT32.440]
     4660 *
     4661 * flags can be:
     4662 *   NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
     4663 *   NORM_IGNORESTRINGWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA
     4664 *
     4665 */
     4666HRESULT WINAPI VarBstrCmp(BSTR left, BSTR right, LCID lcid, DWORD flags)
     4667{
     4668    DWORD r;
     4669
     4670    FIXME("( %s %s %ld %lx ) partial stub\n", debugstr_w(left), debugstr_w(right), lcid, flags);
     4671
     4672    if((!left) || (!right))
     4673        return VARCMP_NULL;
     4674
     4675    if(flags&NORM_IGNORECASE)
     4676        r = lstrcmpiW(left,right);
     4677    else
     4678        r = lstrcmpW(left,right);
     4679
     4680    if(r<0)
     4681        return VARCMP_LT;
     4682    if(r>0)
     4683        return VARCMP_GT;
     4684
     4685    return VARCMP_EQ;
     4686}
     4687
     4688/**********************************************************************
     4689 *              VarBstrCat [OLEAUT32.439]
     4690 */
     4691HRESULT WINAPI VarBstrCat(BSTR left, BSTR right, BSTR *out)
     4692{
     4693    BSTR result;
     4694
     4695    TRACE("( %s %s %p )\n", debugstr_w(left), debugstr_w(right), out);
     4696
     4697    if( (!left) || (!right) || (!out) )
     4698        return 0;
     4699
     4700    result = SysAllocStringLen(left, lstrlenW(left)+lstrlenW(right));
     4701    lstrcatW(result,right);
     4702
     4703    *out = result;
     4704
     4705    return 1;
     4706}
     4707
Note: See TracChangeset for help on using the changeset viewer.