/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <config_features.h>
#include <math.h>
#include <tools/debug.hxx>
#include <tools/stream.hxx>
#include <sal/log.hxx>
#include <basic/sbx.hxx>
#include <sbunoobj.hxx>
#include "sbxconv.hxx"
#include <runtime.hxx>
///////////////////////////// constructors
SbxValue::SbxValue() : SbxBase()
{
aData.eType = SbxEMPTY;
}
SbxValue::SbxValue( SbxDataType t ) : SbxBase()
{
int n = t & 0x0FFF;
if( n == SbxVARIANT )
n = SbxEMPTY;
else
SetFlag( SbxFlagBits::Fixed );
aData.clear(SbxDataType( n ));
}
SbxValue::SbxValue( const SbxValue& r )
: SvRefBase( r ), SbxBase( r )
{
if( !r.CanRead() )
{
SetError( ERRCODE_BASIC_PROP_WRITEONLY );
if( !IsFixed() )
aData.eType = SbxNULL;
}
else
{
const_cast<SbxValue*>(&r)->Broadcast( SfxHintId::BasicDataWanted );
aData = r.aData;
// Copy pointer, increment references
switch( aData.eType )
{
case SbxSTRING:
if( aData.pOUString )
aData.pOUString = new OUString( *aData.pOUString );
break;
case SbxOBJECT:
if( aData.pObj )
aData.pObj->AddFirstRef();
break;
case SbxDECIMAL:
if( aData.pDecimal )
aData.pDecimal->addRef();
break;
default: break;
}
}
}
SbxValue& SbxValue::operator=( const SbxValue& r )
{
if( &r != this )
{
if( !CanWrite() )
SetError( ERRCODE_BASIC_PROP_READONLY );
else
{
// string -> byte array
if( IsFixed() && (aData.eType == SbxOBJECT)
&& aData.pObj && ( aData.pObj->GetType() == (SbxARRAY | SbxBYTE) )
&& (r.aData.eType == SbxSTRING) )
{
OUString aStr = r.GetOUString();
SbxArray* pArr = StringToByteArray(aStr);
PutObject(pArr);
return *this;
}
// byte array -> string
if( r.IsFixed() && (r.aData.eType == SbxOBJECT)
&& r.aData.pObj && ( r.aData.pObj->GetType() == (SbxARRAY | SbxBYTE) )
&& (aData.eType == SbxSTRING) )
{
SbxBase* pObj = r.GetObject();
SbxArray* pArr = dynamic_cast<SbxArray*>( pObj );
if( pArr )
{
OUString aStr = ByteArrayToString( pArr );
PutString(aStr);
return *this;
}
}
// Readout the content of the variables
SbxValues aNew;
if( IsFixed() )
// then the type has to match
aNew.eType = aData.eType;
else if( r.IsFixed() )
// Source fixed: copy the type
aNew.eType = SbxDataType( r.aData.eType & 0x0FFF );
else
// both variant: then don't care
aNew.eType = SbxVARIANT;
if( r.Get( aNew ) )
Put( aNew );
}
}
return *this;
}
SbxValue::~SbxValue()
{
SetFlag( SbxFlagBits::Write );
SbxValue::Clear();
}
void SbxValue::Clear()
{
switch( aData.eType )
{
case SbxNULL:
case SbxEMPTY:
case SbxVOID:
break;
case SbxSTRING:
delete aData.pOUString; aData.pOUString = nullptr;
break;
case SbxOBJECT:
if( aData.pObj )
{
if( aData.pObj != this )
{
SAL_INFO("basic.sbx", "Not at Parent-Prop - otherwise CyclicRef");
SbxVariable *pThisVar = dynamic_cast<SbxVariable*>( this );
bool bParentProp = pThisVar && static_cast<sal_uInt16>(pThisVar->GetUserData()) ==
5345;
if ( !bParentProp )
aData.pObj->ReleaseRef();
}
aData.pObj = nullptr;
}
break;
case SbxDECIMAL:
if( aData.eType == SbxDECIMAL )
releaseDecimalPtr( aData.pDecimal );
break;
case SbxDATAOBJECT:
aData.pData = nullptr; break;
default:
{
SbxValues aEmpty;
aEmpty.clear(GetType());
Put( aEmpty );
}
}
}
// Dummy
void SbxValue::Broadcast( SfxHintId )
{}
//////////////////////////// Readout data
// Detect the "right" variables. If it is an object, will be addressed either
// the object itself or its default property.
// If the variable contain a variable or an object, this will be
// addressed.
SbxValue* SbxValue::TheRealValue( bool bObjInObjError ) const
{
SbxValue* p = const_cast<SbxValue*>(this);
for( ;; )
{
SbxDataType t = SbxDataType( p->aData.eType & 0x0FFF );
if( t == SbxOBJECT )
{
// The block contains an object or a variable
SbxObject* pObj = dynamic_cast<SbxObject*>( p->aData.pObj );
if( pObj )
{
// Has the object a default property?
SbxVariable* pDflt = pObj->GetDfltProperty();
// If this is an object and contains itself,
// we cannot access on it
// The old condition to set an error is not correct,
// because e.g. a regular variant variable with an object
// could be affected if another value should be assigned.
// Therefore with flag.
if( bObjInObjError && !pDflt &&
static_cast<SbxValue*>(pObj)->aData.eType == SbxOBJECT &&
static_cast<SbxValue*>(pObj)->aData.pObj == pObj )
{
#if !HAVE_FEATURE_SCRIPTING
const bool bSuccess = false;
#else
bool bSuccess = handleToStringForCOMObjects( pObj, p );
#endif
if( !bSuccess )
{
SetError( ERRCODE_BASIC_BAD_PROP_VALUE );
p = nullptr;
}
}
else if( pDflt )
p = pDflt;
break;
}
// Did we have an array?
SbxArray* pArray = dynamic_cast<SbxArray*>( p->aData.pObj );
if( pArray )
{
// When indicated get the parameter
SbxArray* pPar = nullptr;
SbxVariable* pVar = dynamic_cast<SbxVariable*>( p );
if( pVar )
pPar = pVar->GetParameters();
if( pPar )
{
// Did we have a dimensioned array?
SbxDimArray* pDimArray = dynamic_cast<SbxDimArray*>( p->aData.pObj );
if( pDimArray )
p = pDimArray->Get( pPar );
else
p = pArray->Get( pPar->Get( 1 )->GetInteger() );
break;
}
}
// Otherwise guess a SbxValue
SbxValue* pVal = dynamic_cast<SbxValue*>( p->aData.pObj );
if( pVal )
p = pVal;
else
break;
}
else
break;
}
return p;
}
bool SbxValue::Get( SbxValues& rRes ) const
{
bool bRes = false;
ErrCode eOld = GetError();
if( eOld != ERRCODE_NONE )
ResetError();
if( !CanRead() )
{
SetError( ERRCODE_BASIC_PROP_WRITEONLY );
rRes.pObj = nullptr;
}
else
{
// If an object or a VARIANT is requested, don't search the real values
SbxValue* p = const_cast<SbxValue*>(this);
if( rRes.eType != SbxOBJECT && rRes.eType != SbxVARIANT )
p = TheRealValue( true );
if( p )
{
p->Broadcast( SfxHintId::BasicDataWanted );
switch( rRes.eType )
{
case SbxEMPTY:
case SbxVOID:
case SbxNULL: break;
case SbxVARIANT: rRes = p->aData; break;
case SbxINTEGER: rRes.nInteger = ImpGetInteger( &p->aData ); break;
case SbxLONG: rRes.nLong = ImpGetLong( &p->aData ); break;
case SbxSALINT64: rRes.nInt64 = ImpGetInt64( &p->aData ); break;
case SbxSALUINT64: rRes.uInt64 = ImpGetUInt64( &p->aData ); break;
case SbxSINGLE: rRes.nSingle = ImpGetSingle( &p->aData ); break;
case SbxDOUBLE: rRes.nDouble = ImpGetDouble( &p->aData ); break;
case SbxCURRENCY:rRes.nInt64 = ImpGetCurrency( &p->aData ); break;
case SbxDECIMAL: rRes.pDecimal = ImpGetDecimal( &p->aData ); break;
case SbxDATE: rRes.nDouble = ImpGetDate( &p->aData ); break;
case SbxBOOL:
rRes.nUShort = sal::static_int_cast< sal_uInt16 >(
ImpGetBool( &p->aData ) );
break;
case SbxCHAR: rRes.nChar = ImpGetChar( &p->aData ); break;
case SbxBYTE: rRes.nByte = ImpGetByte( &p->aData ); break;
case SbxUSHORT: rRes.nUShort = ImpGetUShort( &p->aData ); break;
case SbxULONG: rRes.nULong = ImpGetULong( &p->aData ); break;
case SbxLPSTR:
case SbxSTRING: p->aPic = ImpGetString( &p->aData );
rRes.pOUString = &p->aPic; break;
case SbxCoreSTRING: p->aPic = ImpGetCoreString( &p->aData );
rRes.pOUString = &p->aPic; break;
case SbxINT:
rRes.nInt = static_cast<int>(ImpGetLong( &p->aData ));
break;
case SbxUINT:
rRes.nUInt = static_cast<int>(ImpGetULong( &p->aData ));
break;
case SbxOBJECT:
if( p->aData.eType == SbxOBJECT )
rRes.pObj = p->aData.pObj;
else
{
SetError( ERRCODE_BASIC_NO_OBJECT );
rRes.pObj = nullptr;
}
break;
default:
if( p->aData.eType == rRes.eType )
rRes = p->aData;
else
{
SetError( ERRCODE_BASIC_CONVERSION );
rRes.pObj = nullptr;
}
}
}
else
{
// Object contained itself
SbxDataType eTemp = rRes.eType;
rRes.clear(eTemp);
}
}
if( !IsError() )
{
bRes = true;
if( eOld != ERRCODE_NONE )
SetError( eOld );
}
return bRes;
}
const OUString& SbxValue::GetCoreString() const
{
SbxValues aRes;
aRes.eType = SbxCoreSTRING;
if( Get( aRes ) )
{
const_cast<SbxValue*>(this)->aToolString = *aRes.pOUString;
}
else
{
const_cast<SbxValue*>(this)->aToolString.clear();
}
return aToolString;
}
OUString SbxValue::GetOUString() const
{
OUString aResult;
SbxValues aRes;
aRes.eType = SbxSTRING;
if( Get( aRes ) )
{
aResult = *aRes.pOUString;
}
return aResult;
}
bool SbxValue::GetBool() const
{
SbxValues aRes;
aRes.eType = SbxBOOL;
Get( aRes );
return aRes.nUShort != 0;
}
#define GET( g, e, t, m ) \
t SbxValue::g() const { SbxValues aRes(e); Get( aRes ); return aRes.m; }
GET( GetByte, SbxBYTE, sal_uInt8, nByte )
GET( GetChar, SbxCHAR, sal_Unicode, nChar )
GET( GetCurrency, SbxCURRENCY, sal_Int64, nInt64 )
GET( GetDate, SbxDATE, double, nDouble )
GET( GetDouble, SbxDOUBLE, double, nDouble )
GET( GetInteger, SbxINTEGER, sal_Int16, nInteger )
GET( GetLong, SbxLONG, sal_Int32, nLong )
GET( GetObject, SbxOBJECT, SbxBase*, pObj )
GET( GetSingle, SbxSINGLE, float, nSingle )
GET( GetULong, SbxULONG, sal_uInt32, nULong )
GET( GetUShort, SbxUSHORT, sal_uInt16, nUShort )
GET( GetInt64, SbxSALINT64, sal_Int64, nInt64 )
GET( GetUInt64, SbxSALUINT64, sal_uInt64, uInt64 )
GET( GetDecimal, SbxDECIMAL, SbxDecimal*, pDecimal )
//////////////////////////// Write data
bool SbxValue::Put( const SbxValues& rVal )
{
bool bRes = false;
ErrCode eOld = GetError();
if( eOld != ERRCODE_NONE )
ResetError();
if( !CanWrite() )
SetError( ERRCODE_BASIC_PROP_READONLY );
else if( rVal.eType & 0xF000 )
SetError( ERRCODE_BASIC_BAD_ARGUMENT );
else
{
// If an object is requested, don't search the real values
SbxValue* p = this;
if( rVal.eType != SbxOBJECT )
p = TheRealValue( false ); // Don't allow an error here
if( p )
{
if( !p->CanWrite() )
SetError( ERRCODE_BASIC_PROP_READONLY );
else if( p->IsFixed() || p->SetType( static_cast<SbxDataType>( rVal.eType & 0x0FFF ) ) )
switch( rVal.eType & 0x0FFF )
{
case SbxEMPTY:
case SbxVOID:
case SbxNULL: break;
case SbxINTEGER: ImpPutInteger( &p->aData, rVal.nInteger ); break;
case SbxLONG: ImpPutLong( &p->aData, rVal.nLong ); break;
case SbxSALINT64: ImpPutInt64( &p->aData, rVal.nInt64 ); break;
case SbxSALUINT64: ImpPutUInt64( &p->aData, rVal.uInt64 ); break;
case SbxSINGLE: ImpPutSingle( &p->aData, rVal.nSingle ); break;
case SbxDOUBLE: ImpPutDouble( &p->aData, rVal.nDouble ); break;
case SbxCURRENCY: ImpPutCurrency( &p->aData, rVal.nInt64 ); break;
case SbxDECIMAL: ImpPutDecimal( &p->aData, rVal.pDecimal ); break;
case SbxDATE: ImpPutDate( &p->aData, rVal.nDouble ); break;
case SbxBOOL: ImpPutBool( &p->aData, rVal.nInteger ); break;
case SbxCHAR: ImpPutChar( &p->aData, rVal.nChar ); break;
case SbxBYTE: ImpPutByte( &p->aData, rVal.nByte ); break;
case SbxUSHORT: ImpPutUShort( &p->aData, rVal.nUShort ); break;
case SbxULONG: ImpPutULong( &p->aData, rVal.nULong ); break;
case SbxLPSTR:
case SbxSTRING: ImpPutString( &p->aData, rVal.pOUString ); break;
case SbxINT:
ImpPutLong( &p->aData, static_cast<sal_Int32>(rVal.nInt) );
break;
case SbxUINT:
ImpPutULong( &p->aData, static_cast<sal_uInt32>(rVal.nUInt) );
break;
case SbxOBJECT:
if( !p->IsFixed() || p->aData.eType == SbxOBJECT )
{
// is already inside
if( p->aData.eType == SbxOBJECT && p->aData.pObj == rVal.pObj )
break;
// Delete only the value part!
p->SbxValue::Clear();
// real assignment
p->aData.pObj = rVal.pObj;
// if necessary increment Ref-Count
if( p->aData.pObj && p->aData.pObj != p )
{
if ( p != this )
{
OSL_FAIL( "TheRealValue" );
}
SAL_INFO("basic.sbx", "Not at Parent-Prop - otherwise CyclicRef");
SbxVariable *pThisVar = dynamic_cast<SbxVariable*>( this );
bool bParentProp = pThisVar && static_cast<sal_uInt16>(pThisVar->GetUserData()) ==
5345;
if ( !bParentProp )
p->aData.pObj->AddFirstRef();
}
}
else
SetError( ERRCODE_BASIC_CONVERSION );
break;
default:
if( p->aData.eType == rVal.eType )
p->aData = rVal;
else
{
SetError( ERRCODE_BASIC_CONVERSION );
if( !p->IsFixed() )
p->aData.eType = SbxNULL;
}
}
if( !IsError() )
{
p->SetModified( true );
p->Broadcast( SfxHintId::BasicDataChanged );
if( eOld != ERRCODE_NONE )
SetError( eOld );
bRes = true;
}
}
}
return bRes;
}
// From 1996-03-28:
// Method to execute a pretreatment of the strings at special types.
// In particular necessary for BASIC-IDE, so that
// the output in the Watch-Window can be written back with PutStringExt,
// if Float were declared with ',' as the decimal separator or BOOl
// explicit with "TRUE" or "FALSE".
// Implementation in ImpConvStringExt (SBXSCAN.CXX)
void SbxValue::PutStringExt( const OUString& r )
{
// Copy; if it is Unicode convert it immediately
OUString aStr( r );
// Identify the own type (not as in Put() with TheRealValue(),
// Objects are not handled anyway)
SbxDataType eTargetType = SbxDataType( aData.eType & 0x0FFF );
// tinker a Source-Value
SbxValues aRes;
aRes.eType = SbxSTRING;
// Only if really something was converted, take the copy,
// otherwise take the original (Unicode remains)
bool bRet;
if( ImpConvStringExt( aStr, eTargetType ) )
aRes.pOUString = &aStr;
else
aRes.pOUString = const_cast<OUString*>(&r);
// #34939: For Strings which contain a number, and if this has a Num-Type,
// set a Fixed flag so that the type will not be changed
SbxFlagBits nFlags_ = GetFlags();
if( ( eTargetType >= SbxINTEGER && eTargetType <= SbxCURRENCY ) ||
( eTargetType >= SbxCHAR && eTargetType <= SbxUINT ) ||
eTargetType == SbxBOOL )
{
SbxValue aVal;
aVal.Put( aRes );
if( aVal.IsNumeric() )
SetFlag( SbxFlagBits::Fixed );
}
Put( aRes );
bRet = bool( !IsError() );
// If FIXED resulted in an error, set it back
// (UI-Action should not result in an error, but simply fail)
if( !bRet )
ResetError();
SetFlags( nFlags_ );
}
bool SbxValue::PutBool( bool b )
{
SbxValues aRes;
aRes.eType = SbxBOOL;
aRes.nUShort = sal::static_int_cast< sal_uInt16 >(b ? SbxTRUE : SbxFALSE);
Put( aRes );
return !IsError();
}
bool SbxValue::PutEmpty()
{
bool bRet = SetType( SbxEMPTY );
SetModified( true );
return bRet;
}
void SbxValue::PutNull()
{
bool bRet = SetType( SbxNULL );
if( bRet )
SetModified( true );
}
// Special decimal methods
void SbxValue::PutDecimal( css::bridge::oleautomation::Decimal const & rAutomationDec )
{
SbxValue::Clear();
aData.pDecimal = new SbxDecimal( rAutomationDec );
aData.pDecimal->addRef();
aData.eType = SbxDECIMAL;
}
void SbxValue::fillAutomationDecimal
( css::bridge::oleautomation::Decimal& rAutomationDec ) const
{
SbxDecimal* pDecimal = GetDecimal();
if( pDecimal != nullptr )
{
pDecimal->fillAutomationDecimal( rAutomationDec );
}
}
bool SbxValue::PutString( const OUString& r )
{
SbxValues aRes;
aRes.eType = SbxSTRING;
aRes.pOUString = const_cast<OUString*>(&r);
Put( aRes );
return !IsError();
}
#define PUT( p, e, t, m ) \
bool SbxValue::p( t n ) \
{ SbxValues aRes(e); aRes.m = n; Put( aRes ); return !IsError(); }
void SbxValue::PutDate( double n )
{ SbxValues aRes(SbxDATE); aRes.nDouble = n; Put( aRes ); }
void SbxValue::PutErr( sal_uInt16 n )
{ SbxValues aRes(SbxERROR); aRes.nUShort = n; Put( aRes ); }
PUT( PutByte, SbxBYTE, sal_uInt8, nByte )
PUT( PutChar, SbxCHAR, sal_Unicode, nChar )
PUT( PutCurrency, SbxCURRENCY, sal_Int64, nInt64 )
PUT( PutDouble, SbxDOUBLE, double, nDouble )
PUT( PutInteger, SbxINTEGER, sal_Int16, nInteger )
PUT( PutLong, SbxLONG, sal_Int32, nLong )
PUT( PutObject, SbxOBJECT, SbxBase*, pObj )
PUT( PutSingle, SbxSINGLE, float, nSingle )
PUT( PutULong, SbxULONG, sal_uInt32, nULong )
PUT( PutUShort, SbxUSHORT, sal_uInt16, nUShort )
PUT( PutInt64, SbxSALINT64, sal_Int64, nInt64 )
PUT( PutUInt64, SbxSALUINT64, sal_uInt64, uInt64 )
PUT( PutDecimal, SbxDECIMAL, SbxDecimal*, pDecimal )
////////////////////////// Setting of the data type
bool SbxValue::IsFixed() const
{
return (GetFlags() & SbxFlagBits::Fixed) || ((aData.eType & SbxBYREF) != 0);
}
// A variable is numeric, if it is EMPTY or really numeric
// or if it contains a complete convertible String
// #41692, implement it for RTL and Basic-Core separately
bool SbxValue::IsNumeric() const
{
return ImpIsNumeric( /*bOnlyIntntl*/false );
}
bool SbxValue::IsNumericRTL() const
{
return ImpIsNumeric( /*bOnlyIntntl*/true );
}
bool SbxValue::ImpIsNumeric( bool bOnlyIntntl ) const
{
if( !CanRead() )
{
SetError( ERRCODE_BASIC_PROP_WRITEONLY );
return false;
}
// Test downcast!!!
if( dynamic_cast<const SbxVariable*>( this) != nullptr )
const_cast<SbxVariable*>(static_cast<const SbxVariable*>(this))->Broadcast( SfxHintId::BasicDataWanted );
SbxDataType t = GetType();
if( t == SbxSTRING )
{
if( aData.pOUString )
{
OUString s( *aData.pOUString );
double n;
SbxDataType t2;
sal_uInt16 nLen = 0;
if( ImpScan( s, n, t2, &nLen, bOnlyIntntl ) == ERRCODE_NONE )
return nLen == s.getLength();
}
return false;
}
else
return t == SbxEMPTY
|| ( t >= SbxINTEGER && t <= SbxCURRENCY )
|| ( t >= SbxCHAR && t <= SbxUINT );
}
SbxClassType SbxValue::GetClass() const
{
return SbxClassType::Value;
}
SbxDataType SbxValue::GetType() const
{
return SbxDataType( aData.eType & 0x0FFF );
}
bool SbxValue::SetType( SbxDataType t )
{
DBG_ASSERT( !( t & 0xF000 ), "SetType of BYREF|ARRAY is forbidden!" );
if( ( t == SbxEMPTY && aData.eType == SbxVOID )
|| ( aData.eType == SbxEMPTY && t == SbxVOID ) )
return true;
if( ( t & 0x0FFF ) == SbxVARIANT )
{
// Try to set the data type to Variant
ResetFlag( SbxFlagBits::Fixed );
if( IsFixed() )
{
SetError( ERRCODE_BASIC_CONVERSION );
return false;
}
t = SbxEMPTY;
}
if( ( t & 0x0FFF ) != ( aData.eType & 0x0FFF ) )
{
if( !CanWrite() || IsFixed() )
{
SetError( ERRCODE_BASIC_CONVERSION );
return false;
}
else
{
// De-allocate potential objects
switch( aData.eType )
{
case SbxSTRING:
delete aData.pOUString;
break;
case SbxOBJECT:
if( aData.pObj && aData.pObj != this )
{
SAL_WARN("basic.sbx", "Not at Parent-Prop - otherwise CyclicRef");
SbxVariable *pThisVar = dynamic_cast<SbxVariable*>( this );
sal_uInt16 nSlotId = pThisVar
? static_cast<sal_uInt16>(pThisVar->GetUserData())
: 0;
DBG_ASSERT( nSlotId != 5345 || pThisVar->GetName() == "Parent",
"SID_PARENTOBJECT is not named 'Parent'" );
bool bParentProp = nSlotId == 5345;
if ( !bParentProp )
aData.pObj->ReleaseRef();
}
break;
default: break;
}
aData.clear(t);
}
}
return true;
}
bool SbxValue::Convert( SbxDataType eTo )
{
eTo = SbxDataType( eTo & 0x0FFF );
if( ( aData.eType & 0x0FFF ) == eTo )
return true;
if( !CanWrite() )
return false;
if( eTo == SbxVARIANT )
{
// Trial to set the data type to Variant
ResetFlag( SbxFlagBits::Fixed );
if( IsFixed() )
{
SetError( ERRCODE_BASIC_CONVERSION );
return false;
}
else
return true;
}
// Converting from null doesn't work. Once null, always null!
if( aData.eType == SbxNULL )
{
SetError( ERRCODE_BASIC_CONVERSION );
return false;
}
// Conversion of the data:
SbxValues aNew;
aNew.eType = eTo;
if( Get( aNew ) )
{
// The data type could be converted. It ends here with fixed elements,
// because the data had not to be taken over
if( !IsFixed() )
{
SetType( eTo );
Put( aNew );
SetModified( true );
}
return true;
}
else
return false;
}
////////////////////////////////// Calculating
bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp )
{
#if !HAVE_FEATURE_SCRIPTING
const bool bVBAInterop = false;
#else
bool bVBAInterop = SbiRuntime::isVBAEnabled();
#endif
SbxDataType eThisType = GetType();
SbxDataType eOpType = rOp.GetType();
ErrCode eOld = GetError();
if( eOld != ERRCODE_NONE )
ResetError();
if( !CanWrite() )
SetError( ERRCODE_BASIC_PROP_READONLY );
else if( !rOp.CanRead() )
SetError( ERRCODE_BASIC_PROP_WRITEONLY );
// Special rule 1: If one operand is null, the result is null
else if( eThisType == SbxNULL || eOpType == SbxNULL )
SetType( SbxNULL );
// Special rule 2: If the operand is Empty, the result is the 2. operand
else if( eThisType == SbxEMPTY
&& !bVBAInterop
)
*this = rOp;
// 1996-2-13: Don't test for SbxEMPTY before Get
else
{
SbxValues aL, aR;
bool bDecimal = false;
if( bVBAInterop && ( ( eThisType == SbxSTRING && eOpType != SbxSTRING && eOpType != SbxEMPTY ) ||
( eThisType != SbxSTRING && eThisType != SbxEMPTY && eOpType == SbxSTRING ) ) &&
( eOp == SbxMUL || eOp == SbxDIV || eOp == SbxPLUS || eOp == SbxMINUS ) )
{
goto Lbl_OpIsDouble;
}
else if( eThisType == SbxSTRING || eOp == SbxCAT || ( bVBAInterop && ( eOpType == SbxSTRING ) && ( eOp == SbxPLUS ) ) )
{
if( eOp == SbxCAT || eOp == SbxPLUS )
{
// From 1999-11-5, keep OUString in mind
aL.eType = aR.eType = SbxSTRING;
rOp.Get( aR );
// From 1999-12-8, #70399: Here call GetType() again, Get() can change the type!
if( rOp.GetType() == SbxEMPTY )
goto Lbl_OpIsEmpty;
Get( aL );
// #30576: To begin with test, if the conversion worked
if( aL.pOUString != nullptr && aR.pOUString != nullptr )
{
// tdf#108039: catch possible bad_alloc
try {
*aL.pOUString += *aR.pOUString;
}
catch (const std::bad_alloc&) {
SetError(ERRCODE_BASIC_MATH_OVERFLOW);
}
}
// Not even Left OK?
else if( aL.pOUString == nullptr )
{
aL.pOUString = new OUString();
}
}
else
SetError( ERRCODE_BASIC_CONVERSION );
}
else if( eOpType == SbxSTRING && rOp.IsFixed() )
{ // Numeric: there is no String allowed on the right side
SetError( ERRCODE_BASIC_CONVERSION );
// falls all the way out
}
else if( ( eOp >= SbxIDIV && eOp <= SbxNOT ) || eOp == SbxMOD )
{
if( GetType() == eOpType )
{
if( GetType() == SbxSALUINT64 || GetType() == SbxSALINT64
|| GetType() == SbxCURRENCY || GetType() == SbxULONG )
aL.eType = aR.eType = GetType();
else if ( bVBAInterop && eOpType == SbxBOOL )
aL.eType = aR.eType = SbxBOOL;
else
aL.eType = aR.eType = SbxLONG;
}
else
aL.eType = aR.eType = SbxLONG;
if( rOp.Get( aR ) ) // re-do Get after type assigns above
{
if( rOp.GetType() == SbxEMPTY )
{
if ( !bVBAInterop || ( eOp != SbxNOT ) )
goto Lbl_OpIsEmpty;
}
if( Get( aL ) ) switch( eOp )
{
case SbxIDIV:
if( aL.eType == SbxCURRENCY )
if( !aR.nInt64 ) SetError( ERRCODE_BASIC_ZERODIV );
else {
aL.nInt64 /= aR.nInt64;
aL.nInt64 *= CURRENCY_FACTOR;
}
else if( aL.eType == SbxSALUINT64 )
if( !aR.uInt64 ) SetError( ERRCODE_BASIC_ZERODIV );
else aL.uInt64 /= aR.uInt64;
else if( aL.eType == SbxSALINT64 )
if( !aR.nInt64 ) SetError( ERRCODE_BASIC_ZERODIV );
else aL.nInt64 /= aR.nInt64;
else if( aL.eType == SbxLONG )
if( !aR.nLong ) SetError( ERRCODE_BASIC_ZERODIV );
else aL.nLong /= aR.nLong;
else
if( !aR.nULong ) SetError( ERRCODE_BASIC_ZERODIV );
else aL.nULong /= aR.nULong;
break;
case SbxMOD:
if( aL.eType == SbxCURRENCY || aL.eType == SbxSALINT64 )
if( !aR.nInt64 ) SetError( ERRCODE_BASIC_ZERODIV );
else aL.nInt64 %= aR.nInt64;
else if( aL.eType == SbxSALUINT64 )
if( !aR.uInt64 ) SetError( ERRCODE_BASIC_ZERODIV );
else aL.uInt64 %= aR.uInt64;
else if( aL.eType == SbxLONG )
if( !aR.nLong ) SetError( ERRCODE_BASIC_ZERODIV );
else aL.nLong %= aR.nLong;
else
if( !aR.nULong ) SetError( ERRCODE_BASIC_ZERODIV );
else aL.nULong %= aR.nULong;
break;
case SbxAND:
if( aL.eType != SbxLONG && aL.eType != SbxULONG )
aL.nInt64 &= aR.nInt64;
else
aL.nLong &= aR.nLong;
break;
case SbxOR:
if( aL.eType != SbxLONG && aL.eType != SbxULONG )
aL.nInt64 |= aR.nInt64;
else
aL.nLong |= aR.nLong;
break;
case SbxXOR:
if( aL.eType != SbxLONG && aL.eType != SbxULONG )
aL.nInt64 ^= aR.nInt64;
else
aL.nLong ^= aR.nLong;
break;
case SbxEQV:
if( aL.eType != SbxLONG && aL.eType != SbxULONG )
aL.nInt64 = (aL.nInt64 & aR.nInt64) | (~aL.nInt64 & ~aR.nInt64);
else
aL.nLong = (aL.nLong & aR.nLong) | (~aL.nLong & ~aR.nLong);
break;
case SbxIMP:
if( aL.eType != SbxLONG && aL.eType != SbxULONG )
aL.nInt64 = ~aL.nInt64 | aR.nInt64;
else
aL.nLong = ~aL.nLong | aR.nLong;
break;
case SbxNOT:
if( aL.eType != SbxLONG && aL.eType != SbxULONG )
{
if ( aL.eType != SbxBOOL )
aL.nInt64 = ~aL.nInt64;
else
aL.nLong = ~aL.nLong;
}
else
aL.nLong = ~aL.nLong;
break;
default: break;
}
}
}
else if( ( GetType() == SbxDECIMAL || rOp.GetType() == SbxDECIMAL )
&& ( eOp == SbxMUL || eOp == SbxDIV || eOp == SbxPLUS || eOp == SbxMINUS || eOp == SbxNEG ) )
{
aL.eType = aR.eType = SbxDECIMAL;
bDecimal = true;
if( rOp.Get( aR ) )
{
if( rOp.GetType() == SbxEMPTY )
{
releaseDecimalPtr( aL.pDecimal );
goto Lbl_OpIsEmpty;
}
if( Get( aL ) )
{
if( aL.pDecimal && aR.pDecimal )
{
bool bOk = true;
switch( eOp )
{
case SbxMUL:
bOk = ( *(aL.pDecimal) *= *(aR.pDecimal) );
break;
case SbxDIV:
if( aR.pDecimal->isZero() )
SetError( ERRCODE_BASIC_ZERODIV );
else
bOk = ( *(aL.pDecimal) /= *(aR.pDecimal) );
break;
case SbxPLUS:
bOk = ( *(aL.pDecimal) += *(aR.pDecimal) );
break;
case SbxMINUS:
bOk = ( *(aL.pDecimal) -= *(aR.pDecimal) );
break;
case SbxNEG:
bOk = ( aL.pDecimal->neg() );
break;
default:
SetError( ERRCODE_BASIC_BAD_ARGUMENT );
}
if( !bOk )
SetError( ERRCODE_BASIC_MATH_OVERFLOW );
}
else
{
SetError( ERRCODE_BASIC_CONVERSION );
}
}
}
}
else if( GetType() == SbxCURRENCY || rOp.GetType() == SbxCURRENCY )
{
aL.eType = SbxCURRENCY;
aR.eType = SbxCURRENCY;
if( rOp.Get( aR ) )
{
if( rOp.GetType() == SbxEMPTY )
goto Lbl_OpIsEmpty;
if( Get( aL ) ) switch( eOp )
{
case SbxMUL:
{
// first overflow check: see if product will fit - test real value of product (hence 2 curr factors)
double dTest = static_cast<double>(aL.nInt64) * static_cast<double>(aR.nInt64) / double(CURRENCY_FACTOR_SQUARE);
if( dTest < SbxMINCURR || SbxMAXCURR < dTest)
{
aL.nInt64 = SAL_MAX_INT64;
if( dTest < SbxMINCURR ) aL.nInt64 = SAL_MIN_INT64;
SetError( ERRCODE_BASIC_MATH_OVERFLOW );
break;
}
// second overflow check: see if unscaled product overflows - if so use doubles
dTest = static_cast<double>(aL.nInt64) * static_cast<double>(aR.nInt64);
if( dTest < SAL_MIN_INT64 || SAL_MAX_INT64 < dTest)
{
aL.nInt64 = static_cast<sal_Int64>( dTest / double(CURRENCY_FACTOR) );
break;
}
// precise calc: multiply then scale back (move decimal pt)
aL.nInt64 *= aR.nInt64;
aL.nInt64 /= CURRENCY_FACTOR;
break;
}
case SbxDIV:
{
if( !aR.nInt64 )
{
SetError( ERRCODE_BASIC_ZERODIV );
break;
}
// first overflow check: see if quotient will fit - calc real value of quotient (curr factors cancel)
double dTest = static_cast<double>(aL.nInt64) / static_cast<double>(aR.nInt64);
if( dTest < SbxMINCURR || SbxMAXCURR < dTest)
{
SetError( ERRCODE_BASIC_MATH_OVERFLOW );
break;
}
// second overflow check: see if scaled dividend overflows - if so use doubles
dTest = static_cast<double>(aL.nInt64) * double(CURRENCY_FACTOR);
if( dTest < SAL_MIN_INT64 || SAL_MAX_INT64 < dTest)
{
aL.nInt64 = static_cast<sal_Int64>(dTest / static_cast<double>(aR.nInt64));
break;
}
// precise calc: scale (move decimal pt) then divide
aL.nInt64 *= CURRENCY_FACTOR;
aL.nInt64 /= aR.nInt64;
break;
}
case SbxPLUS:
{
double dTest = ( static_cast<double>(aL.nInt64) + static_cast<double>(aR.nInt64) ) / double(CURRENCY_FACTOR);
if( dTest < SbxMINCURR || SbxMAXCURR < dTest)
{
SetError( ERRCODE_BASIC_MATH_OVERFLOW );
break;
}
aL.nInt64 += aR.nInt64;
break;
}
case SbxMINUS:
{
double dTest = ( static_cast<double>(aL.nInt64) - static_cast<double>(aR.nInt64) ) / double(CURRENCY_FACTOR);
if( dTest < SbxMINCURR || SbxMAXCURR < dTest)
{
SetError( ERRCODE_BASIC_MATH_OVERFLOW );
break;
}
aL.nInt64 -= aR.nInt64;
break;
}
case SbxNEG:
aL.nInt64 = -aL.nInt64;
break;
default:
SetError( ERRCODE_BASIC_BAD_ARGUMENT );
}
}
}
else
Lbl_OpIsDouble:
{ // other types and operators including Date, Double and Single
aL.eType = aR.eType = SbxDOUBLE;
if( rOp.Get( aR ) )
{
if( rOp.GetType() == SbxEMPTY )
{
if ( !bVBAInterop || ( eOp != SbxNEG ) )
goto Lbl_OpIsEmpty;
}
if( Get( aL ) )
{
switch( eOp )
{
case SbxEXP:
aL.nDouble = pow( aL.nDouble, aR.nDouble );
break;
case SbxMUL:
aL.nDouble *= aR.nDouble; break;
case SbxDIV:
if( !aR.nDouble ) SetError( ERRCODE_BASIC_ZERODIV );
else aL.nDouble /= aR.nDouble;
break;
case SbxPLUS:
aL.nDouble += aR.nDouble; break;
case SbxMINUS:
aL.nDouble -= aR.nDouble; break;
case SbxNEG:
aL.nDouble = -aL.nDouble; break;
default:
SetError( ERRCODE_BASIC_BAD_ARGUMENT );
}
// Date with "+" or "-" needs special handling that
// forces the Date type. If the operation is '+' the
// result is always a Date, if '-' the result is only
// a Date if one of lhs or rhs ( but not both ) is already
// a Date
if( GetType() == SbxDATE || rOp.GetType() == SbxDATE )
{
if( eOp == SbxPLUS || ( ( eOp == SbxMINUS ) && ( GetType() != rOp.GetType() ) ) )
aL.eType = SbxDATE;
}
}
}
}
if( !IsError() )
Put( aL );
if( bDecimal )
{
releaseDecimalPtr( aL.pDecimal );
releaseDecimalPtr( aR.pDecimal );
}
}
Lbl_OpIsEmpty:
bool bRes = !IsError();
if( bRes && eOld != ERRCODE_NONE )
SetError( eOld );
return bRes;
}
// The comparison routine deliver TRUE or FALSE.
bool SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const
{
#if !HAVE_FEATURE_SCRIPTING
const bool bVBAInterop = false;
#else
bool bVBAInterop = SbiRuntime::isVBAEnabled();
#endif
bool bRes = false;
ErrCode eOld = GetError();
if( eOld != ERRCODE_NONE )
ResetError();
if( !CanRead() || !rOp.CanRead() )
SetError( ERRCODE_BASIC_PROP_WRITEONLY );
else if( GetType() == SbxNULL && rOp.GetType() == SbxNULL && !bVBAInterop )
{
bRes = true;
}
else if( GetType() == SbxEMPTY && rOp.GetType() == SbxEMPTY )
bRes = !bVBAInterop || ( eOp == SbxEQ );
// Special rule 1: If an operand is null, the result is FALSE
else if( GetType() == SbxNULL || rOp.GetType() == SbxNULL )
bRes = false;
// Special rule 2: If both are variant and one is numeric
// and the other is a String, num is < str
else if( !IsFixed() && !rOp.IsFixed()
&& ( rOp.GetType() == SbxSTRING && GetType() != SbxSTRING && IsNumeric() ) && !bVBAInterop
)
bRes = eOp == SbxLT || eOp == SbxLE || eOp == SbxNE;
else if( !IsFixed() && !rOp.IsFixed()
&& ( GetType() == SbxSTRING && rOp.GetType() != SbxSTRING && rOp.IsNumeric() )
&& !bVBAInterop
)
bRes = eOp == SbxGT || eOp == SbxGE || eOp == SbxNE;
else
{
SbxValues aL, aR;
// If one of the operands is a String,
// a String comparing take place
if( GetType() == SbxSTRING || rOp.GetType() == SbxSTRING )
{
aL.eType = aR.eType = SbxSTRING;
if( Get( aL ) && rOp.Get( aR ) ) switch( eOp )
{
case SbxEQ:
bRes = ( *aL.pOUString == *aR.pOUString ); break;
case SbxNE:
bRes = ( *aL.pOUString != *aR.pOUString ); break;
case SbxLT:
bRes = ( *aL.pOUString < *aR.pOUString ); break;
case SbxGT:
bRes = ( *aL.pOUString > *aR.pOUString ); break;
case SbxLE:
bRes = ( *aL.pOUString <= *aR.pOUString ); break;
case SbxGE:
bRes = ( *aL.pOUString >= *aR.pOUString ); break;
default:
SetError( ERRCODE_BASIC_BAD_ARGUMENT );
}
}
// From 1995-12-19: If SbxSINGLE participate, then convert to SINGLE,
// otherwise it shows a numeric error
else if( GetType() == SbxSINGLE || rOp.GetType() == SbxSINGLE )
{
aL.eType = aR.eType = SbxSINGLE;
if( Get( aL ) && rOp.Get( aR ) )
switch( eOp )
{
case SbxEQ:
bRes = ( aL.nSingle == aR.nSingle ); break;
case SbxNE:
bRes = ( aL.nSingle != aR.nSingle ); break;
case SbxLT:
bRes = ( aL.nSingle < aR.nSingle ); break;
case SbxGT:
bRes = ( aL.nSingle > aR.nSingle ); break;
case SbxLE:
bRes = ( aL.nSingle <= aR.nSingle ); break;
case SbxGE:
bRes = ( aL.nSingle >= aR.nSingle ); break;
default:
SetError( ERRCODE_BASIC_BAD_ARGUMENT );
}
}
else if( GetType() == SbxDECIMAL && rOp.GetType() == SbxDECIMAL )
{
aL.eType = aR.eType = SbxDECIMAL;
Get( aL );
rOp.Get( aR );
if( aL.pDecimal && aR.pDecimal )
{
SbxDecimal::CmpResult eRes = compare( *aL.pDecimal, *aR.pDecimal );
switch( eOp )
{
case SbxEQ:
bRes = ( eRes == SbxDecimal::CmpResult::EQ ); break;
case SbxNE:
bRes = ( eRes != SbxDecimal::CmpResult::EQ ); break;
case SbxLT:
bRes = ( eRes == SbxDecimal::CmpResult::LT ); break;
case SbxGT:
bRes = ( eRes == SbxDecimal::CmpResult::GT ); break;
case SbxLE:
bRes = ( eRes != SbxDecimal::CmpResult::GT ); break;
case SbxGE:
bRes = ( eRes != SbxDecimal::CmpResult::LT ); break;
default:
SetError( ERRCODE_BASIC_BAD_ARGUMENT );
}
}
else
{
SetError( ERRCODE_BASIC_CONVERSION );
}
releaseDecimalPtr( aL.pDecimal );
releaseDecimalPtr( aR.pDecimal );
}
// Everything else comparing on a SbxDOUBLE-Basis
else
{
aL.eType = aR.eType = SbxDOUBLE;
bool bGetL = Get( aL );
bool bGetR = rOp.Get( aR );
if( bGetL && bGetR )
switch( eOp )
{
case SbxEQ:
bRes = ( aL.nDouble == aR.nDouble ); break;
case SbxNE:
bRes = ( aL.nDouble != aR.nDouble ); break;
case SbxLT:
bRes = ( aL.nDouble < aR.nDouble ); break;
case SbxGT:
bRes = ( aL.nDouble > aR.nDouble ); break;
case SbxLE:
bRes = ( aL.nDouble <= aR.nDouble ); break;
case SbxGE:
bRes = ( aL.nDouble >= aR.nDouble ); break;
default:
SetError( ERRCODE_BASIC_BAD_ARGUMENT );
}
// at least one value was got
// if this is VBA then a conversion error for one
// side will yield a false result of an equality test
else if ( bGetR || bGetL )
{
if ( bVBAInterop && eOp == SbxEQ && GetError() == ERRCODE_BASIC_CONVERSION )
{
#ifndef IOS
ResetError();
bRes = false;
#endif
}
}
}
}
if( eOld != ERRCODE_NONE )
SetError( eOld );
return bRes;
}
///////////////////////////// Reading/Writing
bool SbxValue::LoadData( SvStream& r, sal_uInt16 )
{
// #TODO see if these types are really dumped to any stream
// more than likely this is functionality used in the binfilter alone
SbxValue::Clear();
sal_uInt16 nType;
r.ReadUInt16( nType );
aData.eType = SbxDataType( nType );
switch( nType )
{
case SbxBOOL:
case SbxINTEGER:
r.ReadInt16( aData.nInteger ); break;
case SbxLONG:
r.ReadInt32( aData.nLong ); break;
case SbxSINGLE:
{
// Floats as ASCII
OUString aVal = read_uInt16_lenPrefixed_uInt8s_ToOUString(r,
RTL_TEXTENCODING_ASCII_US);
double d;
SbxDataType t;
if( ImpScan( aVal, d, t, nullptr, false ) != ERRCODE_NONE || t == SbxDOUBLE )
{
aData.nSingle = 0.0F;
return false;
}
aData.nSingle = static_cast<float>(d);
break;
}
case SbxDATE:
case SbxDOUBLE:
{
// Floats as ASCII
OUString aVal = read_uInt16_lenPrefixed_uInt8s_ToOUString(r,
RTL_TEXTENCODING_ASCII_US);
SbxDataType t;
if( ImpScan( aVal, aData.nDouble, t, nullptr, false ) != ERRCODE_NONE )
{
aData.nDouble = 0.0;
return false;
}
break;
}
case SbxSALINT64:
r.ReadInt64(aData.nInt64);
break;
case SbxSALUINT64:
r.ReadUInt64( aData.uInt64 );
break;
case SbxCURRENCY:
{
sal_uInt32 tmpHi = 0;
sal_uInt32 tmpLo = 0;
r.ReadUInt32( tmpHi ).ReadUInt32( tmpLo );
aData.nInt64 = (static_cast<sal_Int64>(tmpHi) << 32);
aData.nInt64 |= static_cast<sal_Int64>(tmpLo);
break;
}
case SbxSTRING:
{
OUString aVal = read_uInt16_lenPrefixed_uInt8s_ToOUString(r,
RTL_TEXTENCODING_ASCII_US);
if( !aVal.isEmpty() )
aData.pOUString = new OUString( aVal );
else
aData.pOUString = nullptr; // JSM 1995-09-22
break;
}
case SbxERROR:
case SbxUSHORT:
r.ReadUInt16( aData.nUShort ); break;
case SbxOBJECT:
{
sal_uInt8 nMode;
r.ReadUChar( nMode );
switch( nMode )
{
case 0:
aData.pObj = nullptr;
break;
case 1:
aData.pObj = SbxBase::Load( r );
return ( aData.pObj != nullptr );
case 2:
aData.pObj = this;
break;
}
break;
}
case SbxCHAR:
{
char c;
r.ReadChar( c );
aData.nChar = c;
break;
}
case SbxBYTE:
r.ReadUChar( aData.nByte ); break;
case SbxULONG:
r.ReadUInt32( aData.nULong ); break;
case SbxINT:
{
sal_uInt8 n;
r.ReadUChar( n );
// Match the Int on this system?
if( n > SAL_TYPES_SIZEOFINT )
{
r.ReadInt32( aData.nLong );
aData.eType = SbxLONG;
}
else {
sal_Int32 nInt;
r.ReadInt32( nInt );
aData.nInt = nInt;
}
break;
}
case SbxUINT:
{
sal_uInt8 n;
r.ReadUChar( n );
// Match the UInt on this system?
if( n > SAL_TYPES_SIZEOFINT )
{
r.ReadUInt32( aData.nULong );
aData.eType = SbxULONG;
}
else {
sal_uInt32 nUInt;
r.ReadUInt32( nUInt );
aData.nUInt = nUInt;
}
break;
}
case SbxEMPTY:
case SbxNULL:
case SbxVOID:
break;
case SbxDATAOBJECT:
r.ReadInt32( aData.nLong );
break;
// #78919 For backwards compatibility
case SbxWSTRING:
case SbxWCHAR:
break;
default:
aData.clear(SbxNULL);
ResetFlag(SbxFlagBits::Fixed);
SAL_WARN( "basic.sbx", "Loaded a non-supported data type" );
return false;
}
return true;
}
bool SbxValue::StoreData( SvStream& r ) const
{
sal_uInt16 nType = sal::static_int_cast< sal_uInt16 >(aData.eType);
r.WriteUInt16( nType );
switch( nType & 0x0FFF )
{
case SbxBOOL:
case SbxINTEGER:
r.WriteInt16( aData.nInteger ); break;
case SbxLONG:
r.WriteInt32( aData.nLong ); break;
case SbxDATE:
// #49935: Save as double, otherwise an error during the read in
const_cast<SbxValue*>(this)->aData.eType = static_cast<SbxDataType>( ( nType & 0xF000 ) | SbxDOUBLE );
write_uInt16_lenPrefixed_uInt8s_FromOUString(r, GetCoreString(), RTL_TEXTENCODING_ASCII_US);
const_cast<SbxValue*>(this)->aData.eType = static_cast<SbxDataType>(nType);
break;
case SbxSINGLE:
case SbxDOUBLE:
write_uInt16_lenPrefixed_uInt8s_FromOUString(r, GetCoreString(), RTL_TEXTENCODING_ASCII_US);
break;
case SbxSALUINT64:
case SbxSALINT64:
// see comment in SbxValue::StoreData
r.WriteUInt64( aData.uInt64 );
break;
case SbxCURRENCY:
{
sal_Int32 tmpHi = ( (aData.nInt64 >> 32) & 0xFFFFFFFF );
sal_Int32 tmpLo = static_cast<sal_Int32>(aData.nInt64);
r.WriteInt32( tmpHi ).WriteInt32( tmpLo );
break;
}
case SbxSTRING:
if( aData.pOUString )
{
write_uInt16_lenPrefixed_uInt8s_FromOUString(r, *aData.pOUString, RTL_TEXTENCODING_ASCII_US);
}
else
{
write_uInt16_lenPrefixed_uInt8s_FromOUString(r, OUString(), RTL_TEXTENCODING_ASCII_US);
}
break;
case SbxERROR:
case SbxUSHORT:
r.WriteUInt16( aData.nUShort ); break;
case SbxOBJECT:
// to save itself as Objectptr does not work!
if( aData.pObj )
{
if( dynamic_cast<SbxValue*>( aData.pObj) != this )
{
r.WriteUChar( 1 );
return aData.pObj->Store( r );
}
else
r.WriteUChar( 2 );
}
else
r.WriteUChar( 0 );
break;
case SbxCHAR:
{
char c = sal::static_int_cast< char >(aData.nChar);
r.WriteChar( c );
break;
}
case SbxBYTE:
r.WriteUChar( aData.nByte ); break;
case SbxULONG:
r.WriteUInt32( aData.nULong ); break;
case SbxINT:
{
r.WriteUChar( SAL_TYPES_SIZEOFINT ).WriteInt32( aData.nInt );
break;
}
case SbxUINT:
{
r.WriteUChar( SAL_TYPES_SIZEOFINT ).WriteUInt32( aData.nUInt );
break;
}
case SbxEMPTY:
case SbxNULL:
case SbxVOID:
break;
case SbxDATAOBJECT:
r.WriteInt32( aData.nLong );
break;
// #78919 For backwards compatibility
case SbxWSTRING:
case SbxWCHAR:
break;
default:
SAL_WARN( "basic.sbx", "Saving a non-supported data type" );
return false;
}
return true;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V547 Expression 'aData.eType == SbxDECIMAL' is always true.