mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
331 lines
8.1 KiB
331 lines
8.1 KiB
/*++
|
|
|
|
Copyright (C) 1995-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
DATACONV.CPP
|
|
|
|
Abstract:
|
|
|
|
Provides a some generic data conversion routines. In particular,
|
|
OMSVariantChangeType and OMSVariantClear provide the same
|
|
capabilities as the Ole VariantChangeType and VariantClear
|
|
functions except that the OMS versions handle more data types.
|
|
|
|
History:
|
|
|
|
a-davj 19-Oct-95 Created.
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
|
|
#include "resource.h"
|
|
#include "CVariant.h"
|
|
#include <ole2.h>
|
|
|
|
|
|
//***************************************************************************
|
|
//
|
|
// char * WideToNarrow
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Takes a WCHAR string and creates a MBS equivalent. The caller should
|
|
// free the string when done.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// pConv UNICODE string to convert.
|
|
//
|
|
// RETURN VALUE:
|
|
//
|
|
// NULL if out of memory, otherwise a mbs string that the caller should free
|
|
// via CoTaskMemFree.
|
|
//
|
|
//***************************************************************************
|
|
|
|
char * WideToNarrow(
|
|
IN LPCWSTR pConv)
|
|
{
|
|
char * cpRet = NULL;
|
|
int iMBSLen = wcstombs(NULL,pConv,0) + 1;
|
|
if(iMBSLen == 0)
|
|
return NULL;
|
|
cpRet = (char *)CoTaskMemAlloc(iMBSLen);
|
|
if(cpRet)
|
|
{
|
|
memset(cpRet, 0, iMBSLen);
|
|
wcstombs(cpRet,pConv,iMBSLen);
|
|
}
|
|
return cpRet;
|
|
}
|
|
|
|
int gDiag;
|
|
|
|
char * WideToNarrowA(
|
|
IN LPCWSTR pConv)
|
|
{
|
|
char * cpRet = NULL;
|
|
int iMBSLen = wcstombs(NULL,pConv,0) + 1;
|
|
if(iMBSLen == 0)
|
|
return NULL;
|
|
cpRet = new char[iMBSLen];
|
|
gDiag = iMBSLen;
|
|
if(cpRet)
|
|
{
|
|
memset(cpRet, 0, iMBSLen);
|
|
wcstombs(cpRet,pConv,iMBSLen);
|
|
}
|
|
return cpRet;
|
|
}
|
|
//***************************************************************************
|
|
//
|
|
// SAFEARRAY * OMSSafeArrayCreate
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Creates a safe array.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// vt element type
|
|
// iNumElements number of elements
|
|
//
|
|
// RETURN VALUE:
|
|
//
|
|
// Returns null if there is a problem.
|
|
//
|
|
//***************************************************************************
|
|
|
|
SAFEARRAY * OMSSafeArrayCreate(
|
|
IN VARTYPE vt,
|
|
IN int iNumElements)
|
|
{
|
|
if(iTypeSize(vt) < 1 || iNumElements < 1)
|
|
return NULL;
|
|
SAFEARRAYBOUND rgsabound[1];
|
|
rgsabound[0].lLbound = 0;
|
|
rgsabound[0].cElements = iNumElements;
|
|
return SafeArrayCreate(vt,1,rgsabound);
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// SCODE OMSVariantChangeType
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Converts a variant from one type into another. This functions takes the
|
|
// same arguments and does the same action as the standard
|
|
// VariantChangeType except that it also handles arrays.
|
|
//
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// pDest points to the variant which is to be updated
|
|
// pSrc points to the variant that is the source
|
|
// wFlags flags which are passed on to VariantChangeType
|
|
// vtDest Type that the pDest is conveted to
|
|
//
|
|
// RETURN VALUE:
|
|
//
|
|
// S_OK All is well.
|
|
// WBEM_E_INVALID_PARAMETER Invalid argument
|
|
// WBEM_E_OUT_OF_MEMORY Out of memory
|
|
// otherwise various return codes from VariantChangeType, or safe array
|
|
// manipulation
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT OMSVariantChangeType(
|
|
IN OUT VARIANTARG * pDest,
|
|
IN VARIANTARG *pSrc,
|
|
IN USHORT wFlags,
|
|
IN VARTYPE vtDest)
|
|
{
|
|
SCODE sc;
|
|
|
|
// Verify arguments and clear out the destination
|
|
|
|
if(pDest == NULL || pSrc == NULL || iTypeSize(vtDest)<1 || iTypeSize(pSrc->vt)<1)
|
|
return WBEM_E_INVALID_PARAMETER; // Junk args
|
|
OMSVariantClear(pDest);
|
|
|
|
// if both are arrays,
|
|
|
|
if(vtDest & VT_ARRAY && pSrc->vt & VT_ARRAY) {
|
|
|
|
// Set the VARTYPES without the VT_ARRAY bits
|
|
|
|
VARTYPE vtDestSimple = vtDest & ~VT_ARRAY;
|
|
VARTYPE vtSrcSimple = pSrc->vt &~ VT_ARRAY;
|
|
|
|
// Determine the size of the source array. Also make sure that the array
|
|
// only has one dimension
|
|
|
|
unsigned int uDim = SafeArrayGetDim(pSrc->parray);
|
|
if(uDim != 1)
|
|
return WBEM_E_FAILED; // Bad array, or too many dimensions
|
|
long ix[2] = {0,0};
|
|
long lLower, lUpper;
|
|
sc = SafeArrayGetLBound(pSrc->parray,1,&lLower);
|
|
if(sc != S_OK)
|
|
return sc;
|
|
sc = SafeArrayGetUBound(pSrc->parray,1,&lUpper);
|
|
if(sc != S_OK)
|
|
return sc;
|
|
int iNumElements = lUpper - lLower +1;
|
|
|
|
// Create a destination array of equal size
|
|
|
|
SAFEARRAY * pDestArray = OMSSafeArrayCreate(vtDestSimple,iNumElements);
|
|
if(pDestArray == NULL)
|
|
return WBEM_E_FAILED; // Most likely a bad type!
|
|
|
|
// For each element in the source array
|
|
|
|
for(ix[0] = lLower; ix[0] <= lUpper && sc == S_OK; ix[0]++) {
|
|
|
|
CVariant varSrc, varDest;
|
|
|
|
// Set Temp CVariant to the source data
|
|
|
|
sc = SafeArrayGetElement(pSrc->parray,ix,varSrc.GetDataPtr());
|
|
if(sc != S_OK)
|
|
break;
|
|
varSrc.SetType(vtSrcSimple);
|
|
|
|
// Convert to destination data using VariantConvert
|
|
|
|
sc = VariantChangeType(varDest.GetVarPtr(),varSrc.GetVarPtr(),wFlags,vtDestSimple);
|
|
if(sc != S_OK)
|
|
break;
|
|
|
|
// Set destination data into the array
|
|
|
|
if(vtDestSimple == VT_BSTR || vtDestSimple == VT_UNKNOWN ||
|
|
vtDestSimple == VT_DISPATCH)
|
|
sc = SafeArrayPutElement(pDestArray,ix,(void *)varDest.GetBstr());
|
|
else
|
|
sc = SafeArrayPutElement(pDestArray,ix,(void *)varDest.GetDataPtr());
|
|
|
|
}
|
|
|
|
if(sc != S_OK){
|
|
SafeArrayDestroy(pDestArray);
|
|
}
|
|
else {
|
|
// set the VARTYPE of the destination
|
|
|
|
pDest->vt = vtDest;
|
|
pDest->parray = pDestArray;
|
|
}
|
|
return sc;
|
|
}
|
|
|
|
// if one, but not the other is an array, bail out
|
|
|
|
if(vtDest & VT_ARRAY || pSrc->vt & VT_ARRAY)
|
|
return WBEM_E_FAILED;
|
|
|
|
// Attempt to use standard conversion
|
|
|
|
return VariantChangeType(pDest,pSrc,wFlags,vtDest);
|
|
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// OMSVariantClear
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Does the same as the Ole VariantClear function except
|
|
// that it also sets the data to all 0.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// pClear Variant to be cleared.
|
|
//
|
|
// RETURN VALUE:
|
|
//
|
|
// Result from VariantClear, most always S_OK
|
|
//
|
|
//***************************************************************************
|
|
|
|
HRESULT OMSVariantClear(
|
|
IN OUT VARIANTARG * pClear)
|
|
{
|
|
HRESULT sc;
|
|
sc = VariantClear(pClear);
|
|
memset((void *)&pClear->lVal,0,8);
|
|
return sc;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
// int ITypeSize
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Gets the number of bytes acutally used to store
|
|
// a variant type. 0 if the type is unknown
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// vtTest Type in question.
|
|
//
|
|
//
|
|
// RETURN VALUE:
|
|
//
|
|
// see description
|
|
//
|
|
//***************************************************************************
|
|
|
|
int iTypeSize(
|
|
IN VARTYPE vtTest)
|
|
{
|
|
int iRet;
|
|
vtTest &= ~ VT_ARRAY; // get rid of possible array bit
|
|
switch (vtTest) {
|
|
case VT_UI1:
|
|
case VT_LPSTR:
|
|
iRet = 1;
|
|
break;
|
|
case VT_LPWSTR:
|
|
case VT_BSTR:
|
|
case VT_I2:
|
|
iRet = 2;
|
|
break;
|
|
case VT_I4:
|
|
case VT_R4:
|
|
iRet = 4;
|
|
break;
|
|
case VT_R8:
|
|
iRet = 8;
|
|
break;
|
|
case VT_BOOL:
|
|
iRet = sizeof(VARIANT_BOOL);
|
|
break;
|
|
case VT_ERROR:
|
|
iRet = sizeof(SCODE);
|
|
break;
|
|
case VT_CY:
|
|
iRet = sizeof(CY);
|
|
break;
|
|
case VT_DATE:
|
|
iRet = sizeof(DATE);
|
|
break;
|
|
case CIM_SINT64:
|
|
case CIM_UINT64:
|
|
iRet = 8;
|
|
break;
|
|
|
|
default:
|
|
iRet = 0;
|
|
}
|
|
return iRet;
|
|
}
|
|
|