Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1588 insertions, 0 deletions

diff --git a/basic/source/sbx/sbxvalue.cxx b/basic/source/sbx/sbxvalue.cxx
new file mode 100644
index 000000000..bd668a029
--- /dev/null
+++ b/basic/source/sbx/sbxvalue.cxx
@@ -0,0 +1,1588 @@
+/* -*- 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 <o3tl/float_int_conversion.hxx>
+#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 && (pThisVar->GetUserData() & 0xFFFF) == 5345;
+                    if ( !bParentProp )
+                        aData.pObj->ReleaseRef();
+                }
+                aData.pObj = nullptr;
+            }
+            break;
+        case 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->Get32( pPar->Get32( 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 && (pThisVar->GetUserData() & 0xFFFF) == 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 );
+}
+
+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_uInt32 nSlotId = pThisVar
+                                    ? pThisVar->GetUserData() & 0xFFFF
+                                    : 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 );
+    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;     // concatenate empty, *this stays lhs as result
+                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( Get( aL ) ) switch( eOp )
+                {
+                    /* TODO: For SbxEMPTY operands with boolean operators use
+                     * the VBA Nothing definition of Comparing Nullable Types?
+                     * https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/data-types/nullable-value-types
+                     */
+                    /* TODO: it is unclear yet whether this also should be done
+                     * for the non-bVBAInterop case or not, or at all, consider
+                     * user defined spreadsheet functions where an empty cell
+                     * is SbxEMPTY and usually is treated as 0 zero or "" empty
+                     * string.
+                     */
+                    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 ) && 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( 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( !(o3tl::convertsToAtLeast(dTest, SAL_MIN_INT64)
+                                  && o3tl::convertsToAtMost(dTest, SAL_MAX_INT64)))
+                            {
+                                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( !(o3tl::convertsToAtLeast(dTest, SAL_MIN_INT64)
+                                  && o3tl::convertsToAtMost(dTest, SAL_MAX_INT64)))
+                            {
+                                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( 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, true ) != 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, true ) != 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: */