|
|
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992-2000.
//
// File: variable.cxx
//
// Contents: Used to replace variables
//
// History: 96/Jan/3 DwightKr Created
//
//----------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
void RenderSafeArray( VARTYPE vt, SAFEARRAY * psa, COutputFormat & outputFormat, CVirtualString & vString, BOOL fFormatted );
//+---------------------------------------------------------------------------
//
// Member: CVariable::CVariable - public constructor
//
// Synopsis: Builds a single replaceable variable based in a propVariant
//
// Arguments: [wcsName] - friendly name for the variable
// [pVariant] - the variable's value
// [ulFlags] - all flags associated with this variable, for
// now this indicates if this variable requires
// a IRowsetScroll to access its value.
//
// History: 96/Jan/03 DwightKr Created.
//
//----------------------------------------------------------------------------
CVariable::CVariable( WCHAR const * wcsName, PROPVARIANT const * pVariant, ULONG ulFlags ) : _wcsName(0), _wcsRAWValue(0), _cwcRAWValue(0), _eNumType( eNotANumber ), _ulFlags(ulFlags), _pNext(0), _pBack(0){ Win4Assert( wcsName != 0 );
ULONG cwcName = wcslen(wcsName) + 1; _wcsName = new WCHAR[ cwcName ]; RtlCopyMemory( _wcsName, wcsName, cwcName * sizeof(WCHAR) );
_variant.vt = VT_EMPTY; _variant.pwszVal = 0;
if ( 0 != pVariant ) { // SetValue cannot raise
SetValue( pVariant, ulFlags ); }}
//+---------------------------------------------------------------------------
//
// Member: CVariable::CVariable - public copy constructor
//
// Synopsis: Builds a single replaceable variable based in a propVariant
//
// Arguments: [variable] - the variable to copy
//
// History: 96/Jan/03 DwightKr Created.
//
//----------------------------------------------------------------------------
CVariable::CVariable( const CVariable & variable ) : _wcsName(0), _cwcRAWValue(0), _eNumType( variable._eNumType ), _ulFlags(0), _pNext(0)
{ ULONG cwcName = wcslen(variable._wcsName) + 1;
_wcsName = new WCHAR[ cwcName ];
RtlCopyMemory( _wcsName, variable._wcsName, cwcName * sizeof(WCHAR) );
_ulFlags = variable._ulFlags; _variant = variable._variant;
if ( VT_LPWSTR == variable._variant.vt ) { _cwcRAWValue = variable._cwcRAWValue; }}
//+---------------------------------------------------------------------------
//
// Member: CVariable::~CVariable - public destructor
//
// History: 96/Jan/03 DwightKr Created.
//
//----------------------------------------------------------------------------
CVariable::~CVariable(){ if ( (_ulFlags & eParamOwnsVariantMemory) != 0 ) { delete _variant.pwszVal; }
//
// If we have a RAW string that is not part of the variant, and is
// not pointing to the in-line number buffer, delete it. It's probably
// an ASCII string we've converted to WCHAR.
//
if ( _wcsRAWValue && _wcsRAWValue != _wcsNumberValue && _wcsRAWValue != _variant.pwszVal ) { delete _wcsRAWValue; }
delete _wcsName;
if ( 0 != _pNext ) delete _pNext;}
//+---------------------------------------------------------------------------
//
// Member: CVariable::SetValue - public
//
// Synopsis: An assignment operator; allows the value of a variable to
// be changed.
//
// Arguments: [pVariant] - new value for this variable
//
// History: 96/Jan/03 DwightKr Created.
//
//----------------------------------------------------------------------------
void CVariable::SetValue( PROPVARIANT const * pVariant, ULONG ulFlags ){ //
// If we've stored a string equivalent for the old value, then
// delete it now.
//
if ( _wcsRAWValue && _wcsRAWValue != _wcsNumberValue && _wcsRAWValue != _variant.pwszVal ) { delete _wcsRAWValue; _wcsRAWValue = 0; _cwcRAWValue = 0; _eNumType = eNotANumber; }
if ( (_ulFlags & eParamOwnsVariantMemory) != 0 ) { delete _variant.pwszVal; _variant.pwszVal = 0;
_ulFlags &= ~eParamOwnsVariantMemory; }
if ( 0 != pVariant ) _variant = *pVariant; else { _variant.vt = VT_EMPTY; _variant.pwszVal = 0; // retentive
}
//
// If its a WCHAR string, we already have a pointer to its RAW value.
//
if ( (VT_LPWSTR == _variant.vt) && (0 != _variant.pwszVal) ) { _wcsRAWValue = _variant.pwszVal; _cwcRAWValue = wcslen(_wcsRAWValue); } else { _wcsRAWValue = 0; _cwcRAWValue = 0; }
_ulFlags |= ulFlags;}
//+---------------------------------------------------------------------------
//
// Member: CVariable::FastSetValue - public
//
// Synopsis: Special version of SetValue that can be faster because it
// knows that the variable can't own variant memory, that
// the variant is non-0, that the flags are 0, and that variant
// wide strings are non-zero.
//
// Arguments: [pVariant] - new value for this variable
//
// History: 96/Apr/05 dlee Created.
//
//----------------------------------------------------------------------------
void CVariable::FastSetValue( PROPVARIANT const * pVariant ){ //
// If we've stored a string equivalent for the old value, then
// delete it now.
//
if ( ( _wcsRAWValue != _wcsNumberValue ) && ( _wcsRAWValue != _variant.pwszVal ) ) { delete _wcsRAWValue; _wcsRAWValue = 0; _cwcRAWValue = 0; } _eNumType = eNotANumber;
Win4Assert( (_ulFlags & eParamOwnsVariantMemory) == 0 ); Win4Assert( 0 != pVariant ); _variant = *pVariant;
if ( VT_LPWSTR == _variant.vt ) { // The caller of FastSetValue can't pass a 0 string variant
Win4Assert( 0 != _variant.pwszVal ); _wcsRAWValue = _variant.pwszVal; _cwcRAWValue = wcslen(_wcsRAWValue); } else { _wcsRAWValue = 0; _cwcRAWValue = 0; }}
//+---------------------------------------------------------------------------
//
// Member: CVariable::SetValue - public
//
// Synopsis: A assignment operator; allows the value of a variable to
// be changed. Ownership of the string is transferred to this
// function
//
// Arguments: [wcsValue] - new value for this variable
// [cwcValue] - length of new value string
//
// History: 96/Jan/03 DwightKr Created.
//
//----------------------------------------------------------------------------
void CVariable::SetValue( XPtrST<WCHAR> & wcsValue, ULONG cwcValue ){ Win4Assert( VT_LPWSTR == _variant.vt );
//
// If we've stored a string equivalent for the old value, then
// delete it now.
//
if ( _wcsRAWValue && _wcsRAWValue != _wcsNumberValue && _wcsRAWValue != _variant.pwszVal ) { delete _wcsRAWValue; _wcsRAWValue = 0; _cwcRAWValue = 0; _eNumType = eNotANumber; }
if ( (_ulFlags & eParamOwnsVariantMemory) != 0 ) { delete _variant.pwszVal; _variant.pwszVal = 0; }
_ulFlags |= eParamOwnsVariantMemory;
_wcsRAWValue = wcsValue.Acquire(); _cwcRAWValue = cwcValue;}
// Maximum length of a floating point value string
// Big enough for a 1e308 + 9 decimal places + sign + slop
// Floating point precision.
// +1 because the numbers in float.h seem to be too small by one digit.
const unsigned fltPrec = FLT_DIG+1;const unsigned dblPrec = DBL_DIG+1;
//+---------------------------------------------------------------------------
//
// Function: SARenderElementFormatted
//
// Synopsis: Appends the formatted string form a safearray element to
// a virtual string.
// Only the subset of types that are formatted differently
// when "formatted" vs "raw" are handled in this function.
//
// Arguments: [outputFormat] -- The output format to use
// [vString] -- Where the result is appended
// [vt] -- Type of the element
// [pv] -- Pointer to the element
//
// Notes: I8 and UI8 aren't allowed in safearrays in NT 5, but they
// will be someday.
//
// History: 9-Jun-98 dlee Created
//
//----------------------------------------------------------------------------
void SARenderElementFormatted( COutputFormat & outputFormat, CVirtualString & vString, VARTYPE vt, void * pv ){ ciGibDebugOut(( DEB_ITRACE, "vt %#x, pv %#x\n", vt, pv ));
// Recurse if we have a nested VT_ARRAY in an array element.
if ( VT_ARRAY & vt ) { SAFEARRAY *psa = *(SAFEARRAY **) pv; RenderSafeArray( vt & ~VT_ARRAY, psa, outputFormat, vString, TRUE ); return; }
WCHAR awcTmp[ maxFloatSize ]; const ULONG cwcTmp = sizeof awcTmp / sizeof awcTmp[0]; ULONG cwc = 0;
switch ( vt ) { case VT_UI1: { cwc = outputFormat.FormatNumber( (ULONG) * (BYTE *) pv, awcTmp, cwcTmp ); break; } case VT_I1: { cwc = outputFormat.FormatNumber( (LONG) * (signed char *) pv, awcTmp, cwcTmp ); break; } case VT_UI2: { USHORT us; RtlCopyMemory( &us, pv, sizeof us ); cwc = outputFormat.FormatNumber( (ULONG) us, awcTmp, cwcTmp ); break; } case VT_I2: { SHORT s; RtlCopyMemory( &s, pv, sizeof s ); cwc = outputFormat.FormatNumber( (LONG) s, awcTmp, cwcTmp ); break; } case VT_UI4: case VT_UINT: { ULONG ul; RtlCopyMemory( &ul, pv, sizeof ul ); cwc = outputFormat.FormatNumber( ul, awcTmp, cwcTmp ); break; } case VT_I4: case VT_ERROR: case VT_INT: { LONG l; RtlCopyMemory( &l, pv, sizeof l ); cwc = outputFormat.FormatNumber( l, awcTmp, cwcTmp ); break; } case VT_UI8: { unsigned __int64 ui; RtlCopyMemory( &ui, pv, sizeof ui ); cwc = outputFormat.FormatNumber( ui, awcTmp, cwcTmp ); break; } case VT_I8: { __int64 i; RtlCopyMemory( &i, pv, sizeof i ); cwc = outputFormat.FormatNumber( i, awcTmp, cwcTmp ); break; } case VT_R4: { float f; RtlCopyMemory( &f, pv, sizeof f ); cwc = outputFormat.FormatFloat( f, fltPrec, awcTmp, cwcTmp ); break; } case VT_R8: { double d; RtlCopyMemory( &d, pv, sizeof d ); cwc = outputFormat.FormatFloat( d, dblPrec, awcTmp, cwcTmp ); break; } case VT_DECIMAL: { double d; VarR8FromDec( (DECIMAL *) pv, &d ); cwc = outputFormat.FormatFloat( d, dblPrec, awcTmp, cwcTmp ); break; } case VT_CY: { double d; VarR8FromCy( * (CY *) pv, &d ); cwc = outputFormat.FormatFloat( d, dblPrec, awcTmp, cwcTmp ); break; } case VT_VARIANT: { PROPVARIANT & Var = * (PROPVARIANT *) pv; SARenderElementFormatted( outputFormat, vString, Var.vt, & Var.lVal ); break; } default : { ciGibDebugOut(( DEB_ERROR, "unexpected numeric sa element type %#x\n", vt )); Win4Assert( !"unexpected numeric safearray element type" ); break; } }
vString.StrCat( awcTmp, cwc );} //SARenderElementFormatted
//+---------------------------------------------------------------------------
//
// Function: SARenderElementRaw
//
// Synopsis: Appends the "raw" string form a safearray element to
// a virtual string. Numbers are raw when they don't have
// formatting like commas.
//
// Arguments: [outputFormat] -- The output format to use
// [vString] -- Where the result is appended
// [vt] -- Type of the element
// [pv] -- Pointer to the element
//
// Notes: I8 and UI8 aren't allowed in safearrays in NT 5, but they
// will be someday.
//
// History: 9-Jun-98 dlee Created
//
//----------------------------------------------------------------------------
void SARenderElementRaw( COutputFormat & outputFormat, CVirtualString & vString, VARTYPE vt, void * pv ){ ciGibDebugOut(( DEB_ITRACE, "vt %#x, pv %#x\n", vt, pv ));
// Recurse if we have a nested VT_ARRAY in an array element.
if ( VT_ARRAY & vt ) { SAFEARRAY *psa = *(SAFEARRAY **) pv; RenderSafeArray( vt & ~VT_ARRAY, psa, outputFormat, vString, FALSE ); return; }
WCHAR awcTmp[ maxFloatSize ]; const ULONG cwcTmp = sizeof awcTmp / sizeof awcTmp[0]; ULONG cwc = 0;
switch ( vt ) { case VT_EMPTY: case VT_NULL: { break; } case VT_BSTR: { BSTR bstr = *(BSTR *) pv; vString.StrCat( bstr ); break; } case VT_BOOL: { VARIANT_BOOL vb; RtlCopyMemory( &vb, pv, sizeof vb ); wcscpy( awcTmp, ( VARIANT_FALSE == vb ) ? L"FALSE" : L"TRUE" ); cwc = wcslen( awcTmp); break; } case VT_DATE: { SYSTEMTIME stUTC; DATE date; RtlCopyMemory( &date, pv, sizeof date ); if ( VariantTimeToSystemTime( date, &stUTC ) ) cwc = outputFormat.FormatDateTime( stUTC, awcTmp, cwcTmp ); break; } case VT_UI1: { IDQ_ultow( (ULONG) * (BYTE *) pv, awcTmp ); cwc = wcslen( awcTmp ); break; } case VT_I1: { IDQ_ltow( (LONG) * (signed char *) pv, awcTmp ); cwc = wcslen( awcTmp ); break; } case VT_UI2: { USHORT us; RtlCopyMemory( &us, pv, sizeof us ); IDQ_ultow( (ULONG) us, awcTmp ); cwc = wcslen( awcTmp ); break; } case VT_I2: { SHORT s; RtlCopyMemory( &s, pv, sizeof s ); IDQ_ltow( (LONG) s, awcTmp ); cwc = wcslen( awcTmp ); break; } case VT_UI4: case VT_UINT: { ULONG ul; RtlCopyMemory( &ul, pv, sizeof ul ); IDQ_ultow( ul, awcTmp ); cwc = wcslen( awcTmp ); break; } case VT_I4: case VT_ERROR: case VT_INT: { LONG l; RtlCopyMemory( &l, pv, sizeof l ); IDQ_ltow( l, awcTmp ); cwc = wcslen( awcTmp ); break; } case VT_UI8: { unsigned __int64 ui; RtlCopyMemory( &ui, pv, sizeof ui ); IDQ_ulltow( ui, awcTmp ); cwc = wcslen( awcTmp ); break; } case VT_I8: { __int64 i; RtlCopyMemory( &i, pv, sizeof i ); IDQ_lltow( i, awcTmp ); cwc = wcslen( awcTmp ); break; } case VT_R4: { float f; RtlCopyMemory( &f, pv, sizeof f ); cwc = outputFormat.FormatFloatRaw( f, fltPrec, awcTmp, cwcTmp ); break; } case VT_R8: { double d; RtlCopyMemory( &d, pv, sizeof d ); cwc = outputFormat.FormatFloatRaw( d, dblPrec, awcTmp, cwcTmp ); break; } case VT_DECIMAL: { double d; VarR8FromDec( (DECIMAL *) pv, &d ); cwc = outputFormat.FormatFloatRaw( d, dblPrec, awcTmp, cwcTmp ); break; } case VT_CY: { double d; VarR8FromCy( * (CY *) pv, &d ); cwc = outputFormat.FormatFloatRaw( d, dblPrec, awcTmp, cwcTmp ); break; } case VT_VARIANT: { PROPVARIANT & Var = * (PROPVARIANT *) pv; SARenderElementRaw( outputFormat, vString, Var.vt, & Var.lVal ); break; } default : { ciGibDebugOut(( DEB_ERROR, "unexpected sa element type %#x\n", vt )); Win4Assert( !"unexpected safearray element type" ); break; } }
vString.StrCat( awcTmp, cwc );} //SARenderElementRaw
//+---------------------------------------------------------------------------
//
// Function: GetVectorFormatting
//
// Synopsis: Retrieves the vector formatting strings for a given type.
// Only safearray element datatypes are handled here.
//
// Arguments: [pwcPre] -- Returns the vector prefix string
// [pwcSep] -- Returns the vector separator string
// [pwcSuf] -- Returns the vector suffix string
//
// History: 9-Jun-98 dlee Created
//
//----------------------------------------------------------------------------
void GetVectorFormatting( WCHAR const * & pwcPre, WCHAR const * & pwcSep, WCHAR const * & pwcSuf, VARTYPE vt, COutputFormat & outputFormat ){ Win4Assert( 0 == ( vt & VT_ARRAY ) );
switch ( vt ) { case VT_CY: pwcPre = outputFormat.GetCurrencyVectorPrefix(); pwcSep = outputFormat.GetCurrencyVectorSeparator(); pwcSuf = outputFormat.GetCurrencyVectorSuffix(); break; case VT_DATE: pwcPre = outputFormat.GetDateVectorPrefix(); pwcSep = outputFormat.GetDateVectorSeparator(); pwcSuf = outputFormat.GetDateVectorSuffix(); break; case VT_BOOL: pwcPre = outputFormat.GetBoolVectorPrefix(); pwcSep = outputFormat.GetBoolVectorSeparator(); pwcSuf = outputFormat.GetBoolVectorSuffix(); break; case VT_BSTR: pwcPre = outputFormat.GetStringVectorPrefix(); pwcSep = outputFormat.GetStringVectorSeparator(); pwcSuf = outputFormat.GetStringVectorSuffix(); break; case VT_VARIANT: case VT_EMPTY: case VT_NULL: case VT_I1: case VT_UI1: case VT_I2: case VT_UI2: case VT_I4: case VT_INT: case VT_UI4: case VT_UINT: case VT_I8: case VT_UI8: case VT_R4: case VT_R8: case VT_DECIMAL: case VT_ERROR: pwcPre = outputFormat.GetNumberVectorPrefix(); pwcSep = outputFormat.GetNumberVectorSeparator(); pwcSuf = outputFormat.GetNumberVectorSuffix(); break; default: ciGibDebugOut(( DEB_ERROR, "GetVectorFormatting unknown type %#x\n", vt )); Win4Assert( !"GetVectorFormatting doesn't support type" ); break; }} //GetVectorFormatting
//+---------------------------------------------------------------------------
//
// Function: RenderSafeArray
//
// Synopsis: Appends the string form of a safearray to a virtual string.
//
// Arguments: [vt] -- Datatype of the safearray, without VT_ARRAY
// [psa] -- The safearray to format
// [outputFormat] -- How to render the result
// [vString] -- The result is appended here
// [fFormatted] -- If TRUE, formatted, otherwise raw
//
// History: 9-Jun-98 dlee Created
//
//----------------------------------------------------------------------------
void RenderSafeArray( VARTYPE vt, SAFEARRAY * psa, COutputFormat & outputFormat, CVirtualString & vString, BOOL fFormatted ){ Win4Assert( 0 == ( vt & VT_ARRAY ) );
//
// Get the array prefix, separator, and suffix
//
WCHAR const * pwcPre; WCHAR const * pwcSep; WCHAR const * pwcSuf; GetVectorFormatting( pwcPre, pwcSep, pwcSuf, vt, outputFormat );
//
// Get the dimensions of the array
//
CDynArrayInPlace<WCHAR> xOut; UINT cDim = SafeArrayGetDim( psa ); if ( 0 == cDim ) return;
XArray<LONG> xDim( cDim ); XArray<LONG> xLo( cDim ); XArray<LONG> xUp( cDim );
for ( UINT iDim = 0; iDim < cDim; iDim++ ) { SCODE sc = SafeArrayGetLBound( psa, iDim + 1, &xLo[iDim] ); if ( FAILED( sc ) ) THROW( CException( sc ) );
xDim[ iDim ] = xLo[ iDim ];
sc = SafeArrayGetUBound( psa, iDim + 1, &xUp[iDim] ); if ( FAILED( sc ) ) THROW( CException( sc ) );
ciGibDebugOut(( DEB_ITRACE, "dim %d, lo %d, up %d\n", iDim, xLo[iDim], xUp[iDim] ));
vString.StrCat( pwcPre ); }
//
// Slog through the array
//
UINT iLastDim = cDim - 1; BOOL fDone = FALSE;
while ( !fDone ) { // Inter-element formatting if not the first element
if ( xDim[ iLastDim ] != xLo[ iLastDim ] ) vString.StrCat( pwcSep );
// Get the element and render it
void *pv; SCODE sc = SafeArrayPtrOfIndex( psa, xDim.GetPointer(), &pv ); if ( FAILED( sc ) ) THROW( CException( sc ) );
if ( fFormatted ) SARenderElementFormatted( outputFormat, vString, vt, pv ); else SARenderElementRaw( outputFormat, vString, vt, pv );
// Move to the next element and carry if necessary
ULONG cOpen = 0;
for ( LONG iDim = iLastDim; iDim >= 0; iDim-- ) { if ( xDim[ iDim ] < xUp[ iDim ] ) { xDim[ iDim ] = 1 + xDim[ iDim ]; break; }
vString.StrCat( pwcSuf );
if ( 0 == iDim ) fDone = TRUE; else { cOpen++; xDim[ iDim ] = xLo[ iDim ]; } }
for ( ULONG i = 0; !fDone && i < cOpen; i++ ) vString.StrCat( pwcPre ); }} //RenderSafeArray
//+---------------------------------------------------------------------------
//
// Member: CVariable::GetStringValueFormattedRAW - public
//
// Synopsis: Not all VT types are strings. Those which are not strings
// have a string equivalent generated and stored for reuse.
//
// Arguments: [outputFormat] - contains formatting information for numbers
//
// Returns: A pointer to a string representation of the variable's value.
// Numbers are formatted.
//
// History: 26-Aug-96 KyleP Created (from GetStringValueRAW)
//
//----------------------------------------------------------------------------
WCHAR * CVariable::GetStringValueFormattedRAW( COutputFormat & outputFormat, ULONG & cwcValue ){ Win4Assert( !(_wcsRAWValue == 0 && _cwcRAWValue != 0) );
//
// Did we have a real raw value last time?
//
if ( _wcsRAWValue && _eNumType == eRawNumber ) { if ( _wcsRAWValue != _wcsNumberValue && _wcsRAWValue != _variant.pwszVal ) delete _wcsRAWValue;
_wcsRAWValue = 0; _cwcRAWValue = 0; }
if ( 0 == _wcsRAWValue ) { switch ( _variant.vt ) { case VT_UI1: _cwcRAWValue = outputFormat.FormatNumber( (ULONG) _variant.bVal, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); _wcsRAWValue = _wcsNumberValue; _eNumType = eFormattedNumber; break;
case VT_I1: _cwcRAWValue = outputFormat.FormatNumber( (LONG) _variant.cVal, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); _wcsRAWValue = _wcsNumberValue; _eNumType = eFormattedNumber; break;
case VT_UI2: _cwcRAWValue = outputFormat.FormatNumber( (ULONG) _variant.uiVal, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); _wcsRAWValue = _wcsNumberValue; _eNumType = eFormattedNumber; break;
case VT_I2: _cwcRAWValue = outputFormat.FormatNumber( (LONG) _variant.iVal, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); _wcsRAWValue = _wcsNumberValue; _eNumType = eFormattedNumber; break;
case VT_UI4: case VT_UINT: _cwcRAWValue = outputFormat.FormatNumber( (ULONG) _variant.ulVal, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); _wcsRAWValue = _wcsNumberValue; _eNumType = eFormattedNumber; break;
case VT_I4: case VT_INT: case VT_ERROR: _cwcRAWValue = outputFormat.FormatNumber( (LONG) _variant.lVal, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); _wcsRAWValue = _wcsNumberValue; _eNumType = eFormattedNumber; break;
case VT_UI8: _cwcRAWValue = outputFormat.FormatNumber( _variant.uhVal.QuadPart, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); _wcsRAWValue = _wcsNumberValue; _eNumType = eFormattedNumber; break;
case VT_I8: _cwcRAWValue = outputFormat.FormatNumber( _variant.hVal.QuadPart, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); _wcsRAWValue = _wcsNumberValue; _eNumType = eFormattedNumber; break;
case VT_R4: { WCHAR awchOutput[maxFloatSize];
_cwcRAWValue = outputFormat.FormatFloat( _variant.fltVal, fltPrec, awchOutput, maxFloatSize );
if ( _cwcRAWValue < cwcNumberValue ) _wcsRAWValue = _wcsNumberValue; else _wcsRAWValue = new WCHAR[ 1 + _cwcRAWValue ];
RtlCopyMemory( _wcsRAWValue, awchOutput, (1 + _cwcRAWValue) * sizeof WCHAR ); _eNumType = eFormattedNumber; break; }
case VT_R8: case VT_DECIMAL: { double dblValue = _variant.dblVal; if ( VT_DECIMAL == _variant.vt ) VarR8FromDec( &_variant.decVal, &dblValue );
// Big enough for a 1e308 + 9 decimal places + sign
WCHAR awchOutput[maxFloatSize];
_cwcRAWValue = outputFormat.FormatFloat( dblValue, dblPrec, awchOutput, maxFloatSize );
if ( _cwcRAWValue < cwcNumberValue ) _wcsRAWValue = _wcsNumberValue; else _wcsRAWValue = new WCHAR[ 1 + _cwcRAWValue ];
RtlCopyMemory( _wcsRAWValue, awchOutput, (1 + _cwcRAWValue) * sizeof WCHAR ); _eNumType = eFormattedNumber; break; }
case VT_CY: _cwcRAWValue = outputFormat.FormatCurrency( _variant.cyVal, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); _wcsRAWValue = _wcsNumberValue; _eNumType = eFormattedNumber; break;
case VT_UI1 | VT_VECTOR: case VT_I1 | VT_VECTOR: { _eNumType = eFormattedNumber; CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetNumberVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.caub.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetNumberVectorSeparator() );
if ( (VT_UI1 | VT_VECTOR) == _variant.vt ) _cwcRAWValue = outputFormat.FormatNumber( (ULONG) _variant.caub.pElems[iValue], _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); else _cwcRAWValue = outputFormat.FormatNumber( (LONG) _variant.cac.pElems[iValue], _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) );
vString.StrCat( _wcsNumberValue, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetNumberVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); break; }
case VT_I2 | VT_VECTOR: case VT_UI2 | VT_VECTOR: { _eNumType = eFormattedNumber; CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetNumberVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.caui.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetNumberVectorSeparator() );
if ( (VT_UI2 | VT_VECTOR) == _variant.vt ) _cwcRAWValue = outputFormat.FormatNumber( (ULONG) _variant.caui.pElems[iValue], _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); else _cwcRAWValue = outputFormat.FormatNumber( (LONG) _variant.cai.pElems[iValue], _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) );
vString.StrCat( _wcsNumberValue, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetNumberVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); break; }
case VT_R4 | VT_VECTOR: case VT_I4 | VT_VECTOR: case VT_UI4 | VT_VECTOR: case VT_ERROR | VT_VECTOR: { _eNumType = eFormattedNumber; CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetNumberVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.caul.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetNumberVectorSeparator() );
if ( (VT_R4 | VT_VECTOR) == _variant.vt ) _cwcRAWValue = outputFormat.FormatFloat( _variant.caflt.pElems[iValue], fltPrec, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); else if ( (VT_UI4 | VT_VECTOR) == _variant.vt ) _cwcRAWValue = outputFormat.FormatNumber( _variant.caul.pElems[iValue], _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); else _cwcRAWValue = outputFormat.FormatNumber( _variant.cal.pElems[iValue], _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) );
vString.StrCat( _wcsNumberValue, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetNumberVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); break; }
case VT_I8 | VT_VECTOR: case VT_UI8 | VT_VECTOR: case VT_R8 | VT_VECTOR: { _eNumType = eFormattedNumber; CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetNumberVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.cadbl.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetNumberVectorSeparator() );
if ( (VT_I8 | VT_VECTOR) == _variant.vt ) _cwcRAWValue = outputFormat.FormatNumber( (_int64) _variant.cah.pElems[iValue].QuadPart, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); else if ( (VT_UI8 | VT_VECTOR) == _variant.vt ) _cwcRAWValue = outputFormat.FormatNumber( (unsigned _int64) _variant.cauh.pElems[iValue].QuadPart, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); else _cwcRAWValue = outputFormat.FormatFloat( _variant.cadbl.pElems[iValue], dblPrec, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) );
vString.StrCat( _wcsNumberValue, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetNumberVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); break; }
case VT_CY | VT_VECTOR: { _eNumType = eFormattedNumber; CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetCurrencyVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.cacy.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetCurrencyVectorSeparator() );
_cwcRAWValue = outputFormat.FormatCurrency( _variant.cacy.pElems[iValue], _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); vString.StrCat( _wcsNumberValue, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetCurrencyVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); break; }
case VT_ARRAY | VT_I1 : case VT_ARRAY | VT_UI1: case VT_ARRAY | VT_I2 : case VT_ARRAY | VT_UI2 : case VT_ARRAY | VT_I4 : case VT_ARRAY | VT_INT : case VT_ARRAY | VT_UI4 : case VT_ARRAY | VT_UINT : case VT_ARRAY | VT_CY : case VT_ARRAY | VT_DECIMAL : case VT_ARRAY | VT_ERROR: { _eNumType = eFormattedNumber; CVirtualString vString( 0x200 );
RenderSafeArray( _variant.vt & ~VT_ARRAY, _variant.parray, outputFormat, vString, TRUE ); _wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); break; }
default: { Win4Assert( _eNumType == eNotANumber ); GetStringValueRAW( outputFormat, cwcValue ); break; } } }
#if (DBG == 1)
if ( _wcsRAWValue != 0 ) { Win4Assert( wcslen(_wcsRAWValue) == _cwcRAWValue ); }#endif // DBG == 1
Win4Assert( !(_wcsRAWValue == 0 && _cwcRAWValue != 0) );
cwcValue = _cwcRAWValue; return _wcsRAWValue;}
//+---------------------------------------------------------------------------
//
// Member: CVariable::GetStringValueRAW - public
//
// Synopsis: Not all VT types are strings. Those which are not strings
// have a string equivalent generated and stored for reuse.
//
// Arguments: [outputFormat] - contains formatting information for numbers
//
// Returns: A pointer to a string representation of the variable's value.
//
// History: 96/Jan/03 DwightKr Created.
// 96/Mar/29 DwightKr Add support for deferred VT_LPWSTR
// values
//
//----------------------------------------------------------------------------
WCHAR * CVariable::GetStringValueRAW( COutputFormat & outputFormat, ULONG & cwcValue){ Win4Assert( !(_wcsRAWValue == 0 && _cwcRAWValue != 0) );
//
// Did we have a formatted raw value last time?
//
if ( _wcsRAWValue && _eNumType == eFormattedNumber ) { if ( _wcsRAWValue != _wcsNumberValue && _wcsRAWValue != _variant.pwszVal ) delete _wcsRAWValue;
_wcsRAWValue = 0; _cwcRAWValue = 0; }
if ( 0 == _wcsRAWValue ) { switch ( _variant.vt ) { case VT_LPWSTR: //
// if it's a deferred value, load it now
//
if ( (_ulFlags & eParamDeferredValue) != 0 ) { XArray<WCHAR> wcsValue; ULONG cwcValue;
if ( outputFormat.GetCGIVariableW(_wcsName, wcsValue, cwcValue) ) { _wcsRAWValue = wcsValue.Acquire(); _cwcRAWValue = cwcValue;
ciGibDebugOut(( DEB_ITRACE, "Loading deferred value for %ws=%ws\n", _wcsName, _wcsRAWValue )); } else { ciGibDebugOut(( DEB_ITRACE, "Unable to load deferred value for %ws\n", _wcsName ));
_variant.vt = VT_EMPTY; _wcsRAWValue = _wcsNumberValue; *_wcsRAWValue = 0; _cwcRAWValue = 0; }
break; }
// fall through if not a deferred value
case VT_EMPTY: _wcsRAWValue = _wcsNumberValue; *_wcsRAWValue = 0; _cwcRAWValue = 0; break;
case VT_BSTR: _wcsRAWValue = _variant.bstrVal; _cwcRAWValue = wcslen( _wcsRAWValue ); break;
case VT_LPSTR: { ULONG cbBuffer = strlen( _variant.pszVal ) + 1; XArray<WCHAR> pwBuffer;
_cwcRAWValue = MultiByteToXArrayWideChar( (BYTE * const) _variant.pszVal, cbBuffer, outputFormat.CodePage(), pwBuffer );
_wcsRAWValue = pwBuffer.Acquire(); } break;
case VT_UI1: IDQ_ultow( (ULONG) _variant.bVal, _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); _eNumType = eRawNumber; break;
case VT_I1: IDQ_ltow( (LONG) _variant.cVal, _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); _eNumType = eRawNumber; break;
case VT_UI2: IDQ_ultow( (ULONG) _variant.uiVal, _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); _eNumType = eRawNumber; break;
case VT_I2: IDQ_ltow( (LONG) _variant.iVal, _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); _eNumType = eRawNumber; break;
case VT_UI4: case VT_UINT: IDQ_ultow( _variant.ulVal, _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); _eNumType = eRawNumber; break;
case VT_I4: case VT_INT: case VT_ERROR: IDQ_ltow( _variant.lVal, _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); _eNumType = eRawNumber; break;
case VT_UI8: IDQ_ulltow( _variant.uhVal.QuadPart, _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); _eNumType = eRawNumber; break;
case VT_I8: IDQ_lltow( _variant.hVal.QuadPart, _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); _eNumType = eRawNumber; break;
case VT_R4: { // Big enough for a 1e308 + 9 decimal places + sign
WCHAR awc[maxFloatSize];
outputFormat.FormatFloatRaw( _variant.fltVal, fltPrec, awc, maxFloatSize ); _cwcRAWValue = wcslen( awc );
if ( _cwcRAWValue < cwcNumberValue ) _wcsRAWValue = _wcsNumberValue; else _wcsRAWValue = new WCHAR[ 1 + _cwcRAWValue ];
RtlCopyMemory( _wcsRAWValue, awc, (1 + _cwcRAWValue) * sizeof WCHAR ); _eNumType = eRawNumber; } break;
case VT_R8: case VT_DECIMAL: { double dblValue = _variant.dblVal; if ( VT_DECIMAL == _variant.vt ) VarR8FromDec( &_variant.decVal, &dblValue );
// Big enough for a 1e308 + 9 decimal places + sign
WCHAR awc[maxFloatSize];
outputFormat.FormatFloatRaw( dblValue, dblPrec, awc, maxFloatSize ); _cwcRAWValue = wcslen( awc );
if ( _cwcRAWValue < cwcNumberValue ) _wcsRAWValue = _wcsNumberValue; else _wcsRAWValue = new WCHAR[ 1 + _cwcRAWValue ];
RtlCopyMemory( _wcsRAWValue, awc, (1 + _cwcRAWValue) * sizeof WCHAR ); _eNumType = eRawNumber; } break;
case VT_DATE: { //
// variantdate => dosdate => utcfiletime
//
SYSTEMTIME stUTC; if ( VariantTimeToSystemTime(_variant.date, &stUTC ) ) { _cwcRAWValue = outputFormat.FormatDateTime( stUTC, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); _wcsRAWValue = _wcsNumberValue; } else { _wcsRAWValue = _wcsNumberValue; *_wcsRAWValue = 0; _cwcRAWValue = 0; } } break;
case VT_FILETIME: _cwcRAWValue = outputFormat.FormatDateTime( _variant.filetime, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); _wcsRAWValue = _wcsNumberValue; break;
case VT_BOOL: _wcsRAWValue = _wcsNumberValue; wcscpy( _wcsRAWValue, _variant.boolVal == VARIANT_FALSE ? L"FALSE" : L"TRUE" ); _cwcRAWValue = wcslen( _wcsRAWValue ); break;
case VT_CLSID: _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = swprintf( _wcsRAWValue, L"%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", _variant.puuid->Data1, _variant.puuid->Data2, _variant.puuid->Data3, _variant.puuid->Data4[0], _variant.puuid->Data4[1], _variant.puuid->Data4[2], _variant.puuid->Data4[3], _variant.puuid->Data4[4], _variant.puuid->Data4[5], _variant.puuid->Data4[6], _variant.puuid->Data4[7] ); break;
case VT_CY: { double dblValue; VarR8FromCy( _variant.cyVal, &dblValue );
// Big enough for a 1e308 + 9 decimal places + sign
WCHAR awc[maxFloatSize];
_cwcRAWValue = swprintf( awc, L"%lf", dblValue );
if ( _cwcRAWValue < cwcNumberValue ) _wcsRAWValue = _wcsNumberValue; else _wcsRAWValue = new WCHAR[ 1 + _cwcRAWValue ];
RtlCopyMemory( _wcsRAWValue, awc, (1 + _cwcRAWValue) * sizeof WCHAR ); _eNumType = eRawNumber; } break;
//
// Vectors only below this point
//
case VT_LPWSTR | VT_VECTOR: { CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetStringVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.calpwstr.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetStringVectorSeparator() );
vString.StrCat( _variant.calpwstr.pElems[iValue] ); }
vString.StrCat( outputFormat.GetStringVectorSuffix() ); _wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } break;
case VT_BSTR | VT_VECTOR: { CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetStringVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.cabstr.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetStringVectorSeparator() );
vString.StrCat( _variant.cabstr.pElems[iValue] ); }
vString.StrCat( outputFormat.GetStringVectorSuffix() ); _wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } break;
case VT_LPSTR | VT_VECTOR: { CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetStringVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.calpstr.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetStringVectorSeparator() );
ULONG cbBuffer = strlen( _variant.calpstr.pElems[iValue] ) + 1; XArray<WCHAR> pwBuffer;
_cwcRAWValue = MultiByteToXArrayWideChar( (BYTE * const) _variant.calpstr.pElems[iValue], cbBuffer, outputFormat.CodePage(), pwBuffer );
vString.StrCat( pwBuffer.Get(), _cwcRAWValue ); }
vString.StrCat( outputFormat.GetStringVectorSuffix() ); _wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } break;
case VT_UI1 | VT_VECTOR: case VT_I1 | VT_VECTOR: { _eNumType = eRawNumber; CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetNumberVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.caub.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetNumberVectorSeparator() );
if ( (VT_UI1 | VT_VECTOR) == _variant.vt ) { IDQ_ultow( (ULONG) _variant.caub.pElems[iValue], _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); } else { IDQ_ltow( (LONG) _variant.cac.pElems[iValue], _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); }
vString.StrCat( _wcsNumberValue, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetNumberVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } break;
case VT_I2 | VT_VECTOR: case VT_UI2 | VT_VECTOR: { _eNumType = eRawNumber; CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetNumberVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.caui.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetNumberVectorSeparator() );
if ( (VT_UI2 | VT_VECTOR) == _variant.vt ) { IDQ_ultow( (ULONG) _variant.caui.pElems[iValue], _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); } else { IDQ_ltow( (LONG) _variant.cai.pElems[iValue], _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); }
vString.StrCat( _wcsNumberValue, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetNumberVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } break;
case VT_I4 | VT_VECTOR: case VT_UI4 | VT_VECTOR: case VT_I8 | VT_VECTOR: case VT_UI8 | VT_VECTOR: { _eNumType = eRawNumber; CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetNumberVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.caul.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetNumberVectorSeparator() );
if ( (VT_I4 | VT_VECTOR) == _variant.vt ) { IDQ_ltow( _variant.cal.pElems[iValue], _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); } else if ( (VT_UI4 | VT_VECTOR) == _variant.vt ) { IDQ_ultow( _variant.caul.pElems[iValue], _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); } else if ( (VT_I8 | VT_VECTOR) == _variant.vt ) { IDQ_lltow( _variant.cah.pElems[iValue].QuadPart, _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); } else { IDQ_ulltow( _variant.cauh.pElems[iValue].QuadPart, _wcsNumberValue ); _wcsRAWValue = _wcsNumberValue; _cwcRAWValue = wcslen( _wcsRAWValue ); }
vString.StrCat( _wcsNumberValue, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetNumberVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } break;
case VT_R4 | VT_VECTOR: case VT_R8 | VT_VECTOR: { _eNumType = eRawNumber; CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetNumberVectorPrefix() );
// Big enough for a 1e308 + 9 decimal places + sign
WCHAR awc[maxFloatSize];
for ( unsigned iValue=0; iValue<_variant.cadbl.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetNumberVectorSeparator() );
if ( (VT_R4 | VT_VECTOR) == _variant.vt ) { outputFormat.FormatFloatRaw( _variant.caflt.pElems[iValue], fltPrec, awc, maxFloatSize ); _cwcRAWValue = wcslen( awc ); } else { outputFormat.FormatFloatRaw( _variant.cadbl.pElems[iValue], dblPrec, awc, maxFloatSize ); _cwcRAWValue = wcslen( awc ); }
vString.StrCat( awc, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetNumberVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } break;
case VT_DATE | VT_VECTOR: { CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetDateVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.cadate.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetDateVectorSeparator() );
//
// variantdate => dosdate => localfiletime => utcfiletime
//
SYSTEMTIME stUTC; if ( VariantTimeToSystemTime(_variant.cadate.pElems[iValue], &stUTC ) ) { _cwcRAWValue = outputFormat.FormatDateTime( stUTC, _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); } else { *_wcsNumberValue = 0; _cwcRAWValue = 0; }
vString.StrCat( _wcsNumberValue, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetDateVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } break;
case VT_FILETIME | VT_VECTOR: { CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetDateVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.cafiletime.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetDateVectorSeparator() );
_cwcRAWValue = outputFormat.FormatDateTime( _variant.cafiletime.pElems[iValue], _wcsNumberValue, sizeof(_wcsNumberValue) / sizeof(WCHAR) ); vString.StrCat( _wcsNumberValue, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetDateVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } break;
case VT_BOOL | VT_VECTOR: { CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetBoolVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.cabool.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetBoolVectorSeparator() );
vString.StrCat( _variant.cabool.pElems[iValue] == VARIANT_FALSE ? L"FALSE" : L"TRUE" ); }
vString.StrCat( outputFormat.GetBoolVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } break;
case VT_CLSID | VT_VECTOR: { CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetStringVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.cauuid.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetStringVectorSeparator() );
_cwcRAWValue = swprintf( _wcsNumberValue, L"%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", _variant.cauuid.pElems[iValue].Data1, _variant.cauuid.pElems[iValue].Data2, _variant.cauuid.pElems[iValue].Data3, _variant.cauuid.pElems[iValue].Data4[0], _variant.cauuid.pElems[iValue].Data4[1], _variant.cauuid.pElems[iValue].Data4[2], _variant.cauuid.pElems[iValue].Data4[3], _variant.cauuid.pElems[iValue].Data4[4], _variant.cauuid.pElems[iValue].Data4[5], _variant.cauuid.pElems[iValue].Data4[6], _variant.cauuid.pElems[iValue].Data4[7] ); vString.StrCat( _wcsNumberValue, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetStringVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } break;
case VT_CY | VT_VECTOR: { _eNumType = eRawNumber; CVirtualString vString( 0x200 ); vString.StrCat( outputFormat.GetCurrencyVectorPrefix() );
for ( unsigned iValue=0; iValue<_variant.cacy.cElems; iValue++ ) { if ( 0 != iValue ) vString.StrCat( outputFormat.GetCurrencyVectorSeparator() );
// Big enough for a 1e308 + 9 decimal places + sign
WCHAR awc[maxFloatSize];
double dblValue; VarR8FromCy( _variant.cacy.pElems[iValue], &dblValue );
_cwcRAWValue = swprintf( awc, L"%lf", dblValue );
vString.StrCat( awc, _cwcRAWValue ); }
vString.StrCat( outputFormat.GetCurrencyVectorSuffix() );
_wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } break;
default: { if ( VT_ARRAY & _variant.vt ) { VARTYPE vt = _variant.vt & ~VT_ARRAY;
if ( VT_I1 == vt || VT_UI1 == vt || VT_I2 == vt || VT_UI2 == vt || VT_I4 == vt || VT_UI4 == vt || VT_INT == vt || VT_UINT == vt || VT_I8 == vt || VT_UI8 == vt || VT_R4 == vt || VT_R8 == vt || VT_CY == vt || VT_DECIMAL == vt || VT_ERROR == vt ) _eNumType = eRawNumber;
CVirtualString vString( 0x200 );
RenderSafeArray( vt, _variant.parray, outputFormat, vString, FALSE ); _wcsRAWValue = vString.StrDup(); _cwcRAWValue = vString.StrLen(); } else { _wcsRAWValue = _wcsNumberValue; *_wcsRAWValue = 0; _cwcRAWValue = 0;
ciGibDebugOut(( DEB_WARN, "Type %u not supported in out column", _variant.vt )); } } break; } }
#if (DBG == 1)
if ( _wcsRAWValue != 0 ) { Win4Assert( wcslen(_wcsRAWValue) == _cwcRAWValue ); }#endif // DBG == 1
Win4Assert( !(_wcsRAWValue == 0 && _cwcRAWValue != 0) );
cwcValue = _cwcRAWValue; return _wcsRAWValue;}
//+---------------------------------------------------------------------------
//
// Member: CVariable::DupStringValue - public
//
// Synopsis: Makes a copy of the string value of this variable
//
// Returns: A pointer to a string representation of the variable's value.
//
// History: 96/Mar/07 DwightKr Created.
//
//----------------------------------------------------------------------------
WCHAR * CVariable::DupStringValue( COutputFormat & outputFormat ){ ULONG cwcValue; WCHAR * wcsValue = GetStringValueRAW( outputFormat, cwcValue );
WCHAR * wcsCopyOfValue = new WCHAR[ cwcValue + 1 ]; RtlCopyMemory( wcsCopyOfValue, wcsValue, (cwcValue+1) * sizeof(WCHAR) );
return wcsCopyOfValue;}
//+---------------------------------------------------------------------------
//
// Member: CVariable::IsDirectlyComparable - public
//
// Synopsis: Not all VT types are are numbers. This is useful when
// attempting to compare different VT_TYPES.
//
// Returns: TRUE if the variable can be represented as a number, FALSE
// for strings, blobs, etc.
//
// History: 96/Jan/03 DwightKr Created.
//
//----------------------------------------------------------------------------
BOOL CVariable::IsDirectlyComparable() const{ switch ( _variant.vt & ( ~VT_VECTOR ) ) { case VT_UI1: case VT_I1: case VT_UI2: case VT_I2: case VT_UI4: case VT_I4: case VT_UINT: case VT_INT: case VT_R4: case VT_R8: case VT_I8: case VT_UI8: case VT_BOOL: case VT_CY: case VT_DATE: case VT_FILETIME: case VT_DECIMAL: return TRUE; }
return FALSE;}
//+---------------------------------------------------------------------------
//
// Member: CVariableSet::SetVariable - public
//
// Synopsis: A assignment operator; allows the value of a variable to
// be changed.
//
// Arguments: [wcsName] - the variable name
// [pVariant] - new value for this variable
// [ulCreateFlags] - and flags associated with this variable;
// such as requiring an IRowsetScroll
//
// History: 96/Jan/03 DwightKr Created.
// 96/Apr/11 DwightKr Set back link
//
//----------------------------------------------------------------------------
CVariable * CVariableSet::SetVariable( WCHAR const * wcsName, PROPVARIANT const * pVariant, ULONG ulCreateFlags ){ Win4Assert( 0 != wcsName );
ULONG ulHash = ISAPIVariableNameHash( wcsName ); CVariable *pVariable = Find(wcsName, ulHash);
if ( 0 != pVariable ) { pVariable->SetValue( pVariant, ulCreateFlags ); } else { pVariable = new CVariable( wcsName, pVariant, ulCreateFlags );
pVariable->SetNext( _variableSet[ ulHash ] ); if ( 0 != pVariable->GetNext() ) { pVariable->GetNext()->SetBack( pVariable ); }
_variableSet[ ulHash ] = pVariable; }
return pVariable;}
//+---------------------------------------------------------------------------
//
// Member: CVariableSet::CopyStringValue - public
//
// Synopsis: A assignment operator; allows the value of a variable to
// be changed.
//
// Arguments: [wcsName] - the variable name
// [wcsValue] - value of the variable
// [ulCreateFlags] - and flags associated with this variable;
// such as requiring an IRowsetScroll
// [cwcValue] - # of chars in wcsValue or 0 if unknown
//
// History: 96/Jan/03 DwightKr Created.
//
//----------------------------------------------------------------------------
void CVariableSet::CopyStringValue( WCHAR const * wcsName, WCHAR const * wcsValue, ULONG ulCreateFlags, ULONG cwcValue ){ Win4Assert( 0 != wcsName ); Win4Assert( 0 != wcsValue );
if ( 0 == cwcValue ) cwcValue = wcslen( wcsValue );
cwcValue++;
XArray<WCHAR> wcsCopyOfValue( cwcValue ); RtlCopyMemory( wcsCopyOfValue.Get(), wcsValue, cwcValue * sizeof(WCHAR) );
PROPVARIANT propVariant; propVariant.vt = VT_LPWSTR; propVariant.pwszVal = wcsCopyOfValue.Get();
SetVariable( wcsName, &propVariant, ulCreateFlags | eParamOwnsVariantMemory );
wcsCopyOfValue.Acquire();}
//+---------------------------------------------------------------------------
//
// Member: CVariableSet::AcquireStringValue - public
//
// Synopsis: A assignment operator; allows the value of a variable to
// be changed. Ownership of wcsValue is transferred.
//
// Arguments: [wcsName] - the variable name
// [wcsValue] - value of this variable
// [ulCreateFlags] - and flags associated with this variable;
//
// History: 96/Jan/03 DwightKr Created.
//
//----------------------------------------------------------------------------
void CVariableSet::AcquireStringValue( WCHAR const * wcsName, WCHAR * wcsValue, ULONG ulCreateFlags ){ Win4Assert( 0 != wcsName ); Win4Assert( 0 != wcsValue );
PROPVARIANT propVariant; propVariant.vt = VT_LPWSTR; propVariant.pwszVal = wcsValue;
SetVariable( wcsName, &propVariant, ulCreateFlags | eParamOwnsVariantMemory );}
void CVariableSet::SetVariable( WCHAR const * wcsName, XArray<WCHAR> & xValue ){ Win4Assert( 0 != wcsName ); Win4Assert( 0 != xValue.Get() );
PROPVARIANT propVariant; propVariant.vt = VT_LPWSTR; propVariant.pwszVal = xValue.Get();
SetVariable( wcsName, &propVariant, eParamOwnsVariantMemory );
xValue.Acquire();}
//+---------------------------------------------------------------------------
//
// Member: CVariableSet::AddVariableSet - public
//
// Synopsis: Adds all variables in the variableSet to this variableSet.
//
// Arguments: [variableSet] - the variableSet to add
//
// History: 96/Jan/03 DwightKr Created.
//
//----------------------------------------------------------------------------
void CVariableSet::AddVariableSet( CVariableSet & variableSet, COutputFormat & outputFormat ){ for ( CVariableSetIter iter(variableSet); !iter.AtEnd(); iter.Next() ) { CVariable * pVariable = iter.Get();
SetVariable( pVariable->GetName(), pVariable->GetValue(), pVariable->GetFlags() ); }}
//+---------------------------------------------------------------------------
//
// Member: CVariableSet::CVariableSet - copy constructor
//
// Synopsis: makes a copy of the variableSet
//
// Arguments: [variableSet] - the variableSet to copy
//
// History: 96/Jan/03 DwightKr Created.
// 96/Apr/11 DwightKr Set back link
//
//----------------------------------------------------------------------------
CVariableSet::CVariableSet( const CVariableSet & variableSet ){ RtlZeroMemory( _variableSet, sizeof _variableSet );
for ( CVariableSetIter iter(variableSet); !iter.AtEnd(); iter.Next() ) { CVariable * pVariable = iter.Get(); CVariable * pNewVariable = new CVariable( *pVariable );
XPtr<CVariable> xNewVariable(pNewVariable);
ULONG ulHash = ISAPIVariableNameHash( pNewVariable->GetName() );
//
// Set NEXT & BACK pointers in the hash chain
//
pNewVariable->SetNext( _variableSet[ ulHash ] ); if ( 0 != pNewVariable->GetNext() ) { pNewVariable->GetNext()->SetBack( pNewVariable ); }
_variableSet[ ulHash ] = pNewVariable;
xNewVariable.Acquire(); }}
//+---------------------------------------------------------------------------
//
// Member: CVariableSet::GetValue - public
//
// Synopsis: Gets the value of the variable whose name is specified.
//
// Arguments: [wcsName] - the variable name to return a value for
//
// Returns: PROPVARIANT * to the variable, 0 if no variable with this name.
//
// History: 96/Jan/03 DwightKr Created.
//
//----------------------------------------------------------------------------
PROPVARIANT * CVariableSet::GetValue( WCHAR const * wcsName ) const{ CVariable * pVariable = Find( wcsName );
if ( pVariable ) return pVariable->GetValue(); else return 0;}
//+---------------------------------------------------------------------------
//
// Member: CVariableSet::GetStringValueRAW - public
//
// Synopsis: Gets the string value of the variable whose name is specified.
//
// Arguments: [wcsName] - the variable name to return a value for
//
// Returns: WCHAR * to the variable's string representation, 0 if no
// variable with this name.
//
// History: 96/Jan/03 DwightKr Created.
//
//----------------------------------------------------------------------------
WCHAR const * CVariableSet::GetStringValueRAW( WCHAR const * wcsName, ULONG ulHash, COutputFormat & outputFormat, ULONG & cwcValue ){ CVariable * pVariable = Find(wcsName, ulHash);
if ( pVariable ) return pVariable->GetStringValueRAW( outputFormat, cwcValue ); else return 0;}
//+---------------------------------------------------------------------------
//
// Member: CVariableSet::AddExtensionControlBlock
//
// Synopsis: Adds QUERY_STRING or STDIN buffer to variable set
//
// Arguments: [webServer] - extension control block to add to variableSet
//
// History: 03-Jan-96 DwightKr Created.
// 11-Jun-97 KyleP Take codepage from web server
// 11-Sep-98 KLam Assert that method is GET or POST
//
//----------------------------------------------------------------------------
void CVariableSet::AddExtensionControlBlock( CWebServer & webServer ){ //
// Determine if the user has passed the variables via a GET or POST
//
//
// We support only the GET and POST methods
//
BYTE * pszBuffer; ULONG cbBuffer;
XArray<BYTE> xTemp;
if ( strcmp( webServer.GetMethod(), "GET" ) == 0 ) { pszBuffer = (BYTE *) webServer.GetQueryString(); cbBuffer = strlen( (char *)pszBuffer ); } else if ( strcmp( webServer.GetMethod(), "POST" ) == 0 ) { pszBuffer = (BYTE *) webServer.GetClientData( cbBuffer );
// posts aren't null terminated, and we expect them to be.
xTemp.Init( cbBuffer + 1 ); RtlCopyMemory( xTemp.GetPointer(), pszBuffer, cbBuffer ); xTemp[cbBuffer] = 0; pszBuffer = xTemp.Get(); } else { //
// The validity of the method should have been checked before
//
Win4Assert ( strcmp( webServer.GetMethod(), "GET" ) == 0 || strcmp( webServer.GetMethod(), "POST" ) == 0); }
ciGibDebugOut(( DEB_ITRACE, "QUERY_STRING = %s\n", pszBuffer ));
// NOTE: The pszBuffer is pointing to strings in the ECB. We
// shouldn't modify these strings.
if ( cbBuffer > 0 ) { //
// Strip off trailing control characters, such as \n\r
//
while ( (cbBuffer > 0) && (pszBuffer[cbBuffer-1] <= ' ') ) { cbBuffer--; }
//
// Setup the QUERY_STRING variable in our variableSet
//
XArray<WCHAR> wcsQueryString; ULONG cwcBuffer = MultiByteToXArrayWideChar( (BYTE * const) pszBuffer, cbBuffer + 1, webServer.CodePage(), wcsQueryString );
Win4Assert( cwcBuffer != 0 && cwcBuffer <= (cbBuffer+1) ); wcsQueryString[ cwcBuffer ] = L'\0';
PROPVARIANT Variant; Variant.vt = VT_LPWSTR; Variant.pwszVal = wcsQueryString.Get(); SetVariable( ISAPI_QUERY_STRING, &Variant, eParamOwnsVariantMemory );
wcsQueryString.Acquire(); }
//
// Parse the string, which has the following format:
//
//
// attr1=Value1&attr2=value2&attr3=value+%7c+0&foo&bar
//
CHAR * pszToken = (CHAR *)pszBuffer; while ( (0 != pszToken) && (0 != *pszToken) ) { //
// Find the value on the right hand side of the equal sign.
//
CHAR *pszAttribute = pszToken; CHAR *pszValue = strchr( pszAttribute, '=' );
if ( 0 != pszValue ) { ULONG cchAttribute = (ULONG)(pszValue - pszAttribute); pszValue++;
// Point to the next attribute.
pszToken = strchr( pszToken, '&' );
ULONG cchValue;
if ( 0 != pszToken ) { if ( pszToken < pszValue ) { //
// We have a construction like foo&bar=value. Skip the
// 'foo' part.
//
pszToken++; continue; } cchValue = (ULONG)(pszToken - pszValue); pszToken++; } else { cchValue = (ULONG)((CHAR *)&pszBuffer[cbBuffer] - pszValue); }
WCHAR wcsAttribute[200]; if ( cchAttribute >= ( sizeof wcsAttribute / sizeof WCHAR ) ) THROW( CException( DB_E_ERRORSINCOMMAND ) );
DecodeURLEscapes( (BYTE *) pszAttribute, cchAttribute, wcsAttribute, webServer.CodePage() );
if ( 0 == cchAttribute ) THROW( CException( DB_E_ERRORSINCOMMAND ) );
DecodeHtmlNumeric( wcsAttribute );
//
// We could use Win32 for uppercasing the string, but we're looking for a fixed
// set of attributes that are known to be in this character set.
//
_wcsupr( wcsAttribute );
XArray<WCHAR> wcsValue( cchValue+2 );
DecodeURLEscapes( (BYTE *) pszValue, cchValue, wcsValue.Get(), webServer.CodePage() );
if ( 0 != cchValue ) { DecodeHtmlNumeric( wcsValue.Get() ); }
ciGibDebugOut(( DEB_ITRACE, "From browser, setting %ws=%ws\n", wcsAttribute, wcsValue.Get() ));
SetVariable( wcsAttribute, wcsValue ); } else { //
// There was an & and no =, so it looked like one of the following:
// &&&&&&&&&&&&&&&&&&&&&&&&&&&
// &asdfasdfasdfasdfasdfasdfas
// Most likely, this is a lame DOS attack. Just bail on it.
//
pszToken = 0; } }}
//+---------------------------------------------------------------------------
//
// Member: ISAPIVariableNameHash - public
//
// Synopsis: Generates a hash for the name specified
//
// Arguments: [pwcName] - the variable name to hash
//
// Returns: ULONG - hash of the name
//
// History: 96/Jan/03 DwightKr Created.
//
//
//----------------------------------------------------------------------------
ULONG ISAPIVariableNameHash( WCHAR const * pwcName ){ Win4Assert( 0 != pwcName ); WCHAR const *pwcStart = pwcName;
ULONG ulHash = 0;
while ( 0 != *pwcName ) { ulHash <<= 1; ulHash += *pwcName; pwcName++; }
ulHash <<= 1; ulHash += (ULONG)( pwcName - pwcStart );
return ulHash % VARIABLESET_HASH_TABLE_SIZE;}
//+---------------------------------------------------------------------------
//
// Member: CVariableSet::~CVariableSet - public
//
// Synopsis: Deletes the variables in the set.
//
// History: 96/Apr/03 dlee Created.
//
//
//----------------------------------------------------------------------------
CVariableSet::~CVariableSet(){ // Variables delete the next in their chain, so only delete the
// start of each hash chain.
for ( unsigned x = 0; x < VARIABLESET_HASH_TABLE_SIZE; x++ ) delete _variableSet[ x ];}
//+---------------------------------------------------------------------------
//
// Member: CVariableSet::Find
//
// Synopsis: Locates a variable in the variableSet with the given name
//
// Arguments: [wcsName] - name of variable to find
// [ulHash] - hashed value of the name
//
// Returns: pVariable if found, 0 otherwise
//
// History: 96/Apr/11 DwightKr Created.
//
//----------------------------------------------------------------------------
CVariable * CVariableSet::Find( WCHAR const * wcsName, ULONG ulHash ) const{ Win4Assert( ulHash == ISAPIVariableNameHash(wcsName) );
//
// Walk down the chain and try to find a match
// Note: Variable names have been converted to upper case before
// we got this far. Hence, the case insensitive string
// comparison.
//
for ( CVariable * pVariable = _variableSet[ ulHash ]; pVariable != 0; pVariable = pVariable->GetNext() ) { Win4Assert( pVariable != 0);
if ( wcscmp(wcsName, pVariable->GetName() ) == 0 ) { return pVariable; } }
return 0;}
//+---------------------------------------------------------------------------
//
// Member: CVariableSet::Delete
//
// Synopsis: Deletes a single variable from a variableSet
//
// Arguments: [pVariable] - pointer to variable to delete
//
// History: 96/Apr/11 DwightKr Created.
//
//----------------------------------------------------------------------------
void CVariableSet::Delete( CVariable * pVariable ){ Win4Assert ( 0 != pVariable );
ULONG ulHash = ISAPIVariableNameHash( pVariable->GetName() ); Win4Assert( Find(pVariable->GetName(), ulHash) == pVariable );
//
// If there is a variable before this one in the hash chain, set its
// next pointer.
//
if ( 0 != pVariable->GetBack() ) { pVariable->GetBack()->SetNext( pVariable->GetNext() ); }
//
// If there is a variable after this one in the hash chain, set its
// back pointer.
//
if ( 0 != pVariable->GetNext() ) { pVariable->GetNext()->SetBack( pVariable->GetBack() ); }
//
// Update the array
//
if ( _variableSet[ulHash] == pVariable ) { _variableSet[ulHash] = pVariable->GetNext(); }
pVariable->SetNext(0); pVariable->SetBack(0);
delete pVariable;}
#if (DBG == 1)
//+---------------------------------------------------------------------------
//
// Member: CVariableSet::Dump
//
// Synopsis: Appends each of the variables to the virtual string supplied
//
// Arguments: [string] - string to append data to
//
// History: 96/Jan/03 DwightKr Created.
//
//----------------------------------------------------------------------------
void CVariableSet::Dump( CVirtualString & wcsString, COutputFormat & outputFormat ){ for (CVariableSetIter iter(*this); !iter.AtEnd(); iter.Next() ) { CVariable *pVariable = iter.Get();
wcsString.StrCat( pVariable->GetName() );
wcsString.CharCat( L'=' );
ULONG cwcValue; WCHAR * wcsValue = pVariable->GetStringValueRAW( outputFormat, cwcValue); wcsString.StrCat( wcsValue, cwcValue );
wcsString.StrCat( L"<BR>\n" ); }}#endif // DBG == 1
|
