able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/ole32/stg/props/stgvarb.cxx

1161 lines
30 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1992.
//
// File: StgVarB.cxx
//
// Contents: C++ Base wrapper for PROPVARIANT.
//
// History: 01-Aug-94 KyleP Created
// 31-Jul-96 MikeHill - Relaxed assert in IsUnicodeString.
// - Allow NULL strings.
//
//--------------------------------------------------------------------------
#include <pch.cxx>
#include "debtrace.hxx"
#include <propset.h>
#include <propvar.h>
// These optionally-compiled directives tell the compiler & debugger
// where the real file, rather than the copy, is located.
#ifdef _ORIG_FILE_LOCATION_
#if __LINE__ != 25
#error File heading has change size
#else
#line 29 "\\nt\\private\\dcomidl\\stgvarb.cxx"
#endif
#endif
#if DBGPROP
BOOLEAN
IsUnicodeString(WCHAR const *pwszname, ULONG cb)
{
if (cb != 0)
{
for (ULONG i = 0; pwszname[i] != L'\0'; i++)
{
}
// If cb isn't MAXULONG we verify that cb is at least as
// big as the string. We can't check for equality, because
// there are some property sets in which the length field
// for a string may include several zero padding bytes.
PROPASSERT(cb == MAXULONG || (i + 1) * sizeof(WCHAR) <= cb);
}
return(TRUE);
}
BOOLEAN
IsAnsiString(CHAR const *pszname, ULONG cb)
{
if (cb != 0)
{
// If the string is NULL, then it's not not an Ansi string,
// so we'll call it an Ansi string.
if( NULL == pszname )
return( TRUE );
for (ULONG i = 0; pszname[i] != '\0'; i++)
{
}
// If cb isn't MAXULONG we verify that cb is at least as
// big as the string. We can't check for equality, because
// there are some property sets in which the length field
// for a string may include several zero padding bytes.
PROPASSERT(cb == MAXULONG || i + 1 <= cb);
}
return(TRUE);
}
#endif
//+-------------------------------------------------------------------
// Member: CBaseStorageVariant::UnmarshalledSize, public
//
// Synopsis: Unmarshalls a PROPVARIANT value serialized in a PDeSerStream.
//
// Arguments: [stm] -- serialized stream
// [cb] -- size of *additional* data goes here. Size of
// base PROPVARIANT not included.
//
// Returns: one of the following NTSTATUS values
// STATUS_SUCCESS -- the call was successful.
// STATUS_INVALID_PARAMETER -- unsupported type for unmarshalling.
//
// Notes: The size is computed assuming 4-byte granular allocations.
//
//--------------------------------------------------------------------
#if defined(WINNT) && !defined(IPROPERTY_DLL)
#ifdef KERNEL
NTSTATUS
CBaseStorageVariant::UnmarshalledSize(
PDeSerStream& stm,
ULONG &cb)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG cElems = 0;
ULONG i;
cb = 0;
VARTYPE vt = (VARTYPE) stm.GetULong();
switch (vt)
{
case VT_EMPTY:
case VT_NULL:
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_CY:
case VT_DATE:
case VT_FILETIME:
break;
case VT_CLSID:
cb = sizeof(GUID);
break;
case VT_BLOB:
case VT_BLOB_OBJECT:
cb = stm.GetULong();
break;
case VT_CF:
cb = stm.GetULong() + sizeof(CLIPDATA);
break;
case VT_STREAM:
case VT_STREAMED_OBJECT:
PROPASSERT("Serialization of stream not yet supported!");
Status = STATUS_INVALID_PARAMETER;
break;
case VT_STORAGE:
case VT_STORED_OBJECT:
PROPASSERT("Serialization of storage not yet supported!");
Status = STATUS_INVALID_PARAMETER;
break;
case VT_BSTR:
cb = sizeof(ULONG) + stm.GetULong();
break;
case VT_LPSTR:
cb = stm.GetULong();
break;
case VT_LPWSTR:
cb = stm.GetULong() * sizeof(WCHAR);
break;
case VT_VECTOR | VT_UI1:
cb = stm.GetULong();
break;
case VT_VECTOR | VT_I2:
case VT_VECTOR | VT_UI2:
case VT_VECTOR | VT_BOOL:
cb = stm.GetULong() * sizeof(SHORT);
break;
case VT_VECTOR | VT_I4:
case VT_VECTOR | VT_UI4:
case VT_VECTOR | VT_R4:
case VT_VECTOR | VT_ERROR:
cb = stm.GetULong() * sizeof(LONG);
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:
cb = stm.GetULong() * sizeof(LARGE_INTEGER);
break;
case VT_VECTOR | VT_CLSID:
cb = stm.GetULong() * sizeof(GUID);
break;
case VT_VECTOR | VT_CF:
cElems = stm.GetULong();
cb = cElems * sizeof(CLIPDATA);
break;
case VT_VECTOR | VT_BSTR:
cElems = stm.GetULong();
cb = cElems * (sizeof(ULONG) + sizeof(LPSTR));
break;
case VT_VECTOR | VT_LPSTR:
cElems = stm.GetULong();
cb = cElems * sizeof(LPSTR);
break;
case VT_VECTOR | VT_LPWSTR:
cElems = stm.GetULong();
cb = cElems * sizeof(LPWSTR);
break;
case VT_VECTOR | VT_VARIANT:
cElems = stm.GetULong();
cb = cElems * sizeof(PROPVARIANT);
break;
default:
PROPASSERT(!"Invalid type for PROPVARIANT marshalling");
Status = STATUS_INVALID_PARAMETER;
break;
}
cb = (cb + 3) & ~3;
if (cElems == 0 || Status != STATUS_SUCCESS)
{
return(Status);
}
// We have a variant with variable sized data which requires
// further unmarshalling.
switch(vt)
{
case VT_VECTOR | VT_CF:
for (i = 0; i < cElems; i++)
{
ULONG len = (stm.GetULong() + 3) & ~3;
cb += len;
stm.SkipChar(sizeof(ULONG) + len);
}
break;
case VT_VECTOR | VT_BSTR:
case VT_VECTOR | VT_LPSTR:
for (i = 0; i < cElems; i++)
{
ULONG len = (stm.GetULong() + 3) & ~3;
cb += len;
stm.SkipChar(len);
}
break;
case VT_VECTOR | VT_LPWSTR:
for (i = 0; i < cElems; i++)
{
ULONG len = (stm.GetULong() * sizeof(WCHAR) + 3) & ~3;
cb += len;
stm.SkipWChar(len / sizeof(WCHAR));
}
break;
case VT_VECTOR | VT_VARIANT:
for (i = 0; i < cElems; i++)
{
ULONG cbElem = 0;
Status = CBaseStorageVariant::UnmarshalledSize(stm, cbElem);
if (Status != STATUS_SUCCESS)
{
break;
}
cb += cbElem;
}
break;
}
return(Status);
}
#endif //ifdef KERNEL
//+-------------------------------------------------------------------
// Member: CBaseStorageVariant::Unmarshall, public
//
// Synopsis: Unmarshalls a PROPVARIANT value serialized in a PDeSerStream.
//
// Arguments: [stm] -- serialized stream
// [var] -- unmarshalled PROPVARIANT instance
// [MemAlloc] -- memory allocator for unmarshalling
//
// Returns: one of the following NTSTATUS values
// STATUS_SUCCESS -- the call was successful.
// STATUS_INSUFFICIENT_RESOURCES -- out of memory.
// STATUS_INVALID_PARAMETER -- unsupported type for unmarshalling.
//--------------------------------------------------------------------
NTSTATUS
CBaseStorageVariant::Unmarshall(
PDeSerStream& stm,
PROPVARIANT& var,
PMemoryAllocator &MemAlloc)
{
#if DBG
switch (stm.PeekULong())
{
case VT_EMPTY:
case VT_NULL:
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_CY:
case VT_DATE:
case VT_FILETIME:
case VT_CLSID:
case VT_BLOB:
case VT_BLOB_OBJECT:
case VT_CF:
case VT_STREAM:
case VT_STREAMED_OBJECT:
case VT_STORAGE:
case VT_STORED_OBJECT:
case VT_BSTR:
case VT_LPSTR:
case VT_LPWSTR:
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:
case VT_VECTOR | VT_CF:
case VT_VECTOR | VT_BSTR:
case VT_VECTOR | VT_LPSTR:
case VT_VECTOR | VT_LPWSTR:
case VT_VECTOR | VT_VARIANT:
break;
default:
PROPASSERT(!"Invalid type (peek) for PROPVARIANT unmarshalling");
break;
}
#endif
NTSTATUS Status = STATUS_SUCCESS;
ULONG cbAlloc = 0;
VOID **ppv = NULL;
BOOLEAN fZero = FALSE;
// Zero the entire variant data structure before assembling it together.
memset(&var, 0, sizeof(PROPVARIANT));
var.vt = (VARTYPE) stm.GetULong();
switch (var.vt)
{
case VT_EMPTY:
case VT_NULL:
break;
case VT_UI1:
var.bVal = stm.GetByte();
break;
case VT_I2:
case VT_UI2:
case VT_BOOL:
var.iVal = stm.GetUShort();
break;
case VT_I4:
case VT_UI4:
case VT_R4:
case VT_ERROR:
var.lVal = stm.GetULong();
break;
case VT_I8:
case VT_UI8:
case VT_R8:
case VT_CY:
case VT_DATE:
case VT_FILETIME:
stm.GetBlob((BYTE *)&var.hVal, sizeof(LARGE_INTEGER));
break;
case VT_CLSID:
cbAlloc = sizeof(GUID);
ppv = (void **)&var.puuid;
break;
case VT_BLOB:
case VT_BLOB_OBJECT:
var.blob.cbSize = stm.GetULong();
cbAlloc = var.blob.cbSize;
ppv = (void **)&var.blob.pBlobData;
break;
case VT_CF:
var.pclipdata = (CLIPDATA *) MemAlloc.Allocate(sizeof(*var.pclipdata));
if (var.pclipdata == NULL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
var.pclipdata->cbSize = stm.GetULong();
cbAlloc = CBPCLIPDATA(*var.pclipdata);
var.pclipdata->ulClipFmt = stm.GetULong();
ppv = (void **) &var.pclipdata->pClipData;
break;
case VT_STREAM:
case VT_STREAMED_OBJECT:
PROPASSERT("Serialization of stream not yet supported!");
Status = STATUS_INVALID_PARAMETER;
break;
case VT_STORAGE:
case VT_STORED_OBJECT:
PROPASSERT("Serialization of storage not yet supported!");
Status = STATUS_INVALID_PARAMETER;
break;
case VT_BSTR:
cbAlloc = sizeof(ULONG) + stm.GetULong();
ppv = (void **)&var.bstrVal;
break;
case VT_LPSTR:
cbAlloc = stm.GetULong();
ppv = (void **)&var.pszVal;
break;
case VT_LPWSTR:
cbAlloc = stm.GetULong() * sizeof(WCHAR);
ppv = (void **)&var.pwszVal;
break;
case VT_VECTOR | VT_UI1:
var.caub.cElems = stm.GetULong();
cbAlloc = var.caub.cElems * sizeof(BYTE);
ppv = (void **)&var.caub.pElems;
break;
case VT_VECTOR | VT_I2:
case VT_VECTOR | VT_UI2:
case VT_VECTOR | VT_BOOL:
var.cai.cElems = stm.GetULong();
cbAlloc = var.cai.cElems * sizeof(SHORT);
ppv = (void **)&var.cai.pElems;
break;
case VT_VECTOR | VT_I4:
case VT_VECTOR | VT_UI4:
case VT_VECTOR | VT_R4:
case VT_VECTOR | VT_ERROR:
var.cal.cElems = stm.GetULong();
cbAlloc = var.cal.cElems * sizeof(LONG);
ppv = (void **)&var.cal.pElems;
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:
var.cah.cElems = stm.GetULong();
cbAlloc = var.cah.cElems * sizeof(LARGE_INTEGER);
ppv = (void **)&var.cah.pElems;
break;
case VT_VECTOR | VT_CLSID:
var.cauuid.cElems = stm.GetULong();
cbAlloc = var.cauuid.cElems * sizeof(GUID);
ppv = (void **)&var.cauuid.pElems;
break;
case VT_VECTOR | VT_CF:
var.caclipdata.cElems = stm.GetULong();
cbAlloc = var.caclipdata.cElems * sizeof(CLIPDATA);
ppv = (void **)&var.caclipdata.pElems;
fZero = TRUE; // set all pClipData pointers to NULL
break;
case VT_VECTOR | VT_BSTR:
var.cabstr.cElems = stm.GetULong();
cbAlloc = var.cabstr.cElems * sizeof(BSTR);
ppv = (void **)&var.cabstr.pElems;
fZero = TRUE; // set all BSTR pointers to NULL
break;
case VT_VECTOR | VT_LPSTR:
var.calpstr.cElems = stm.GetULong();
cbAlloc = var.calpstr.cElems * sizeof(LPSTR);
ppv = (void **)&var.calpstr.pElems;
fZero = TRUE; // set all LPSTR pointers to NULL
break;
case VT_VECTOR | VT_LPWSTR:
var.calpwstr.cElems = stm.GetULong();
cbAlloc = var.calpwstr.cElems * sizeof(LPWSTR);
ppv = (void **)&var.calpwstr.pElems;
fZero = TRUE; // set all LPWSTR pointers to NULL
break;
case VT_VECTOR | VT_VARIANT:
var.capropvar.cElems = stm.GetULong();
cbAlloc = var.capropvar.cElems * sizeof(PROPVARIANT);
ppv = (void **)&var.capropvar.pElems;
fZero = TRUE; // set all vt pointers to VT_EMPTY
PROPASSERT(VT_EMPTY == 0);
break;
default:
PROPASSERT(!"Invalid type for PROPVARIANT unmarshalling");
Status = STATUS_INVALID_PARAMETER;
break;
}
if (cbAlloc == 0 || Status != STATUS_SUCCESS)
{
// No further work need be done. The Ummarshalling is complete,
// i.e., fixed size variant or no variable length data.
if (ppv != NULL)
{
*ppv = NULL;
}
return(Status);
}
// Allocate the desired amount of memory and continue unmarshalling
// if allocation was successfull.
ULONG i;
PROPASSERT(ppv != NULL);
*ppv = MemAlloc.Allocate(cbAlloc);
if (*ppv == NULL)
{
return(STATUS_INSUFFICIENT_RESOURCES);
}
if (fZero)
{
memset(*ppv, 0, cbAlloc);
}
// We have a variant with variable sized data which requires
// further unmarshalling.
switch(var.vt)
{
case VT_CLSID:
stm.GetBlob((BYTE *)var.puuid, sizeof(CLSID));
break;
case VT_BLOB:
case VT_BLOB_OBJECT:
stm.GetBlob(var.blob.pBlobData, var.blob.cbSize);
break;
case VT_CF:
stm.GetBlob(var.pclipdata->pClipData, CBPCLIPDATA(*var.pclipdata));
break;
case VT_BSTR:
cbAlloc -= sizeof(ULONG);
*(ULONG *) var.bstrVal = cbAlloc - sizeof (OLECHAR);
var.bstrVal = (BSTR) ((ULONG *) var.bstrVal + 1);
stm.GetChar((char *) var.bstrVal, cbAlloc);
break;
case VT_LPSTR:
stm.GetChar(var.pszVal, cbAlloc);
break;
case VT_LPWSTR:
stm.GetWChar(var.pwszVal, cbAlloc / sizeof(WCHAR));
break;
case VT_VECTOR | VT_UI1:
for (i = 0; i < var.caub.cElems; i++)
{
var.caub.pElems[i] = stm.GetByte();
}
break;
case VT_VECTOR | VT_I2:
case VT_VECTOR | VT_UI2:
case VT_VECTOR | VT_BOOL:
for (i = 0; i < var.cai.cElems; i++)
{
var.cai.pElems[i] = stm.GetUShort();
}
break;
case VT_VECTOR | VT_I4:
case VT_VECTOR | VT_UI4:
case VT_VECTOR | VT_R4:
case VT_VECTOR | VT_ERROR:
for (i = 0; i < var.cal.cElems; i++)
{
var.cal.pElems[i] = stm.GetULong();
}
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:
for (i = 0; i < var.cah.cElems; i++)
{
stm.GetBlob((BYTE *)&var.cah.pElems[i], sizeof(LARGE_INTEGER));
}
break;
case VT_VECTOR | VT_CLSID:
for (i = 0; i < var.cauuid.cElems; i++)
{
stm.GetBlob((BYTE *)&var.cauuid.pElems[i], sizeof(CLSID));
}
break;
case VT_VECTOR | VT_CF:
for (i = 0; i < var.caclipdata.cElems; i++)
{
PROPASSERT(var.caclipdata.pElems[i].pClipData == NULL);
var.caclipdata.pElems[i].cbSize = stm.GetULong();
cbAlloc = CBPCLIPDATA(var.caclipdata.pElems[i]);
var.caclipdata.pElems[i].ulClipFmt = stm.GetULong();
if (cbAlloc == 0)
{
Status = STATUS_INVALID_PARAMETER;
break;
}
var.caclipdata.pElems[i].pClipData =
(BYTE *) MemAlloc.Allocate(cbAlloc);
if (var.caclipdata.pElems[i].pClipData == NULL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
stm.GetBlob(var.caclipdata.pElems[i].pClipData, cbAlloc);
}
break;
case VT_VECTOR | VT_BSTR:
for (i = 0; i < var.cabstr.cElems; i++)
{
PROPASSERT(var.cabstr.pElems[i] == NULL);
cbAlloc = stm.GetULong();
if (cbAlloc == 0)
{
Status = STATUS_INVALID_PARAMETER;
break;
}
var.cabstr.pElems[i] =
(BSTR) MemAlloc.Allocate(sizeof(ULONG) + cbAlloc);
if (var.cabstr.pElems[i] == NULL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
*(ULONG *) var.cabstr.pElems[i] = cbAlloc - sizeof (OLECHAR);
var.cabstr.pElems[i] = (BSTR) ((ULONG *) var.cabstr.pElems[i] + 1);
stm.GetChar((char *) var.cabstr.pElems[i], cbAlloc);
}
break;
case VT_VECTOR | VT_LPSTR:
for (i = 0; i < var.calpstr.cElems; i++)
{
PROPASSERT(var.calpstr.pElems[i] == NULL);
cbAlloc = stm.GetULong();
if (cbAlloc == 0)
{
Status = STATUS_INVALID_PARAMETER;
break;
}
var.calpstr.pElems[i] = (LPSTR) MemAlloc.Allocate(cbAlloc);
if (var.calpstr.pElems[i] == NULL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
stm.GetChar(var.calpstr.pElems[i], cbAlloc);
}
break;
case VT_VECTOR | VT_LPWSTR:
for (i = 0; i < var.calpwstr.cElems; i++)
{
PROPASSERT(var.calpwstr.pElems[i] == NULL);
cbAlloc = stm.GetULong(); // actually, a count of WCHARs
if (cbAlloc == 0)
{
Status = STATUS_INVALID_PARAMETER;
break;
}
var.calpwstr.pElems[i] = (WCHAR *) MemAlloc.Allocate(cbAlloc * sizeof(WCHAR));
if (var.calpwstr.pElems[i] == NULL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
stm.GetWChar(var.calpwstr.pElems[i], cbAlloc);
}
break;
case VT_VECTOR | VT_VARIANT:
for (i = 0; i < var.capropvar.cElems; i++)
{
PROPASSERT(var.capropvar.pElems[i].vt == VT_EMPTY);
Status = CBaseStorageVariant::Unmarshall(
stm,
var.capropvar.pElems[i],
MemAlloc);
if (Status != STATUS_SUCCESS)
{
break;
}
}
break;
}
return(Status);
}
#ifdef ENABLE_MARSHAL_VARIANT
inline void
_Marshall_VT_CF(CLIPDATA *pclipdata, PSerStream &stm)
{
CLIPDATA clipdata;
clipdata.cbSize = 0;
clipdata.ulClipFmt = 0;
if (pclipdata != NULL)
{
clipdata.cbSize = pclipdata->cbSize;
clipdata.ulClipFmt = pclipdata->ulClipFmt;
if (pclipdata->pClipData == NULL)
{
clipdata.cbSize = 0;
}
}
stm.PutULong(clipdata.cbSize);
stm.PutULong(clipdata.ulClipFmt);
if (clipdata.cbSize)
{
stm.PutBlob((BYTE *) pclipdata->pClipData, CBPCLIPDATA(clipdata));
}
}
#endif //ifdef ENABLE_MARSHAL_VARIANT
#ifdef ENABLE_MARSHAL_VARIANT
inline void
_Marshall_VT_BSTR(BSTR bstrVal, PSerStream &stm)
{
if (bstrVal != NULL)
{
ULONG cc = BSTRLEN(bstrVal) + sizeof (OLECHAR);
stm.PutULong(cc);
stm.PutChar((char *) bstrVal, cc);
}
else
{
stm.PutULong(0);
}
}
#endif //ifdef ENABLE_MARSHAL_VARIANT
#ifdef ENABLE_MARSHAL_VARIANT
inline void
_Marshall_VT_LPSTR(CHAR *pszVal, PSerStream &stm)
{
if (pszVal != NULL)
{
// Include NULL because OLE 2.0 spec says so.
ULONG cc = strlen(pszVal) + 1;
stm.PutULong(cc);
stm.PutChar(pszVal, cc);
PROPASSERT(IsAnsiString(pszVal, cc));
}
else
{
stm.PutULong(0);
}
}
#endif //ifdef ENABLE_MARSHAL_VARIANT
#ifdef ENABLE_MARSHAL_VARIANT
inline void
_Marshall_VT_LPWSTR(LPWSTR pwszVal, PSerStream &stm)
{
if (pwszVal != NULL)
{
// Include NULL because OLE 2.0 spec says so.
ULONG cc = Prop_wcslen(pwszVal) + 1;
PROPASSERT(IsUnicodeString(pwszVal, cc * sizeof(WCHAR)));
stm.PutULong(cc);
stm.PutWChar(pwszVal, cc);
}
else
{
stm.PutULong(0);
}
}
#endif //ifdef ENABLE_MARSHAL_VARIANT
#ifdef ENABLE_MARSHAL_VARIANT
void
CBaseStorageVariant::Marshall(PSerStream & stm) const
{
ULONG i;
stm.PutULong(vt);
switch (vt)
{
case VT_EMPTY:
case VT_NULL:
break;
case VT_UI1:
stm.PutByte(bVal);
break;
case VT_I2:
case VT_UI2:
case VT_BOOL:
stm.PutUShort(iVal);
break;
case VT_I4:
case VT_UI4:
case VT_R4:
case VT_ERROR:
stm.PutULong(lVal);
break;
case VT_I8:
case VT_UI8:
case VT_R8:
case VT_CY:
case VT_DATE:
case VT_FILETIME:
stm.PutBlob((BYTE *) &hVal, sizeof(hVal));
break;
case VT_CLSID:
stm.PutBlob((BYTE *)puuid, sizeof(CLSID));
break;
case VT_BLOB:
case VT_BLOB_OBJECT:
stm.PutULong(blob.cbSize);
stm.PutBlob(blob.pBlobData, blob.cbSize);
break;
case VT_CF:
_Marshall_VT_CF(pclipdata, stm);
break;
case VT_STREAM:
case VT_STREAMED_OBJECT:
PROPASSERT("Serialization of stream not yet supported!");
break;
case VT_STORAGE:
case VT_STORED_OBJECT:
PROPASSERT("Serialization of storage not yet supported!");
break;
case VT_BSTR:
_Marshall_VT_BSTR(bstrVal, stm);
break;
case VT_LPSTR:
_Marshall_VT_LPSTR(pszVal, stm);
break;
case VT_LPWSTR:
_Marshall_VT_LPWSTR(pwszVal, stm);
break;
case VT_VECTOR | VT_UI1:
stm.PutULong(caub.cElems);
for (i = 0; i < caub.cElems; i++)
{
stm.PutByte(caub.pElems[i]);
}
break;
case VT_VECTOR | VT_I2:
case VT_VECTOR | VT_UI2:
case VT_VECTOR | VT_BOOL:
stm.PutULong(cai.cElems);
for (i = 0; i < cai.cElems; i++)
{
stm.PutUShort(cai.pElems[i]);
}
break;
case VT_VECTOR | VT_I4:
case VT_VECTOR | VT_UI4:
case VT_VECTOR | VT_R4:
case VT_VECTOR | VT_ERROR:
stm.PutULong(cal.cElems);
for (i = 0; i < cal.cElems; i++)
{
stm.PutULong(cal.pElems[i]);
}
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:
stm.PutULong(cah.cElems);
for (i = 0; i < cah.cElems; i++)
{
stm.PutBlob((BYTE *) &cah.pElems[i], sizeof(LARGE_INTEGER));
}
break;
case VT_VECTOR | VT_CLSID:
stm.PutULong(cauuid.cElems);
for (i = 0; i < cauuid.cElems; i++)
{
stm.PutBlob((BYTE *)&cauuid.pElems[i], sizeof(CLSID));
}
break;
case VT_VECTOR | VT_CF:
stm.PutULong(caclipdata.cElems);
for (i = 0; i < caclipdata.cElems; i++)
{
_Marshall_VT_CF(&caclipdata.pElems[i], stm);
}
break;
break;
case VT_VECTOR | VT_BSTR:
stm.PutULong(cabstr.cElems);
for (i = 0; i < cabstr.cElems; i++)
{
_Marshall_VT_BSTR(cabstr.pElems[i], stm);
}
break;
case VT_VECTOR | VT_LPSTR:
stm.PutULong(calpstr.cElems);
for (i = 0; i < calpstr.cElems; i++)
{
_Marshall_VT_LPSTR(calpstr.pElems[i], stm);
}
break;
case VT_VECTOR | VT_LPWSTR:
stm.PutULong(calpwstr.cElems);
for (i = 0; i < calpwstr.cElems; i++)
{
_Marshall_VT_LPWSTR(calpwstr.pElems[i], stm);
}
break;
case VT_VECTOR | VT_VARIANT:
stm.PutULong(capropvar.cElems);
for (i = 0; i < capropvar.cElems; i++)
{
((CBaseStorageVariant *) &capropvar.pElems[i])->Marshall(stm);
}
break;
default:
PROPASSERT(!"Invalid type for PROPVARIANT marshalling");
break;
}
}
#endif //ifdef ENABLE_MARSHAL_VARIANT
#ifdef OLDSUMCATAPI
void
MarshallVariant(PSerStream &stm, PROPVARIANT &stgvar)
{
CBaseStorageVariant *pstgvar = (CBaseStorageVariant *)&stgvar;
pstgvar->Marshall(stm);
}
#endif //ifdef OLDSUMCATAPI
#ifdef ENABLE_DISPLAY_VARIANT
VOID
CBaseStorageVariant::DisplayVariant(
ULONG ulLevel,
USHORT CodePage) const
{
char *psz;
switch (vt)
{
case VT_ILLEGAL: psz = "ILLEGAL"; goto EmptyType;
case VT_EMPTY: psz = "EMPTY"; goto EmptyType;
case VT_NULL: psz = "NULL"; goto EmptyType;
BlobType:
EmptyType:
DEBTRACE((DBGFLAG "%s", psz));
break;
case VT_UI1:
AssertByteField(bVal); // VT_UI1
DEBTRACE((DBGFLAG "UI1=%hx", bVal));
break;
case VT_I2: psz = "I2"; goto ShortType;
case VT_UI2: psz = "UI2"; goto ShortType;
ShortType:
AssertShortField(iVal); // VT_I2
AssertShortField(uiVal); // VT_UI2
DEBTRACE((DBGFLAG "%s=%hx", psz, iVal));
break;
case VT_BOOL:
switch (boolVal)
{
case VARIANT_TRUE:
DEBTRACE((DBGFLAG "BOOL=TRUE"));
break;
case FALSE:
DEBTRACE((DBGFLAG "BOOL=FALSE"));
break;
default:
DEBTRACE((DBGFLAG "BOOL=%hx???", boolVal));
break;
}
break;
case VT_I4: psz = "I4"; goto LongType;
case VT_UI4: psz = "UI4"; goto LongType;
case VT_R4: psz = "R4"; goto LongType;
case VT_ERROR: psz = "ERROR"; goto LongType;
LongType:
AssertLongField(lVal); // VT_I4
AssertLongField(ulVal); // VT_UI4
AssertLongField(fltVal); // VT_R4
AssertLongField(scode); // VT_ERROR
DEBTRACE((DBGFLAG "%s=%x", psz, lVal));
break;
case VT_I8: psz = "I8"; goto LongLongType;
case VT_UI8: psz = "UI8"; goto LongLongType;
case VT_R8: psz = "R8"; goto LongLongType;
case VT_CY: psz = "CY"; goto LongLongType;
case VT_DATE: psz = "DATE"; goto LongLongType;
case VT_FILETIME: psz = "FILETIME"; goto LongLongType;
LongLongType:
AssertLongLongField(hVal); // VT_I8
AssertLongLongField(uhVal); // VT_UI8
AssertLongLongField(dblVal); // VT_R8
AssertLongLongField(cyVal); // VT_CY
AssertLongLongField(date); // VT_DATE
AssertLongLongField(filetime); // VT_FILETIME
DEBTRACE((DBGFLAG "%s=%x:%x", psz, hVal.HighPart, hVal.LowPart));
break;
case VT_CLSID: psz = "CLSID"; goto EmptyType;
case VT_BLOB: psz = "BLOB"; goto BlobType;
case VT_BLOB_OBJECT: psz = "BLOB_OBJECT"; goto BlobType;
case VT_CF: psz = "CF"; goto BlobType;
case VT_STREAM: psz = "STREAM"; goto TestUnicode;
case VT_STREAMED_OBJECT: psz = "STREAMED_OBJECT"; goto TestUnicode;
case VT_STORAGE: psz = "STORAGE"; goto TestUnicode;
case VT_STORED_OBJECT: psz = "STORED_OBJECT"; goto TestUnicode;
case VT_LPSTR: psz = "LPSTR"; goto TestUnicode;
TestUnicode:
AssertStringField(pszVal); // VT_STREAM, VT_STREAMED_OBJECT
AssertStringField(pszVal); // VT_STORAGE, VT_STORED_OBJECT
AssertStringField(pszVal); // VT_LPSTR
DEBTRACE((
DBGFLAG
CodePage == CP_WINUNICODE? "%s=L'%ws'" : "%s='%s'",
psz,
pszVal));
break;
case VT_BSTR: psz = "BSTR"; goto PrintUnicode;
case VT_LPWSTR: psz = "LPWSTR"; goto PrintUnicode;
PrintUnicode:
AssertStringField(pwszVal); // VT_LPWSTR
AssertStringField(bstrVal); // VT_BSTR
DEBTRACE((DBGFLAG "%s=L'%ws'", psz, pwszVal));
break;
default:
if (vt & VT_VECTOR)
{
DEBTRACE((DBGFLAG "UNPRINTABLE VECTOR TYPE=%x(%u)", vt, vt));
}
else
{
DEBTRACE((DBGFLAG "UNKNOWN TYPE=%x(%u)", vt, vt));
}
break;
}
}
#endif //ifdef ENABLE_DISPLAY_VARIANT
#endif //ifdef WINNT
Reference in a new issue Copy permalink