windows-xp/Source/XPSP1/NT/inetsrv/query/restrict/stgvara.cxx

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1998.
//
//  File:       StgVarA.cxx
//
//  Contents:   C++ wrapper for PROPVARIANT.
//
//  History:    01-Aug-94 KyleP     Created
//              14-May-97 mohamedn  allocate/deallocate SafeArrays (VT_ARRAY)
//
//--------------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

#ifndef _NTDLLBUILD_

#include <propset.h>
#include <propvar.h>
#include <pmalloc.hxx>

CAllocStorageVariant::CAllocStorageVariant(
    BYTE *pb,
    ULONG cb,
    PMemoryAllocator &ma)
{
    vt = VT_BLOB;

    if ( 0 == pb )
    {
        blob.cbSize = 0;
        blob.pBlobData = 0;
    }
    else
    {
        blob.cbSize = cb;
        blob.pBlobData = (BYTE *) ma.Allocate(cb);

        if (blob.pBlobData != NULL)
        {
            memcpy(blob.pBlobData, pb, cb);
        }
    }
}


CAllocStorageVariant::CAllocStorageVariant(
    char const *psz,
    PMemoryAllocator &ma)
{
    vt = VT_LPSTR;

    if ( 0 == psz )
    {
        pszVal = 0;
    }
    else
    {
        int cb = strlen(psz) + 1;

        pszVal = (char *) ma.Allocate(cb);

        if (pszVal != NULL)
        {
            memcpy(pszVal, psz, cb);
        }
    }
}


CAllocStorageVariant::CAllocStorageVariant(
    WCHAR const *pwsz,
    PMemoryAllocator &ma)
{
    vt = VT_LPWSTR;

    if ( 0 == pwsz )
    {
        pwszVal = 0;
    }
    else
    {
        int cb = (wcslen(pwsz) + 1) * sizeof(WCHAR);

        pwszVal = (WCHAR *) ma.Allocate(cb);

        if (pszVal != NULL)
        {
            memcpy(pwszVal, pwsz, cb);
        }
    }
}


CAllocStorageVariant::CAllocStorageVariant(
    CLSID const *pcid,
    PMemoryAllocator &ma)
{
    vt = VT_CLSID;
    puuid = (CLSID *) ma.Allocate(sizeof(CLSID));

    if (puuid != NULL)
    {
        memcpy(puuid, pcid, sizeof(CLSID));
    }
}


CAllocStorageVariant::CAllocStorageVariant(
    VARENUM v,
    ULONG cElements,
    PMemoryAllocator &ma)
{
    ULONG cbElement;
    BOOLEAN fZero = FALSE;

    // Ignore vector flag.  This constructor is always for vectors only.

    vt = v | VT_VECTOR;

    switch (vt)
    {
    case VT_VECTOR | VT_I1:
    case VT_VECTOR | VT_UI1:
        AssertByteVector(cac);                  // VT_I1
        AssertByteVector(caub);                 // VT_UI1
        cbElement = sizeof(caub.pElems[0]);
        break;

    case VT_VECTOR | VT_I2:
    case VT_VECTOR | VT_UI2:
    case VT_VECTOR | VT_BOOL:
        AssertShortVector(cai);                 // VT_I2
        AssertShortVector(caui);                // VT_UI2
        AssertShortVector(cabool);              // VT_BOOL
        cbElement = sizeof(cai.pElems[0]);
        break;

    case VT_VECTOR | VT_I4:
    case VT_VECTOR | VT_UI4:
    case VT_VECTOR | VT_R4:
    case VT_VECTOR | VT_ERROR:
        AssertLongVector(cal);                  // VT_I4
        AssertLongVector(caul);                 // VT_UI4
        AssertLongVector(caflt);                // VT_R4
        AssertLongVector(cascode);              // VT_ERROR
        cbElement = sizeof(cal.pElems[0]);
        break;

    case VT_VECTOR | VT_I8:
    case VT_VECTOR | VT_UI8:
    case VT_VECTOR | VT_R8:
    case VT_VECTOR | VT_CY:
    case VT_VECTOR | VT_DATE:
    case VT_VECTOR | VT_FILETIME:
        AssertLongLongVector(cah);              // VT_I8
        AssertLongLongVector(cauh);             // VT_UI8
        AssertLongLongVector(cadbl);            // VT_R8
        AssertLongLongVector(cacy);             // VT_CY
        AssertLongLongVector(cadate);           // VT_DATE
        AssertLongLongVector(cafiletime);       // VT_FILETIME
        cbElement = sizeof(cah.pElems[0]);
        break;

    case VT_VECTOR | VT_CLSID:
        AssertVarVector(cauuid, sizeof(GUID));
        cbElement = sizeof(GUID);
        fZero = TRUE;
        break;

    case VT_VECTOR | VT_CF:
        AssertVarVector(caclipdata, sizeof(CLIPDATA));  // VT_CF
        cbElement = sizeof(CLIPDATA);
        fZero = TRUE;
        break;

    case VT_VECTOR | VT_BSTR:
    case VT_VECTOR | VT_LPSTR:
    case VT_VECTOR | VT_LPWSTR:
        AssertStringVector(calpwstr);                   // VT_LPWSTR
        AssertStringVector(cabstr);                     // VT_BSTR
        AssertStringVector(calpstr);                    // VT_LPSTR
        cbElement = sizeof(VOID *);
        fZero = TRUE;
        break;

    case VT_VECTOR | VT_VARIANT:
        AssertVarVector(capropvar, sizeof(PROPVARIANT)); // VT_VARIANT
        cbElement = sizeof(PROPVARIANT);
        ASSERT(VT_EMPTY == 0);
        fZero = TRUE;
        break;

    default:
        ASSERT(!"CAllocStorageVariant -- Invalid vector type");
        vt = VT_EMPTY;
        break;
    }
    if (vt != VT_EMPTY)
    {
        caub.cElems = 0;
        caub.pElems = (BYTE *) ma.Allocate(cElements * cbElement);
        if (caub.pElems != NULL)
        {
            if (fZero)
            {
                memset(caub.pElems, 0, cElements * cbElement);
            }
            caub.cElems = cElements;
        }
    }
}


#define POINTER_FIXUP(type, field)                 \
  field.pElems = (type *) ma.Allocate(field.cElems * sizeof(field.pElems[0]));\
  if (field.pElems != NULL)                        \
  {                                                \
      memcpy(                                      \
          field.pElems,                            \
          var.field.pElems,                        \
          field.cElems * sizeof(field.pElems[0])); \
  }


CAllocStorageVariant::CAllocStorageVariant(
    PROPVARIANT& var,
    PMemoryAllocator &ma): CBaseStorageVariant(var)
{
    BOOLEAN fNoMemory = FALSE;
    ULONG i;

    //
    // Fixup any pointers
    //

    switch (vt)
    {
    case VT_EMPTY:
    case VT_NULL:
    case VT_I1:
    case VT_UI1:
    case VT_I2:
    case VT_UI2:
    case VT_BOOL:
    case VT_I4:
    case VT_UI4:
    case VT_R4:
    case VT_ERROR:
    case VT_I8:
    case VT_UI8:
    case VT_R8:
    case VT_INT:
    case VT_UINT:
    case VT_DECIMAL:
    case VT_CY:
    case VT_DATE:
    case VT_FILETIME:
        break;

    case VT_CLSID:
        vt = VT_EMPTY;
        SetCLSID(var.puuid, ma);
        break;

    case VT_BLOB:
    case VT_BLOB_OBJECT:
        blob.pBlobData = (BYTE *) ma.Allocate(blob.cbSize);
        if (blob.pBlobData == NULL)
        {
            fNoMemory = TRUE;
            break;
        }
        memcpy(blob.pBlobData, var.blob.pBlobData, blob.cbSize);
        break;

    case VT_CF:
        pclipdata = (CLIPDATA *) ma.Allocate(sizeof(*pclipdata));
        if (pclipdata == NULL)
        {
            fNoMemory = TRUE;
            break;
        }
        *pclipdata = *var.pclipdata;
        pclipdata->pClipData = (BYTE *) ma.Allocate(CBPCLIPDATA(*pclipdata));
        if (pclipdata->pClipData == NULL)
        {
            fNoMemory = TRUE;
            break;
        }
        memcpy(pclipdata->pClipData, var.pclipdata->pClipData, CBPCLIPDATA(*pclipdata));
        break;

    case VT_STREAM:
    case VT_VERSIONED_STREAM:
    case VT_STREAMED_OBJECT:
        pStream->AddRef();
        break;

    case VT_STORAGE:
    case VT_STORED_OBJECT:
        pStorage->AddRef();
        break;

    case VT_BSTR:
        vt = VT_EMPTY;
        SetBSTR(var.bstrVal, ma);
        break;

    case VT_LPSTR:
        vt = VT_EMPTY;
        SetLPSTR(var.pszVal, ma);
        break;

    case VT_LPWSTR:
        vt = VT_EMPTY;
        SetLPWSTR(var.pwszVal, ma);
        break;

    case VT_VECTOR | VT_I1:
    case VT_VECTOR | VT_UI1:
        POINTER_FIXUP(BYTE, caub);
        break;

    case VT_VECTOR | VT_I2:
    case VT_VECTOR | VT_UI2:
    case VT_VECTOR | VT_BOOL:
        AssertShortVector(cai);                 // VT_I2
        AssertShortVector(caui);                // VT_UI2
        AssertShortVector(cabool);              // VT_BOOL
        POINTER_FIXUP(short, cai);
        break;

    case VT_VECTOR | VT_I4:
    case VT_VECTOR | VT_UI4:
    case VT_VECTOR | VT_R4:
    case VT_VECTOR | VT_ERROR:
        AssertLongVector(cal);                  // VT_I4
        AssertLongVector(caul);                 // VT_UI4
        AssertLongVector(caflt);                // VT_R4
        AssertLongVector(cascode);              // VT_ERROR
        POINTER_FIXUP(long, cal);
        break;

    case VT_VECTOR | VT_I8:
    case VT_VECTOR | VT_UI8:
    case VT_VECTOR | VT_R8:
    case VT_VECTOR | VT_CY:
    case VT_VECTOR | VT_DATE:
    case VT_VECTOR | VT_FILETIME:
        AssertLongLongVector(cah);              // VT_I8
        AssertLongLongVector(cauh);             // VT_UI8
        AssertLongLongVector(cadbl);            // VT_R8
        AssertLongLongVector(cacy);             // VT_CY
        AssertLongLongVector(cadate);           // VT_DATE
        AssertLongLongVector(cafiletime);       // VT_FILETIME
        POINTER_FIXUP(LARGE_INTEGER, cah);
        break;

    case VT_VECTOR | VT_CLSID:
        POINTER_FIXUP(CLSID, cauuid);
        break;

    case VT_VECTOR | VT_CF:
    {
        caclipdata.pElems = (CLIPDATA *)
            ma.Allocate(caclipdata.cElems * sizeof(caclipdata.pElems[0]));
        if (caclipdata.pElems == NULL)
        {
            fNoMemory = TRUE;
            break;
        }
        memset(
            caclipdata.pElems,
            0,
            caclipdata.cElems * sizeof(caclipdata.pElems[0]));
        for (i = 0; i < caclipdata.cElems; i++)
        {
            caclipdata.pElems[i] = var.caclipdata.pElems[i];
            caclipdata.pElems[i].pClipData = (BYTE *)
                ma.Allocate(CBPCLIPDATA(caclipdata.pElems[i]));

            if (caclipdata.pElems[i].pClipData == NULL)
            {
                fNoMemory = TRUE;
                break;
            }
            memcpy(
                caclipdata.pElems[i].pClipData,
                var.caclipdata.pElems[i].pClipData,
                CBPCLIPDATA(caclipdata.pElems[i]));
        }
        break;
    }

    case VT_VECTOR | VT_BSTR:
    {
        cabstr.pElems = (BSTR *)
        ma.Allocate(cabstr.cElems * sizeof(cabstr.pElems[0]));
        if (cabstr.pElems == NULL)
        {
            fNoMemory = TRUE;
            break;
        }
        memset(cabstr.pElems, 0, cabstr.cElems * sizeof(cabstr.pElems[0]));
        for (i = 0; i < cabstr.cElems; i++)
        {
            cabstr.pElems[i] = SysAllocString(var.cabstr.pElems[i]);
            if (cabstr.pElems[i] == NULL)
            {
                fNoMemory = TRUE;
                break;
            }
        }
        break;
    }

    case VT_VECTOR | VT_LPSTR:
    {
        calpstr.pElems = (LPSTR *)
            ma.Allocate(calpstr.cElems * sizeof(calpstr.pElems[0]));
        if (calpstr.pElems == NULL)
        {
            fNoMemory = TRUE;
            break;
        }
        memset(calpstr.pElems, 0, calpstr.cElems * sizeof(calpstr.pElems[0]));
        for (i = 0; i < calpstr.cElems; i++)
        {
            unsigned cb = strlen(var.calpstr.pElems[i]) + 1;
            calpstr.pElems[i] = (char *) ma.Allocate(cb);
            if (calpstr.pElems[i] == NULL)
            {
                fNoMemory = TRUE;
                break;
            }
            memcpy(calpstr.pElems[i], var.calpstr.pElems[i], cb);
        }
        break;
    }

    case VT_VECTOR | VT_LPWSTR:
    {
        calpwstr.pElems = (LPWSTR *)
            ma.Allocate(calpwstr.cElems * sizeof(calpwstr.pElems[0]));
        if (calpwstr.pElems == NULL)
        {
            fNoMemory = TRUE;
            break;
        }
        memset(calpwstr.pElems, 0, calpwstr.cElems * sizeof(calpwstr.pElems[0]));
        for (i = 0; i < calpwstr.cElems; i++)
        {
            unsigned cb = (wcslen(var.calpwstr.pElems[i]) + 1) * sizeof(WCHAR);
            calpwstr.pElems[i] = (WCHAR *) ma.Allocate(cb);
            if (calpwstr.pElems[i] == NULL)
            {
                fNoMemory = TRUE;
                break;
            }
            memcpy(calpwstr.pElems[i], var.calpwstr.pElems[i], cb);
        }
        break;
    }

    case VT_VECTOR | VT_VARIANT:
        capropvar.pElems = (PROPVARIANT *)
            ma.Allocate(capropvar.cElems * sizeof(capropvar.pElems[0]));
        if (capropvar.pElems == NULL)
        {
            fNoMemory = TRUE;
            break;
        }
        ASSERT(VT_EMPTY == 0);
        memset(
            capropvar.pElems,
            0,
            capropvar.cElems * sizeof(capropvar.pElems[0]));

        for (i = 0; i < capropvar.cElems; i++)
        {
            new (&capropvar.pElems[i]) CAllocStorageVariant(
                                                var.capropvar.pElems[i],
                                                ma);

            if (!((CAllocStorageVariant *) &capropvar.pElems[i])->IsValid())
            {
                fNoMemory = TRUE;
                break;
            }
        }
        break;

    case VT_ARRAY | VT_I4:
    case VT_ARRAY | VT_UI1:
    case VT_ARRAY | VT_I2:
    case VT_ARRAY | VT_R4:
    case VT_ARRAY | VT_R8:
    case VT_ARRAY | VT_BOOL:
    case VT_ARRAY | VT_ERROR:
    case VT_ARRAY | VT_CY:
    case VT_ARRAY | VT_DATE:
    case VT_ARRAY | VT_I1:
    case VT_ARRAY | VT_UI2:
    case VT_ARRAY | VT_UI4:
    case VT_ARRAY | VT_INT:
    case VT_ARRAY | VT_UINT:
    case VT_ARRAY | VT_DECIMAL:
    case VT_ARRAY | VT_BSTR:
    case VT_ARRAY | VT_VARIANT:
        {
            //
            // avoid double delete of the source variant
            //

            parray = 0;

            SAFEARRAY * pSaDst = 0;

            if ( FAILED( SafeArrayCopy( var.parray, &pSaDst ) ) )
            {
                fNoMemory = TRUE;
                break;
            }

            parray = pSaDst;
        }
        break;

    default:
        {
            Win4Assert( !"Unexpected vt type" );
            return;
        }
    }
    if (fNoMemory || !IsValid())
    {
        ResetType(ma);

        // We cannot raise in a non-unwindable constructor.
        // Just return a PROPVARIANT guaranteed to look invalid.

        vt = VT_LPSTR;
        pszVal = NULL;
    }
}

//+---------------------------------------------------------------------------
//
//  Function:   SaCreateAndCopy
//
//  Synopsis:   Creates a safearray & initializes it with source safearray.
//
//  Arguments:  [ma]       - memory allocator to use
//              [psaSrc]   - source safearry
//              [ppsaDst] - safearray to be created.
//
//  Returns:    TRUE    - upon success
//              FALSE   - upon failure
//
//  History:    5-10-97     mohamedn    created
//
//----------------------------------------------------------------------------

BOOL SaCreateAndCopy( PMemoryAllocator &ma,
                      SAFEARRAY * psaSrc,
                      SAFEARRAY **ppsaDst )
{
    ULONG cb  = sizeof SAFEARRAY + ( ( 0 != psaSrc->cDims ?
                (psaSrc->cDims-1) : 0) * sizeof SAFEARRAYBOUND );

    Win4Assert( psaSrc->cDims > 0);

    SAFEARRAY * psaDst = (SAFEARRAY *) ma.Allocate( cb );
    if ( 0 == psaDst )
    {
        *ppsaDst = 0;
        return FALSE;
    }

    RtlCopyMemory(psaDst, psaSrc, cb);

    // reset fields and values
    psaDst->fFeatures &= ~( FADF_AUTO | FADF_STATIC );
    psaDst->cLocks     = 1;        // new safearray has lockcount of 1
    psaDst->pvData     = 0;

    *ppsaDst = psaDst;

    return TRUE;
} //SaCreateAndCopy

//+---------------------------------------------------------------------------
//
//  Function:   SaCreateData
//
//  Synopsis:   Creates/initializes SafeArray's data area
//
//  Arguments:  [ma]       - memory allocator to use
//              [vt]       - variant type (VT_ARRAY assumed)
//              [saSrc]    - source safearry
//              [saDst]    - destination safearray.
//              [fUseAllocatorOnly] - if TRUE, BSTRs are allocated using [ma]
//
//  Returns:    TRUE    - upon success
//              FALSE   - upon failure
//
//  History:    5-10-97     mohamedn    created
//
//----------------------------------------------------------------------------

BOOL SaCreateData(
    PVarAllocator & ma,
    VARTYPE         vt,
    SAFEARRAY &     saSrc,
    SAFEARRAY &     saDst,
    BOOL            fUseAllocatorOnly )
{
    //
    // Find out how much memory is needed for the array and allocate it.
    //
    unsigned cDataElements = SaCountElements(saSrc);
    ULONG cb = cDataElements * saSrc.cbElements;
    void * pv = ma.Allocate( cb );

    if ( !pv )
        return FALSE;

    RtlZeroMemory( pv, cb );

    switch (vt)
    {
    case VT_I4:
    case VT_UI1:
    case VT_I2:
    case VT_R4:
    case VT_R8:
    case VT_BOOL:
    case VT_ERROR:
    case VT_CY:
    case VT_DATE:
    case VT_I1:
    case VT_UI2:
    case VT_UI4:
    case VT_INT:
    case VT_UINT:
    case VT_DECIMAL:
        {
            RtlCopyMemory( pv, saSrc.pvData, cb);
            saDst.pvData = pv;
        }
        break;

    case VT_BSTR:
        {
            BSTR *pBstrSrc  = (BSTR *) saSrc.pvData;
            BSTR *pBstrDst = (BSTR *) pv;

            for ( unsigned i = 0; i < cDataElements; i++ )
            {
                Win4Assert( pBstrSrc[i]  != 0 );
                Win4Assert( pBstrDst[i] == 0 );

                if ( fUseAllocatorOnly )
                {
                    ULONG cbBstr = SysStringByteLen(pBstrSrc[i]) +
                                   sizeof (ULONG) +
                                   sizeof (WCHAR);
                    void * pv = ma.Allocate( cbBstr );
                    if ( 0 != pv )
                    {
                        BYTE * pbSrc = (BYTE *) pBstrSrc[i];
                        pbSrc -= sizeof ULONG;
                        RtlCopyMemory( pv, pbSrc, cbBstr);
                        pBstrDst[i] = (BSTR) ( (BYTE *) pv + sizeof ULONG );
                        pBstrDst[i] = (BSTR) ma.PointerToOffset( pBstrDst[i] );
                    }
                }
                else
                {
                    pBstrDst[i] = SysAllocString(pBstrSrc[i]);
                }

                if ( 0 == pBstrDst[i] )
                    return FALSE;
            }

            saDst.pvData = pv;
        }
        break;

    case VT_VARIANT:
        {
            CAllocStorageVariant *pVarntSrc = (CAllocStorageVariant *)saSrc.pvData;
            CAllocStorageVariant *pVarntDst = (CAllocStorageVariant *)pv;

            for ( unsigned i = 0; i < cDataElements; i++ )
            {
                Win4Assert( pVarntDst[i].vt == 0 );

                if ( VT_BSTR == pVarntSrc[i].vt )
                {
                    if ( fUseAllocatorOnly )
                    {
                        ULONG cbBstr = SysStringByteLen(pVarntSrc[i].bstrVal) +
                                       sizeof (ULONG) +
                                       sizeof (WCHAR);
                        void * pv = ma.Allocate( cbBstr );
                        if ( 0 != pv )
                        {
                            BYTE * pbSrc = (BYTE *) pVarntSrc[i].bstrVal;
                            pbSrc -= sizeof ULONG;
                            RtlCopyMemory( pv, pbSrc, cbBstr);
                            pVarntDst[i].bstrVal = (BSTR) ((BYTE *) pv + sizeof ULONG);
                            pVarntDst[i].bstrVal = (BSTR) ma.PointerToOffset( pVarntDst[i].bstrVal );
                        }
                    }
                    else
                    {
                        pVarntDst[i].bstrVal = SysAllocString(pVarntSrc[i].bstrVal);
                    }

                    if (  0 == pVarntDst[i].bstrVal )
                        return FALSE;

                    pVarntDst[i].vt = VT_BSTR;
                }
                else if ( 0 != (pVarntSrc[i].vt & VT_ARRAY) )
                {
                    SAFEARRAY * pSaSrc = pVarntSrc[i].parray;
                    SAFEARRAY * pSaDst = 0;

                    if ( !SaCreateAndCopy( ma, pSaSrc, &pSaDst ) )
                        return FALSE;

                    if ( !SaCreateData( ma,
                                        pVarntSrc[i].vt & ~VT_ARRAY,
                                        *pSaSrc,
                                        *pSaDst,
                                        fUseAllocatorOnly ) )
                        return FALSE;

                    pVarntDst[i].parray = (SAFEARRAY *) ma.PointerToOffset( pSaDst );
                    pVarntDst[i].vt = pVarntSrc[i].vt;
                }
                else
                {
                    Win4Assert( pVarntSrc[i].vt != VT_VARIANT );
                    Win4Assert( pVarntSrc[i].vt != VT_LPWSTR );
                    Win4Assert( pVarntSrc[i].vt != VT_LPSTR );
                    Win4Assert( pVarntSrc[i].vt != VT_CLSID );

                    pVarntDst[i] = pVarntSrc[i];
                }
            }

            saDst.pvData = pv;
        }
        break;

    default:
        ciDebugOut(( DEB_ERROR, "Unexpected SafeArray type: vt=%x\n", vt ) );
        Win4Assert( !"Unexpected SafeArray Type" );
        return FALSE;
    }

    saDst.pvData = (void *) ma.PointerToOffset( saDst.pvData );

    return TRUE;
} //SaCreateData

//+---------------------------------------------------------------------------
//
//  Function:   SaComputeSize
//
//  Synopsis:   Computes the size of a safearray.
//
//  Arguments:  [vt]       - variant type (VT_ARRAY assumed)
//              [saSrc]    - source safearry
//
//  Returns:    ULONG - number of bytes of memory needed to store safearray
//
//  History:    5-01-98     AlanW       Created
//
//----------------------------------------------------------------------------

ULONG SaComputeSize( VARTYPE vt,
                     SAFEARRAY & saSrc )
{
    //
    // get number of data elements in array and size of the header.
    //
    unsigned cDataElements = SaCountElements(saSrc);

    Win4Assert( 0 != saSrc.cDims );

    ULONG    cb = sizeof (SAFEARRAY) +
                  (saSrc.cDims-1) * sizeof (SAFEARRAYBOUND) +
                  cDataElements * saSrc.cbElements;

    cb = AlignBlock( cb, sizeof LONGLONG );

    switch (vt)
    {
    case VT_I4:
    case VT_UI1:
    case VT_I2:
    case VT_R4:
    case VT_R8:
    case VT_BOOL:
    case VT_ERROR:
    case VT_CY:
    case VT_DATE:
    case VT_I1:
    case VT_UI2:
    case VT_UI4:
    case VT_INT:
    case VT_UINT:
    case VT_DECIMAL:
        break;

    case VT_BSTR:
        {
            BSTR *pBstrSrc  = (BSTR *) saSrc.pvData;

            for ( unsigned i = 0; i < cDataElements; i++ )
            {
                Win4Assert( pBstrSrc[i]  != 0 );

                cb += AlignBlock( SysStringByteLen(pBstrSrc[i]) +
                                  sizeof ULONG + sizeof WCHAR,
                                  sizeof LONGLONG );
            }
        }
        break;

    case VT_VARIANT:
        {
            CAllocStorageVariant *pVarnt = (CAllocStorageVariant *)saSrc.pvData;

            for ( unsigned i = 0; i < cDataElements; i++ )
            {
                if ( VT_BSTR == pVarnt[i].vt )
                {
                    cb += AlignBlock( SysStringByteLen(pVarnt[i].bstrVal) +
                                      sizeof ULONG + sizeof WCHAR,
                                      sizeof LONGLONG );
                }
                else if ( 0 != (pVarnt[i].vt & VT_ARRAY) )
                {
                    cb += AlignBlock( SaComputeSize( (pVarnt[i].vt & ~VT_ARRAY),
                                                     *pVarnt[i].parray),
                                      sizeof LONGLONG );
                }
                else
                {
                    Win4Assert( pVarnt[i].vt != VT_VARIANT );
                }
            }
        }
        break;

    default:
        ciDebugOut(( DEB_ERROR, "Unexpected SafeArray type: vt=%x\n", vt ) );
        Win4Assert( !"Unexpected SafeArray Type" );
        return 1;
    }

    return cb;
}



CAllocStorageVariant::~CAllocStorageVariant()
{
    switch (vt)
    {
    case VT_EMPTY:
    case VT_NULL:
    case VT_I1:
    case VT_UI1:
    case VT_I2:
    case VT_UI2:
    case VT_BOOL:
    case VT_I4:
    case VT_UI4:
    case VT_R4:
    case VT_ERROR:
    case VT_I8:
    case VT_UI8:
    case VT_R8:
    case VT_INT:
    case VT_UINT:
    case VT_DECIMAL:
    case VT_CY:
    case VT_DATE:
    case VT_FILETIME:
        break;

    default:
        ciDebugOut(( DEB_ERROR, "~CAllocStorageVariant -- Memory Leak: vt=%x\n", vt ) );
    }
}


void
CAllocStorageVariant::ResetType(PMemoryAllocator &ma)
{
    // The most typical case

    if ( VT_EMPTY == vt )
        return;

    ULONG i;

    if ((vt & VT_BYREF) == 0)
    {
        switch (vt)
        {
        case VT_EMPTY:
        case VT_NULL:
        case VT_I1:
        case VT_UI1:
        case VT_I2:
        case VT_UI2:
        case VT_BOOL:
        case VT_I4:
        case VT_UI4:
        case VT_R4:
        case VT_ERROR:
        case VT_I8:
        case VT_UI8:
        case VT_R8:
        case VT_INT:
        case VT_UINT:
        case VT_DECIMAL:
        case VT_CY:
        case VT_DATE:
        case VT_FILETIME:
            break;

        case VT_CLSID:
            ma.Free(puuid);
            break;

        case VT_BLOB:
        case VT_BLOB_OBJECT:
            ma.Free(blob.pBlobData);
            break;

        case VT_CF:
            if (pclipdata != NULL)
            {
                ma.Free(pclipdata->pClipData);
                ma.Free(pclipdata);
            }
            break;

        case VT_STREAM:
        case VT_VERSIONED_STREAM:
        case VT_STREAMED_OBJECT:
            pStream->Release();
            break;

        case VT_STORAGE:
        case VT_STORED_OBJECT:
            pStorage->Release();
            break;

        case VT_BSTR:
            SysFreeString(bstrVal);
            break;

        case VT_LPSTR:
        case VT_LPWSTR:
            AssertStringField(pszVal);              // VT_LPSTR
            AssertStringField(pwszVal);             // VT_LPWSTR
            ma.Free(pwszVal);
            break;

        case VT_VECTOR | VT_I1:
        case VT_VECTOR | VT_UI1:
        case VT_VECTOR | VT_I2:
        case VT_VECTOR | VT_UI2:
        case VT_VECTOR | VT_BOOL:
        case VT_VECTOR | VT_I4:
        case VT_VECTOR | VT_UI4:
        case VT_VECTOR | VT_R4:
        case VT_VECTOR | VT_ERROR:
        case VT_VECTOR | VT_I8:
        case VT_VECTOR | VT_UI8:
        case VT_VECTOR | VT_R8:
        case VT_VECTOR | VT_CY:
        case VT_VECTOR | VT_DATE:
        case VT_VECTOR | VT_FILETIME:
        case VT_VECTOR | VT_CLSID:
            AssertByteVector(cac);                  // VT_I1
            AssertByteVector(caub);                 // VT_UI1
            AssertShortVector(cai);                 // VT_I2
            AssertShortVector(caui);                // VT_UI2
            AssertShortVector(cabool);              // VT_BOOL
            AssertLongVector(cal);                  // VT_I4
            AssertLongVector(caul);                 // VT_UI4
            AssertLongVector(caflt);                // VT_R4
            AssertLongVector(cascode);              // VT_ERROR
            AssertLongLongVector(cah);              // VT_I8
            AssertLongLongVector(cauh);             // VT_UI8
            AssertLongLongVector(cadbl);            // VT_R8
            AssertLongLongVector(cacy);             // VT_CY
            AssertLongLongVector(cadate);           // VT_DATE
            AssertLongLongVector(cafiletime);       // VT_FILETIME
            AssertVarVector(cauuid, sizeof(GUID));  // VT_CLSID
            ma.Free(cal.pElems);
            break;

        case VT_VECTOR | VT_CF:
            if (caclipdata.pElems != NULL)
            {
                for (i = 0; i < caclipdata.cElems; i++)
                {
                    ma.Free(caclipdata.pElems[i].pClipData);
                }
                ma.Free(caclipdata.pElems);
            }
            break;


        case VT_VECTOR | VT_LPSTR:
        case VT_VECTOR | VT_LPWSTR:
            AssertStringVector(calpwstr);                   // VT_LPWSTR
            AssertStringVector(calpstr);                    // VT_LPSTR
            if (calpwstr.pElems != NULL)
            {
                for (i = 0; i < calpwstr.cElems; i++)
                {
                    if (calpstr.pElems[i] != NULL)  // don't free (NULL - cbbstr)
                    {
                        ma.Free((BYTE *) calpstr.pElems[i] );
                    }
                }
                ma.Free(calpwstr.pElems);
            }
            break;

        case VT_VECTOR | VT_BSTR:

            AssertStringVector(cabstr);                     // VT_BSTR

            if (cabstr.pElems != NULL )
            {
                for (i = 0; i < cabstr.cElems; i++)
                {
                     SysFreeString(cabstr.pElems[i]);
                }
                ma.Free(cabstr.pElems);
            }
            break;

        case VT_VECTOR | VT_VARIANT:
            if (capropvar.pElems != NULL)
            {
                for (i = 0; i < calpstr.cElems; i++)
                {
                    ((CAllocStorageVariant *) &capropvar.pElems[i])->ResetType(ma);
                }
                ma.Free(capropvar.pElems);
            }
            break;

        case VT_ARRAY | VT_I4:
        case VT_ARRAY | VT_UI1:
        case VT_ARRAY | VT_I2:
        case VT_ARRAY | VT_R4:
        case VT_ARRAY | VT_R8:
        case VT_ARRAY | VT_BOOL:
        case VT_ARRAY | VT_ERROR:
        case VT_ARRAY | VT_CY:
        case VT_ARRAY | VT_DATE:
        case VT_ARRAY | VT_I1:
        case VT_ARRAY | VT_UI2:
        case VT_ARRAY | VT_UI4:
        case VT_ARRAY | VT_INT:
        case VT_ARRAY | VT_UINT:
        case VT_ARRAY | VT_DECIMAL:
        case VT_ARRAY | VT_BSTR:
        case VT_ARRAY | VT_VARIANT:
            {
                //
                // What should we do if the array is locked?
                // Perhaps just set cLocks to 0 so it can be freed.
                // Note that we never hit the assert below because
                // we deal with SafeArrays under our control so we
                // know they won't be locked.
                //

                if ( 0 != parray )
                {
                    Win4Assert( 0 == parray->cLocks );
                    HRESULT hr = SafeArrayDestroy( parray );
                    Win4Assert( S_OK == hr );
                }
                break;
            }

        default:
                Win4Assert( !" Unexpected VT type" );
        }
    }

    vt = VT_EMPTY;
}


// Invalid variants have a pointer type but a NULL pointer.
// Some are valid in this form in general, but not for many uses.

BOOL
CAllocStorageVariant::IsValid() const
{
    ULONG i;

    if ((VT_VECTOR & vt) && cal.cElems != 0 && cal.pElems == NULL)
    {
        return(FALSE);
    }
    switch (vt)
    {
        case VT_EMPTY:
        case VT_NULL:
        case VT_I1:
        case VT_UI1:
        case VT_I2:
        case VT_UI2:
        case VT_BOOL:
        case VT_I4:
        case VT_UI4:
        case VT_R4:
        case VT_ERROR:
        case VT_I8:
        case VT_UI8:
        case VT_INT:
        case VT_UINT:
        case VT_R8:
        case VT_CY:
        case VT_DATE:
        case VT_FILETIME:
            break;

        case VT_DECIMAL:
            return ( 0 == decVal.sign || DECIMAL_NEG == decVal.sign );

        case VT_CLSID:
            return(puuid != NULL);

        case VT_BLOB:
        case VT_BLOB_OBJECT:
            return(blob.cbSize == 0 || blob.pBlobData != NULL);

        case VT_CF:
            return(pclipdata != NULL && pclipdata->pClipData != NULL);

        case VT_STREAM:
        case VT_VERSIONED_STREAM:
        case VT_STREAMED_OBJECT:
            return(pStream != NULL);

        case VT_STORAGE:
        case VT_STORED_OBJECT:
            return(pStorage != NULL);

        case VT_BSTR:
        case VT_LPSTR:
        case VT_LPWSTR:
            AssertStringField(bstrVal);         // VT_BSTR
            AssertStringField(pszVal);          // VT_LPSTR
            AssertStringField(pwszVal);         // VT_LPWSTR
            return(pszVal != NULL);

        case VT_VECTOR | VT_I1:
        case VT_VECTOR | VT_UI1:
        case VT_VECTOR | VT_I2:
        case VT_VECTOR | VT_UI2:
        case VT_VECTOR | VT_BOOL:
        case VT_VECTOR | VT_I4:
        case VT_VECTOR | VT_UI4:
        case VT_VECTOR | VT_R4:
        case VT_VECTOR | VT_ERROR:
        case VT_VECTOR | VT_I8:
        case VT_VECTOR | VT_UI8:
        case VT_VECTOR | VT_R8:
        case VT_VECTOR | VT_CY:
        case VT_VECTOR | VT_DATE:
        case VT_VECTOR | VT_FILETIME:
        case VT_VECTOR | VT_CLSID:
            AssertByteVector(cac);              // VT_I1
            AssertByteVector(caub);             // VT_UI1
            AssertShortVector(cai);             // VT_I2
            AssertShortVector(caui);            // VT_UI2
            AssertShortVector(cabool);          // VT_BOOL
            AssertLongVector(cal);              // VT_I4
            AssertLongVector(caul);             // VT_UI4
            AssertLongVector(caflt);            // VT_R4
            AssertLongVector(cascode);          // VT_ERROR
            AssertLongLongVector(cah);          // VT_I8
            AssertLongLongVector(cauh);         // VT_UI8
            AssertLongLongVector(cadbl);        // VT_R8
            AssertLongLongVector(cacy);         // VT_CY
            AssertLongLongVector(cadate);       // VT_DATE
            AssertLongLongVector(cafiletime);   // VT_FILETIME
            AssertVarVector(cauuid, sizeof(GUID)); // VT_CLSID
            break;

        case VT_VECTOR | VT_CF:
            for (i = 0; i < caclipdata.cElems; i++)
            {
                if (caclipdata.pElems[i].pClipData == NULL)
                {
                    return(FALSE);
                }
            }

        case VT_VECTOR | VT_BSTR:
        case VT_VECTOR | VT_LPSTR:
        case VT_VECTOR | VT_LPWSTR:
            AssertStringVector(calpwstr);               // VT_LPWSTR
            AssertStringVector(cabstr);                 // VT_BSTR
            AssertStringVector(calpstr);                // VT_LPSTR
            for (i = 0; i < calpstr.cElems; i++)
            {
                if (calpstr.pElems[i] == NULL)
                {
                    return(FALSE);
                }
            }
            break;

        case VT_VECTOR | VT_VARIANT:
            for (i = 0; i < capropvar.cElems; i++)
            {
                if (!((CAllocStorageVariant *) &capropvar.pElems[i])->IsValid())
                {
                    return(FALSE);
                }
            }
            break;

        case VT_ARRAY | VT_I4:
        case VT_ARRAY | VT_UI1:
        case VT_ARRAY | VT_I2:
        case VT_ARRAY | VT_R4:
        case VT_ARRAY | VT_R8:
        case VT_ARRAY | VT_BOOL:
        case VT_ARRAY | VT_ERROR:
        case VT_ARRAY | VT_CY:
        case VT_ARRAY | VT_DATE:
        case VT_ARRAY | VT_I1:
        case VT_ARRAY | VT_UI2:
        case VT_ARRAY | VT_UI4:
        case VT_ARRAY | VT_INT:
        case VT_ARRAY | VT_UINT:
        case VT_ARRAY | VT_BSTR:
        case VT_ARRAY | VT_DECIMAL:
        case VT_ARRAY | VT_VARIANT:
             {
                SAFEARRAY *pSa = parray;

                if ( 0 == pSa )
                    return FALSE;

                if ( !(pSa->cDims && pSa->pvData) )
                    return FALSE;

                // validate all the bstrs are allocated

                if ( ( VT_BSTR | VT_ARRAY ) == vt )
                {
                    unsigned cDataElements = SaCountElements(*pSa);
                    BSTR *pBstr = (BSTR *)pSa->pvData;

                    for ( i = 0; i < cDataElements; i++ )
                        if ( 0 == pBstr[i] )
                            return FALSE;
                }
                if ( ( VT_VARIANT | VT_ARRAY ) == vt )
                {
                    unsigned cDataElements = SaCountElements(*pSa);
                    CAllocStorageVariant *pVarnt = (CAllocStorageVariant *)pSa->pvData;

                    for ( i = 0; i < cDataElements; i++ )
                        if ( ! pVarnt[i].IsValid() )
                            return FALSE;
                }
             }
             break;

        case VT_BYREF | VT_I2:
        case VT_BYREF | VT_I4:
        case VT_BYREF | VT_R4:
        case VT_BYREF | VT_R8:
        case VT_BYREF | VT_CY:
        case VT_BYREF | VT_DATE:
        case VT_BYREF | VT_ERROR:
        case VT_BYREF | VT_BOOL:
        case VT_BYREF | VT_I1:
        case VT_BYREF | VT_UI1:
        case VT_BYREF | VT_UI2:
        case VT_BYREF | VT_UI4:
        case VT_BYREF | VT_INT:
        case VT_BYREF | VT_UINT:
            return (piVal != 0);

        case VT_BYREF | VT_BSTR:
            return ( pbstrVal != 0 && *pbstrVal != 0 );

        case VT_BYREF | VT_DECIMAL:
            return ( pdecVal != 0 &&
                     ( 0 == pdecVal->sign || DECIMAL_NEG == pdecVal->sign ) );

        case VT_BYREF | VT_VARIANT:
            return ( pvarVal != 0 && pvarVal->vt != (VT_BYREF|VT_VARIANT) &&
                    ((CAllocStorageVariant*)pvarVal)->IsValid() );

        default:
            ASSERT(!"CAllocStorageVariant::IsValid -- Invalid variant type");
            return FALSE;
    }
    return TRUE;
}


CAllocStorageVariant::CAllocStorageVariant(
    PDeSerStream& stm,
    PMemoryAllocator &ma)
{
    Unmarshall(stm, *((PROPVARIANT *)this), ma);
}


#define VECTOR_SET_BODY(type, vtype, val, aval)                               \
                                                                              \
void CAllocStorageVariant::Set##vtype(                                        \
    type val,                                                                 \
    unsigned pos,                                                             \
    PMemoryAllocator &ma)                                                     \
{                                                                             \
    if (vt != ( VT_##vtype | VT_VECTOR ) )                                    \
    {                                                                         \
        ResetType(ma);                                                        \
        new (this) CAllocStorageVariant(VT_##vtype, pos, ma);                 \
    }                                                                         \
                                                                              \
    if (pos >= cai.cElems)                                                    \
    {                                                                         \
        type *pTemp = aval.pElems;                                            \
        aval.pElems = (type *) ma.Allocate( (pos+1) * sizeof(aval.pElems[0]));\
        if (aval.pElems != NULL)                                              \
        {                                                                     \
            memcpy(aval.pElems, pTemp, aval.cElems * sizeof(aval.pElems[0])); \
            memset(                                                           \
                &aval.pElems[aval.cElems],                                    \
                0,                                                            \
                (( pos+1 ) - aval.cElems) * sizeof(aval.pElems[0]));          \
            aval.pElems[pos] = val;                                           \
            aval.cElems = pos+1;                                              \
            ma.Free(pTemp);                                                   \
        }                                                                     \
    }                                                                         \
    else                                                                      \
    {                                                                         \
        aval.pElems[pos] = val;                                               \
    }                                                                         \
}


#define VECTOR_GET_BODY(type, vtype, aval, nullval)              \
                                                                 \
type CAllocStorageVariant::Get##vtype(unsigned pos) const        \
{                                                                \
    if (vt == (VT_##vtype | VT_VECTOR) && pos < aval.cElems)     \
    {                                                            \
        return(aval.pElems[pos]);                                \
    }                                                            \
    return(nullval);                                             \
}


VECTOR_SET_BODY(CHAR, I1, i, cac)
VECTOR_GET_BODY(CHAR, I1, cac, 0)

VECTOR_SET_BODY(BYTE, UI1, ui, caub)
VECTOR_GET_BODY(BYTE, UI1, caub, 0)

VECTOR_SET_BODY(short, I2, i, cai)
VECTOR_GET_BODY(short, I2, cai, 0)

VECTOR_SET_BODY(USHORT, UI2, ui, caui)
VECTOR_GET_BODY(USHORT, UI2, caui, 0)

VECTOR_SET_BODY(long, I4, l, cal)
VECTOR_GET_BODY(long, I4, cal, 0)

VECTOR_SET_BODY(ULONG, UI4, ul, caul)
VECTOR_GET_BODY(ULONG, UI4, caul, 0)

VECTOR_SET_BODY(SCODE, ERROR, scode, cascode)
VECTOR_GET_BODY(SCODE, ERROR, cascode, 0)

static LARGE_INTEGER const liZero = { 0, 0 };
VECTOR_SET_BODY(LARGE_INTEGER, I8, li, cah)
VECTOR_GET_BODY(LARGE_INTEGER, I8, cah, liZero)

static ULARGE_INTEGER const uliZero = { 0, 0 };
VECTOR_SET_BODY(ULARGE_INTEGER, UI8, uli, cauh)
VECTOR_GET_BODY(ULARGE_INTEGER, UI8, cauh, uliZero)

VECTOR_SET_BODY(float, R4, f, caflt)
VECTOR_GET_BODY(float, R4, caflt, (float)0.0)

VECTOR_SET_BODY(double, R8, d, cadbl)
VECTOR_GET_BODY(double, R8, cadbl, 0.0)

VECTOR_SET_BODY(VARIANT_BOOL, BOOL, b, cabool)
VECTOR_GET_BODY(VARIANT_BOOL, BOOL, cabool, FALSE)

static CY const cyZero = { 0, 0 };
VECTOR_SET_BODY(CY, CY, cy, cacy)
VECTOR_GET_BODY(CY, CY, cacy, cyZero)

VECTOR_SET_BODY(DATE, DATE, d, cadate)
VECTOR_GET_BODY(DATE, DATE, cadate, 0.0)


BOOLEAN
CAllocStorageVariant::_AddStringToVector(
    unsigned pos,
    VOID *pv,
    ULONG cb,
    PMemoryAllocator &ma)
{
    ASSERT(vt == (VT_VECTOR | VT_BSTR) ||
           vt == (VT_VECTOR | VT_LPSTR) ||
           vt == (VT_VECTOR | VT_LPWSTR));
    ASSERT(calpstr.pElems != NULL);

    if (pos >= calpstr.cElems)
    {
        char **ppsz = calpstr.pElems;

        calpstr.pElems =
            (char **) ma.Allocate((pos + 1) * sizeof(calpstr.pElems[0]));
        if (calpstr.pElems == NULL)
        {
            calpstr.pElems = ppsz;
            return(FALSE);
        }
        memcpy(calpstr.pElems, ppsz, calpstr.cElems * sizeof(calpstr.pElems[0]));
        memset(
            &calpstr.pElems[calpstr.cElems],
            0,
            ((pos + 1) - calpstr.cElems) * sizeof(calpstr.pElems[0]));
        calpstr.cElems = pos + 1;
        ma.Free(ppsz);
    }

    if ( vt == (VT_VECTOR|VT_BSTR) )
    {
        BSTR bstrVal = SysAllocString( (OLECHAR *)pv );

        if (bstrVal == NULL)
        {
            return (FALSE);
        }

        if ( cabstr.pElems[pos] != NULL )
        {
            SysFreeString(cabstr.pElems[pos]);
        }

        cabstr.pElems[pos] = bstrVal;
    }
    else
    {
        char *psz = (char *) ma.Allocate(cb);

        if (psz == NULL)
        {
            return(FALSE);
        }

        memcpy(psz, pv, cb);

        if (calpstr.pElems[pos] != NULL)
        {
            ma.Free(calpstr.pElems[pos]);
        }
        calpstr.pElems[pos] = psz;
    }

    return(TRUE);
}

void
CAllocStorageVariant::SetBSTR(BSTR b, PMemoryAllocator &ma)
{
    ResetType(ma);
    vt = VT_BSTR;

    bstrVal = SysAllocString(b);
}


void
CAllocStorageVariant::SetBSTR(
    BSTR b,
    unsigned pos,
    PMemoryAllocator &ma)
{
    if (vt != (VT_VECTOR | VT_BSTR))
    {
        ResetType(ma);
        new (this) CAllocStorageVariant(VT_BSTR, pos, ma);
    }

    _AddStringToVector(
                pos,
                b,
                -1,    // not used, pass an invalid value to detect failure.
                ma);
}


void
CAllocStorageVariant::SetLPSTR(
    char const *psz,
    unsigned pos,
    PMemoryAllocator &ma)
{
    if (vt != (VT_VECTOR | VT_LPSTR))
    {
        ResetType(ma);
        new (this) CAllocStorageVariant(VT_LPSTR, pos, ma);
    }
    _AddStringToVector(pos, (VOID *) psz, strlen(psz) + 1, ma);
}


void
CAllocStorageVariant::SetLPWSTR(
    WCHAR const *pwsz,
    unsigned pos,
    PMemoryAllocator &ma)
{
    if (vt != (VT_VECTOR | VT_LPWSTR))
    {
        ResetType(ma);
        new (this) CAllocStorageVariant(VT_LPWSTR, pos, ma);
    }
    _AddStringToVector(
                pos,
                (VOID *) pwsz,
                (wcslen(pwsz) + 1) * sizeof(WCHAR),
                ma);
}


VECTOR_GET_BODY(char *, LPSTR, calpstr, 0);
VECTOR_GET_BODY(WCHAR *, LPWSTR, calpwstr, 0);

static FILETIME const fiZero = { 0, 0 };
VECTOR_SET_BODY(FILETIME, FILETIME, ft, cafiletime)
VECTOR_GET_BODY(FILETIME, FILETIME, cafiletime, fiZero)

static CLSID const guidZero =
{
    0x00000000,
    0x0000,
    0x0000,
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
};

VECTOR_SET_BODY(CLSID, CLSID, c, cauuid)
VECTOR_GET_BODY(CLSID, CLSID, cauuid, guidZero)
#endif //ifndef _NTDLLBUILD_