LCOV - code coverage report
Current view: top level - basic/source/sbx - sbxvalue.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 384 859 44.7 %
Date: 2015-06-13 12:38:46 Functions: 42 72 58.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <config_features.h>
      21             : 
      22             : #include <math.h>
      23             : #include <tools/debug.hxx>
      24             : #include <tools/stream.hxx>
      25             : 
      26             : #include <basic/sbx.hxx>
      27             : #include "sbunoobj.hxx"
      28             : #include "sbxconv.hxx"
      29             : #include "runtime.hxx"
      30             : 
      31      466139 : TYPEINIT1(SbxValue,SbxBase)
      32             : 
      33             : ///////////////////////////// constructors
      34             : 
      35        8823 : SbxValue::SbxValue() : SbxBase()
      36             : {
      37        8823 :     aData.eType = SbxEMPTY;
      38        8823 : }
      39             : 
      40      141230 : SbxValue::SbxValue( SbxDataType t, void* p ) : SbxBase()
      41             : {
      42      141230 :     int n = t & 0x0FFF;
      43      141230 :     if( p )
      44           0 :         n |= SbxBYREF;
      45      141230 :     if( n == SbxVARIANT )
      46        5274 :         n = SbxEMPTY;
      47             :     else
      48      135956 :         SetFlag( SBX_FIXED );
      49      141230 :     if( p )
      50             :     {
      51           0 :         switch( t & 0x0FFF )
      52             :         {
      53           0 :             case SbxINTEGER:    n |= SbxBYREF; aData.pInteger = static_cast<sal_Int16*>(p); break;
      54           0 :             case SbxSALUINT64:  n |= SbxBYREF; aData.puInt64 = static_cast<sal_uInt64*>(p); break;
      55             :             case SbxSALINT64:
      56           0 :             case SbxCURRENCY:   n |= SbxBYREF; aData.pnInt64 = static_cast<sal_Int64*>(p); break;
      57           0 :             case SbxLONG:       n |= SbxBYREF; aData.pLong = static_cast<sal_Int32*>(p); break;
      58           0 :             case SbxSINGLE:     n |= SbxBYREF; aData.pSingle = static_cast<float*>(p); break;
      59             :             case SbxDATE:
      60           0 :             case SbxDOUBLE:     n |= SbxBYREF; aData.pDouble = static_cast<double*>(p); break;
      61           0 :             case SbxSTRING:     n |= SbxBYREF; aData.pOUString = static_cast<OUString*>(p); break;
      62             :             case SbxERROR:
      63             :             case SbxUSHORT:
      64           0 :             case SbxBOOL:       n |= SbxBYREF; aData.pUShort = static_cast<sal_uInt16*>(p); break;
      65           0 :             case SbxULONG:      n |= SbxBYREF; aData.pULong = static_cast<sal_uInt32*>(p); break;
      66           0 :             case SbxCHAR:       n |= SbxBYREF; aData.pChar = static_cast<sal_Unicode*>(p); break;
      67           0 :             case SbxBYTE:       n |= SbxBYREF; aData.pByte = static_cast<sal_uInt8*>(p); break;
      68           0 :             case SbxINT:        n |= SbxBYREF; aData.pInt = static_cast<int*>(p); break;
      69             :             case SbxOBJECT:
      70           0 :                 aData.pObj = static_cast<SbxBase*>(p);
      71           0 :                 if( p )
      72           0 :                     aData.pObj->AddFirstRef();
      73           0 :                 break;
      74             :             case SbxDECIMAL:
      75           0 :                 aData.pDecimal = static_cast<SbxDecimal*>(p);
      76           0 :                 if( p )
      77           0 :                     aData.pDecimal->addRef();
      78           0 :                 break;
      79             :             default:
      80             :                 DBG_ASSERT( false, "Improper pointer argument" );
      81           0 :                 n = SbxNULL;
      82             :         }
      83             :     }
      84             :     else
      85      141230 :         memset( &aData, 0, sizeof( SbxValues ) );
      86      141230 :     aData.eType = SbxDataType( n );
      87      141230 : }
      88             : 
      89       11660 : SbxValue::SbxValue( const SbxValue& r )
      90       11660 :     : SvRefBase( r ), SbxBase( r )
      91             : {
      92       11660 :     if( !r.CanRead() )
      93             :     {
      94           0 :         SetError( SbxERR_PROP_WRITEONLY );
      95           0 :         if( !IsFixed() )
      96           0 :             aData.eType = SbxNULL;
      97             :     }
      98             :     else
      99             :     {
     100       11660 :         const_cast<SbxValue*>(&r)->Broadcast( SBX_HINT_DATAWANTED );
     101       11660 :         aData = r.aData;
     102             :         // Copy pointer, increment references
     103       11660 :         switch( aData.eType )
     104             :         {
     105             :             case SbxSTRING:
     106        2931 :                 if( aData.pOUString )
     107        2311 :                     aData.pOUString = new OUString( *aData.pOUString );
     108        2931 :                 break;
     109             :             case SbxOBJECT:
     110        2361 :                 if( aData.pObj )
     111        2326 :                     aData.pObj->AddFirstRef();
     112        2361 :                 break;
     113             :             case SbxDECIMAL:
     114           0 :                 if( aData.pDecimal )
     115           0 :                     aData.pDecimal->addRef();
     116           0 :                 break;
     117        6368 :             default: break;
     118             :         }
     119             :     }
     120       11660 : }
     121             : 
     122        6057 : SbxValue& SbxValue::operator=( const SbxValue& r )
     123             : {
     124        6057 :     if( &r != this )
     125             :     {
     126        6057 :         if( !CanWrite() )
     127           0 :             SetError( SbxERR_PROP_READONLY );
     128             :         else
     129             :         {
     130             :             // string -> byte array
     131       17140 :             if( IsFixed() && (aData.eType == SbxOBJECT)
     132         416 :                 && aData.pObj && ( aData.pObj->GetType() == (SbxARRAY | SbxBYTE) )
     133        6059 :                 && (r.aData.eType == SbxSTRING) )
     134             :             {
     135           2 :                 OUString aStr = r.GetOUString();
     136           2 :                 SbxArray* pArr = StringToByteArray(aStr);
     137           2 :                 PutObject(pArr);
     138           2 :                 return *this;
     139             :             }
     140             :             // byte array -> string
     141       13259 :             if( r.IsFixed() && (r.aData.eType == SbxOBJECT)
     142         292 :                 && r.aData.pObj && ( r.aData.pObj->GetType() == (SbxARRAY | SbxBYTE) )
     143        6057 :                 && (aData.eType == SbxSTRING) )
     144             :             {
     145           2 :                 SbxBase* pObj = r.GetObject();
     146           2 :                 SbxArray* pArr = PTR_CAST(SbxArray, pObj);
     147           2 :                 if( pArr )
     148             :                 {
     149           2 :                     OUString aStr = ByteArrayToString( pArr );
     150           2 :                     PutString(aStr);
     151           2 :                     return *this;
     152             :                 }
     153             :             }
     154             :             // Readout the content of the variables
     155        6053 :             SbxValues aNew;
     156        6053 :             if( IsFixed() )
     157             :                 // then the type has to match
     158        5022 :                 aNew.eType = aData.eType;
     159        1031 :             else if( r.IsFixed() )
     160             :                 // Source fixed: copy the type
     161         227 :                 aNew.eType = SbxDataType( r.aData.eType & 0x0FFF );
     162             :             else
     163             :                 // both variant: then don't care
     164         804 :                 aNew.eType = SbxVARIANT;
     165        6053 :             if( r.Get( aNew ) )
     166        6043 :                 Put( aNew );
     167             :         }
     168             :     }
     169        6053 :     return *this;
     170             : }
     171             : 
     172      305104 : SbxValue::~SbxValue()
     173             : {
     174      152552 :     Broadcast( SBX_HINT_DYING );
     175      152552 :     SetFlag( SBX_WRITE );
     176      152552 :     SbxValue::Clear();
     177      152552 : }
     178             : 
     179      162278 : void SbxValue::Clear()
     180             : {
     181      162278 :     switch( aData.eType )
     182             :     {
     183             :         case SbxNULL:
     184             :         case SbxEMPTY:
     185             :         case SbxVOID:
     186       20362 :             break;
     187             :         case SbxSTRING:
     188       47642 :             delete aData.pOUString; aData.pOUString = NULL;
     189       47642 :             break;
     190             :         case SbxOBJECT:
     191       81440 :             if( aData.pObj )
     192             :             {
     193       40290 :                 if( aData.pObj != this )
     194             :                 {
     195             :                     SAL_INFO("basic.sbx", "Not at Parent-Prop - otherwise CyclicRef");
     196        5608 :                     SbxVariable *pThisVar = PTR_CAST(SbxVariable, this);
     197        7463 :                     bool bParentProp = pThisVar && 5345 ==
     198        7463 :                     ( (sal_Int16) ( pThisVar->GetUserData() & 0xFFFF ) );
     199        5608 :                     if ( !bParentProp )
     200        5608 :                         aData.pObj->ReleaseRef();
     201             :                 }
     202       40290 :                 aData.pObj = NULL;
     203             :             }
     204       81440 :             break;
     205             :         case SbxDECIMAL:
     206         486 :             if( aData.eType == SbxDECIMAL )
     207         486 :                 releaseDecimalPtr( aData.pDecimal );
     208         486 :             break;
     209             :         case SbxDATAOBJECT:
     210           0 :             aData.pData = NULL; break;
     211             :         default:
     212             :         {
     213       12348 :             SbxValues aEmpty;
     214       12348 :             memset( &aEmpty, 0, sizeof( SbxValues ) );
     215       12348 :             aEmpty.eType = GetType();
     216       12348 :             Put( aEmpty );
     217             :         }
     218             :     }
     219      162278 : }
     220             : 
     221             : // Dummy
     222             : 
     223      173179 : void SbxValue::Broadcast( sal_uIntPtr )
     224      173179 : {}
     225             : 
     226             : //////////////////////////// Readout data
     227             : 
     228             : // Detect the "right" variables. If it is an object, will be addressed either
     229             : // the object itself or its default property.
     230             : // If the variable contain a variable or an object, this will be
     231             : // addressed.
     232             : 
     233       26924 : SbxValue* SbxValue::TheRealValue() const
     234             : {
     235       26924 :     return TheRealValue( true );
     236             : }
     237             : 
     238       68855 : SbxValue* SbxValue::TheRealValue( bool bObjInObjError ) const
     239             : {
     240       68855 :     SbxValue* p = const_cast<SbxValue*>(this);
     241             :     for( ;; )
     242             :     {
     243       68855 :         SbxDataType t = SbxDataType( p->aData.eType & 0x0FFF );
     244       68855 :         if( t == SbxOBJECT )
     245             :         {
     246             :             // The block contains an object or a variable
     247          27 :             SbxObject* pObj = PTR_CAST(SbxObject,p->aData.pObj);
     248          27 :             if( pObj )
     249             :             {
     250             :                 // Has the object a default property?
     251           6 :                 SbxVariable* pDflt = pObj->GetDfltProperty();
     252             : 
     253             :                 // If this is an object and contains itself,
     254             :                 // we cannot access on it
     255             :                 // The old condition to set an error is not correct,
     256             :                 // because e.g. a regular variant variable with an object
     257             :                 // could be affected if another value should be assigned.
     258             :                 // Therefore with flag.
     259           6 :                 if( bObjInObjError && !pDflt &&
     260           0 :                     static_cast<SbxValue*>(pObj)->aData.eType == SbxOBJECT &&
     261           0 :                     static_cast<SbxValue*>(pObj)->aData.pObj == pObj )
     262             :                 {
     263             : #if !HAVE_FEATURE_SCRIPTING
     264             :                     const bool bSuccess = false;
     265             : #else
     266           0 :                     bool bSuccess = handleToStringForCOMObjects( pObj, p );
     267             : #endif
     268           0 :                     if( !bSuccess )
     269             :                     {
     270           0 :                         SetError( SbxERR_BAD_PROP_VALUE );
     271           0 :                         p = NULL;
     272           0 :                     }
     273             :                 }
     274           6 :                 else if( pDflt )
     275           6 :                     p = pDflt;
     276           6 :                 break;
     277             :             }
     278             :             // Did we have an array?
     279          21 :             SbxArray* pArray = PTR_CAST(SbxArray,p->aData.pObj);
     280          21 :             if( pArray )
     281             :             {
     282             :                 // When indicated get the parameter
     283          14 :                 SbxArray* pPar = NULL;
     284          14 :                 SbxVariable* pVar = PTR_CAST(SbxVariable,p);
     285          14 :                 if( pVar )
     286          14 :                     pPar = pVar->GetParameters();
     287          14 :                 if( pPar )
     288             :                 {
     289             :                     // Did we have a dimensioned array?
     290           0 :                     SbxDimArray* pDimArray = PTR_CAST(SbxDimArray,p->aData.pObj);
     291           0 :                     if( pDimArray )
     292           0 :                         p = pDimArray->Get( pPar );
     293             :                     else
     294           0 :                         p = pArray->Get( pPar->Get( 1 )->GetInteger() );
     295           0 :                     break;
     296             :                 }
     297             :             }
     298             :             // Otherwise guess a SbxValue
     299          21 :             SbxValue* pVal = PTR_CAST(SbxValue,p->aData.pObj);
     300          21 :             if( pVal )
     301           0 :                 p = pVal;
     302             :             else
     303          21 :                 break;
     304             :         }
     305             :         else
     306       68828 :             break;
     307           0 :     }
     308       68855 :     return p;
     309             : }
     310             : 
     311      118510 : bool SbxValue::Get( SbxValues& rRes ) const
     312             : {
     313      118510 :     bool bRes = false;
     314      118510 :     SbxError eOld = GetError();
     315      118510 :     if( eOld != SbxERR_OK )
     316           0 :         ResetError();
     317      118510 :     if( !CanRead() )
     318             :     {
     319           0 :         SetError( SbxERR_PROP_WRITEONLY );
     320           0 :         rRes.pObj = NULL;
     321             :     }
     322             :     else
     323             :     {
     324             :         // If an object or a VARIANT is requested, don't search the real values
     325      118510 :         SbxValue* p = const_cast<SbxValue*>(this);
     326      118510 :         if( rRes.eType != SbxOBJECT && rRes.eType != SbxVARIANT )
     327       26924 :             p = TheRealValue();
     328      118510 :         if( p )
     329             :         {
     330      118510 :             p->Broadcast( SBX_HINT_DATAWANTED );
     331      118510 :             switch( rRes.eType )
     332             :             {
     333             :                 case SbxEMPTY:
     334             :                 case SbxVOID:
     335          15 :                 case SbxNULL:    break;
     336         884 :                 case SbxVARIANT: rRes = p->aData; break;
     337        3198 :                 case SbxINTEGER: rRes.nInteger = ImpGetInteger( &p->aData ); break;
     338        2796 :                 case SbxLONG:    rRes.nLong = ImpGetLong( &p->aData ); break;
     339           0 :                 case SbxSALINT64:   rRes.nInt64 = ImpGetInt64( &p->aData ); break;
     340           0 :                 case SbxSALUINT64:  rRes.uInt64 = ImpGetUInt64( &p->aData ); break;
     341           1 :                 case SbxSINGLE:  rRes.nSingle = ImpGetSingle( &p->aData ); break;
     342        9814 :                 case SbxDOUBLE:  rRes.nDouble = ImpGetDouble( &p->aData ); break;
     343           0 :                 case SbxCURRENCY:rRes.nInt64 = ImpGetCurrency( &p->aData ); break;
     344           0 :                 case SbxDECIMAL: rRes.pDecimal = ImpGetDecimal( &p->aData ); break;
     345           3 :                 case SbxDATE:    rRes.nDouble = ImpGetDate( &p->aData ); break;
     346             :                 case SbxBOOL:
     347             :                     rRes.nUShort = sal::static_int_cast< sal_uInt16 >(
     348        2868 :                         ImpGetBool( &p->aData ) );
     349        2868 :                     break;
     350           0 :                 case SbxCHAR:    rRes.nChar = ImpGetChar( &p->aData ); break;
     351         177 :                 case SbxBYTE:    rRes.nByte = ImpGetByte( &p->aData ); break;
     352           0 :                 case SbxUSHORT:  rRes.nUShort = ImpGetUShort( &p->aData ); break;
     353           0 :                 case SbxULONG:   rRes.nULong = ImpGetULong( &p->aData ); break;
     354             :                 case SbxLPSTR:
     355        8052 :                 case SbxSTRING:  p->aPic = ImpGetString( &p->aData );
     356        8052 :                                  rRes.pOUString = &p->aPic; break;
     357           0 :                 case SbxCoreSTRING: p->aPic = ImpGetCoreString( &p->aData );
     358           0 :                                     rRes.pOUString = &p->aPic; break;
     359             :                 case SbxINT:
     360             : #if SAL_TYPES_SIZEOFINT == 2
     361             :                     rRes.nInt = (int) ImpGetInteger( &p->aData );
     362             : #else
     363           0 :                     rRes.nInt = (int) ImpGetLong( &p->aData );
     364             : #endif
     365           0 :                     break;
     366             :                 case SbxUINT:
     367             : #if SAL_TYPES_SIZEOFINT == 2
     368             :                     rRes.nUInt = (int) ImpGetUShort( &p->aData );
     369             : #else
     370           0 :                     rRes.nUInt = (int) ImpGetULong( &p->aData );
     371             : #endif
     372           0 :                     break;
     373             :                 case SbxOBJECT:
     374       90702 :                     if( p->aData.eType == SbxOBJECT )
     375       90699 :                         rRes.pObj = p->aData.pObj;
     376             :                     else
     377             :                     {
     378           3 :                         SetError( SbxERR_NO_OBJECT );
     379           3 :                         rRes.pObj = NULL;
     380             :                     }
     381       90702 :                     break;
     382             :                 default:
     383           0 :                     if( p->aData.eType == rRes.eType )
     384           0 :                         rRes = p->aData;
     385             :                     else
     386             :                     {
     387           0 :                         SetError( SbxERR_CONVERSION );
     388           0 :                         rRes.pObj = NULL;
     389             :                     }
     390             :             }
     391             :         }
     392             :         else
     393             :         {
     394             :             // Object contained itself
     395           0 :             SbxDataType eTemp = rRes.eType;
     396           0 :             memset( &rRes, 0, sizeof( SbxValues ) );
     397           0 :             rRes.eType = eTemp;
     398             :         }
     399             :     }
     400      118510 :     if( !IsError() )
     401             :     {
     402      118491 :         bRes = true;
     403      118491 :         if( eOld != SbxERR_OK )
     404           0 :             SetError( eOld );
     405             :     }
     406      118510 :     return bRes;
     407             : }
     408             : 
     409           0 : const OUString& SbxValue::GetCoreString() const
     410             : {
     411           0 :     SbxValues aRes;
     412           0 :     aRes.eType = SbxCoreSTRING;
     413           0 :     if( Get( aRes ) )
     414             :     {
     415           0 :         const_cast<SbxValue*>(this)->aToolString = *aRes.pOUString;
     416             :     }
     417             :     else
     418             :     {
     419           0 :         const_cast<SbxValue*>(this)->aToolString.clear();
     420             :     }
     421           0 :     return aToolString;
     422             : }
     423             : 
     424        1981 : OUString SbxValue::GetOUString() const
     425             : {
     426        1981 :     OUString aResult;
     427        1981 :     SbxValues aRes;
     428        1981 :     aRes.eType = SbxSTRING;
     429        1981 :     if( Get( aRes ) )
     430             :     {
     431        1981 :         aResult = *aRes.pOUString;
     432             :     }
     433        1981 :     return aResult;
     434             : }
     435             : 
     436        1862 : bool SbxValue::GetBool() const
     437             : {
     438        1862 :     SbxValues aRes;
     439        1862 :     aRes.eType = SbxBOOL;
     440        1862 :     Get( aRes );
     441        1862 :     return aRes.nUShort != 0;
     442             : }
     443             : 
     444             : #define GET( g, e, t, m ) \
     445             : t SbxValue::g() const { SbxValues aRes(e); Get( aRes ); return aRes.m; }
     446             : 
     447         177 : GET( GetByte,     SbxBYTE,       sal_uInt8,     nByte )
     448           0 : GET( GetChar,     SbxCHAR,       sal_Unicode,   nChar )
     449           0 : GET( GetCurrency, SbxCURRENCY,   sal_Int64,     nInt64 )
     450           0 : GET( GetDate,     SbxDATE,       double,        nDouble )
     451        1600 : GET( GetDouble,   SbxDOUBLE,     double,        nDouble )
     452        1704 : GET( GetInteger,  SbxINTEGER,    sal_Int16,     nInteger )
     453        1626 : GET( GetLong,     SbxLONG,       sal_Int32,     nLong )
     454       90268 : GET( GetObject,   SbxOBJECT,     SbxBase*,      pObj )
     455           0 : GET( GetSingle,   SbxSINGLE,     float,         nSingle )
     456           0 : GET( GetULong,    SbxULONG,      sal_uInt32,    nULong )
     457           0 : GET( GetUShort,   SbxUSHORT,     sal_uInt16,    nUShort )
     458           0 : GET( GetInt64,    SbxSALINT64,   sal_Int64,     nInt64 )
     459           0 : GET( GetUInt64,   SbxSALUINT64,  sal_uInt64,    uInt64 )
     460           0 : GET( GetDecimal,  SbxDECIMAL,    SbxDecimal*,   pDecimal )
     461             : 
     462             : 
     463             : //////////////////////////// Write data
     464             : 
     465       45532 : bool SbxValue::Put( const SbxValues& rVal )
     466             : {
     467       45532 :     bool bRes = false;
     468       45532 :     SbxError eOld = GetError();
     469       45532 :     if( eOld != SbxERR_OK )
     470           0 :         ResetError();
     471       45532 :     if( !CanWrite() )
     472           0 :         SetError( SbxERR_PROP_READONLY );
     473       45532 :     else if( rVal.eType & 0xF000 )
     474           0 :         SetError( SbxERR_NOTIMP );
     475             :     else
     476             :     {
     477             :         // If an object is requested, don't search the real values
     478       45532 :         SbxValue* p = this;
     479       45532 :         if( rVal.eType != SbxOBJECT )
     480       41931 :             p = TheRealValue( false );  // Don't allow an error here
     481       45532 :         if( p )
     482             :         {
     483       45532 :             if( !p->CanWrite() )
     484           0 :                 SetError( SbxERR_PROP_READONLY );
     485       45532 :             else if( p->IsFixed() || p->SetType( (SbxDataType) ( rVal.eType & 0x0FFF ) ) )
     486       45532 :               switch( rVal.eType & 0x0FFF )
     487             :             {
     488             :                 case SbxEMPTY:
     489             :                 case SbxVOID:
     490         919 :                 case SbxNULL:       break;
     491        9197 :                 case SbxINTEGER:    ImpPutInteger( &p->aData, rVal.nInteger ); break;
     492        5787 :                 case SbxLONG:       ImpPutLong( &p->aData, rVal.nLong ); break;
     493           0 :                 case SbxSALINT64:   ImpPutInt64( &p->aData, rVal.nInt64 ); break;
     494           0 :                 case SbxSALUINT64:  ImpPutUInt64( &p->aData, rVal.uInt64 ); break;
     495           6 :                 case SbxSINGLE:     ImpPutSingle( &p->aData, rVal.nSingle ); break;
     496        8777 :                 case SbxDOUBLE:     ImpPutDouble( &p->aData, rVal.nDouble ); break;
     497           6 :                 case SbxCURRENCY:   ImpPutCurrency( &p->aData, rVal.nInt64 ); break;
     498           0 :                 case SbxDECIMAL:    ImpPutDecimal( &p->aData, rVal.pDecimal ); break;
     499          31 :                 case SbxDATE:       ImpPutDate( &p->aData, rVal.nDouble ); break;
     500        4566 :                 case SbxBOOL:       ImpPutBool( &p->aData, rVal.nInteger ); break;
     501           0 :                 case SbxCHAR:       ImpPutChar( &p->aData, rVal.nChar ); break;
     502          24 :                 case SbxBYTE:       ImpPutByte( &p->aData, rVal.nByte ); break;
     503           0 :                 case SbxUSHORT:     ImpPutUShort( &p->aData, rVal.nUShort ); break;
     504           0 :                 case SbxULONG:      ImpPutULong( &p->aData, rVal.nULong ); break;
     505             :                 case SbxLPSTR:
     506       12595 :                 case SbxSTRING:     ImpPutString( &p->aData, rVal.pOUString ); break;
     507             :                 case SbxINT:
     508             : #if SAL_TYPES_SIZEOFINT == 2
     509             :                     ImpPutInteger( &p->aData, (sal_Int16) rVal.nInt );
     510             : #else
     511           0 :                     ImpPutLong( &p->aData, (sal_Int32) rVal.nInt );
     512             : #endif
     513           0 :                     break;
     514             :                 case SbxUINT:
     515             : #if SAL_TYPES_SIZEOFINT == 2
     516             :                     ImpPutUShort( &p->aData, (sal_uInt16) rVal.nUInt );
     517             : #else
     518           0 :                     ImpPutULong( &p->aData, (sal_uInt32) rVal.nUInt );
     519             : #endif
     520           0 :                     break;
     521             :                 case SbxOBJECT:
     522        3601 :                     if( !p->IsFixed() || p->aData.eType == SbxOBJECT )
     523             :                     {
     524             :                         // is already inside
     525        3601 :                         if( p->aData.eType == SbxOBJECT && p->aData.pObj == rVal.pObj )
     526         298 :                             break;
     527             : 
     528             :                         // Delete only the value part!
     529        3303 :                         p->SbxValue::Clear();
     530             : 
     531             :                         // real assignment
     532        3303 :                         p->aData.pObj = rVal.pObj;
     533             : 
     534             :                         // if necessary increment Ref-Count
     535        3303 :                         if( p->aData.pObj && p->aData.pObj != p )
     536             :                         {
     537             :                             if ( p != this )
     538             :                             {
     539             :                                 OSL_FAIL( "TheRealValue" );
     540             :                             }
     541             :                             SAL_INFO("basic.sbx", "Not at Parent-Prop - otherwise CyclicRef");
     542        3300 :                             SbxVariable *pThisVar = PTR_CAST(SbxVariable, this);
     543        6600 :                             bool bParentProp = pThisVar && 5345 ==
     544        6600 :                                     ( (sal_Int16) ( pThisVar->GetUserData() & 0xFFFF ) );
     545        3300 :                             if ( !bParentProp )
     546        3300 :                                 p->aData.pObj->AddFirstRef();
     547             :                         }
     548             :                     }
     549             :                     else
     550           0 :                         SetError( SbxERR_CONVERSION );
     551        3303 :                     break;
     552             :                 default:
     553          23 :                     if( p->aData.eType == rVal.eType )
     554          23 :                         p->aData = rVal;
     555             :                     else
     556             :                     {
     557           0 :                         SetError( SbxERR_CONVERSION );
     558           0 :                         if( !p->IsFixed() )
     559           0 :                             p->aData.eType = SbxNULL;
     560             :                     }
     561             :             }
     562       45532 :             if( !IsError() )
     563             :             {
     564       45532 :                 p->SetModified( true );
     565       45532 :                 p->Broadcast( SBX_HINT_DATACHANGED );
     566       45532 :                 if( eOld != SbxERR_OK )
     567           0 :                     SetError( eOld );
     568       45532 :                 bRes = true;
     569             :             }
     570             :         }
     571             :     }
     572       45532 :     return bRes;
     573             : }
     574             : 
     575             : // From 1996-03-28:
     576             : // Method to execute a pretreatment of the strings at special types.
     577             : // In particular necessary for BASIC-IDE, so that
     578             : // the output in the Watch-Window can be written back with PutStringExt,
     579             : // if Float were declared with ',' as the decimal separator or BOOl
     580             : // explicit with "TRUE" or "FALSE".
     581             : // Implementation in ImpConvStringExt (SBXSCAN.CXX)
     582           0 : bool SbxValue::PutStringExt( const OUString& r )
     583             : {
     584             :     // Copy; if it is Unicode convert it immediately
     585           0 :     OUString aStr( r );
     586             : 
     587             :     // Identify the own type (not as in Put() with TheRealValue(),
     588             :     // Objects are not handled anyway)
     589           0 :     SbxDataType eTargetType = SbxDataType( aData.eType & 0x0FFF );
     590             : 
     591             :     // tinker a Source-Value
     592           0 :     SbxValues aRes;
     593           0 :     aRes.eType = SbxSTRING;
     594             : 
     595             :     // Only if really something was converted, take the copy,
     596             :     // otherwise take the original (Unicode remains)
     597             :     bool bRet;
     598           0 :     if( ImpConvStringExt( aStr, eTargetType ) )
     599           0 :         aRes.pOUString = &aStr;
     600             :     else
     601           0 :         aRes.pOUString = const_cast<OUString*>(&r);
     602             : 
     603             :     // #34939: For Strings which contain a number, and if this has a Num-Type,
     604             :     // set a Fixed flag so that the type will not be changed
     605           0 :     SbxFlagBits nFlags_ = GetFlags();
     606           0 :     if( ( eTargetType >= SbxINTEGER && eTargetType <= SbxCURRENCY ) ||
     607           0 :         ( eTargetType >= SbxCHAR && eTargetType <= SbxUINT ) ||
     608             :         eTargetType == SbxBOOL )
     609             :     {
     610           0 :         SbxValue aVal;
     611           0 :         aVal.Put( aRes );
     612           0 :         if( aVal.IsNumeric() )
     613           0 :             SetFlag( SBX_FIXED );
     614             :     }
     615             : 
     616           0 :     Put( aRes );
     617           0 :     bRet = bool( !IsError() );
     618             : 
     619             :     // If FIXED resulted in an error, set it back
     620             :     // (UI-Action should not result in an error, but simply fail)
     621           0 :     if( !bRet )
     622           0 :         ResetError();
     623             : 
     624           0 :     SetFlags( nFlags_ );
     625           0 :     return bRet;
     626             : }
     627             : 
     628        1553 : bool SbxValue::PutBool( bool b )
     629             : {
     630        1553 :     SbxValues aRes;
     631        1553 :     aRes.eType = SbxBOOL;
     632        1553 :     aRes.nUShort = sal::static_int_cast< sal_uInt16 >(b ? SbxTRUE : SbxFALSE);
     633        1553 :     Put( aRes );
     634        1553 :     return !IsError();
     635             : }
     636             : 
     637        1531 : bool SbxValue::PutEmpty()
     638             : {
     639        1531 :     bool bRet = SetType( SbxEMPTY );
     640        1531 :         SetModified( true );
     641        1531 :     return bRet;
     642             : }
     643             : 
     644           0 : bool SbxValue::PutNull()
     645             : {
     646           0 :     bool bRet = SetType( SbxNULL );
     647           0 :     if( bRet )
     648           0 :         SetModified( true );
     649           0 :     return bRet;
     650             : }
     651             : 
     652             : 
     653             : // Special decimal methods
     654           0 : bool SbxValue::PutDecimal( com::sun::star::bridge::oleautomation::Decimal& rAutomationDec )
     655             : {
     656           0 :     SbxValue::Clear();
     657           0 :     aData.pDecimal = new SbxDecimal( rAutomationDec );
     658           0 :     aData.pDecimal->addRef();
     659           0 :     aData.eType = SbxDECIMAL;
     660           0 :     return true;
     661             : }
     662             : 
     663           0 : bool SbxValue::fillAutomationDecimal
     664             :     ( com::sun::star::bridge::oleautomation::Decimal& rAutomationDec ) const
     665             : {
     666           0 :     SbxDecimal* pDecimal = GetDecimal();
     667           0 :     if( pDecimal != NULL )
     668             :     {
     669           0 :         pDecimal->fillAutomationDecimal( rAutomationDec );
     670           0 :         return true;
     671             :     }
     672           0 :     return false;
     673             : }
     674             : 
     675             : 
     676        7041 : bool SbxValue::PutString( const OUString& r )
     677             : {
     678        7041 :     SbxValues aRes;
     679        7041 :     aRes.eType = SbxSTRING;
     680        7041 :     aRes.pOUString = const_cast<OUString*>(&r);
     681        7041 :     Put( aRes );
     682        7041 :     return !IsError();
     683             : }
     684             : 
     685             : 
     686             : #define PUT( p, e, t, m ) \
     687             : bool SbxValue::p( t n ) \
     688             : { SbxValues aRes(e); aRes.m = n; Put( aRes ); return !IsError(); }
     689             : 
     690          12 : PUT( PutByte,     SbxBYTE,       sal_uInt8,        nByte )
     691           0 : PUT( PutChar,     SbxCHAR,       sal_Unicode,      nChar )
     692           3 : PUT( PutCurrency, SbxCURRENCY,   const sal_Int64&, nInt64 )
     693           5 : PUT( PutDate,     SbxDATE,       double,           nDouble )
     694        2990 : PUT( PutDouble,   SbxDOUBLE,     double,           nDouble )
     695          19 : PUT( PutErr,      SbxERROR,      sal_uInt16,       nUShort )
     696        3301 : PUT( PutInteger,  SbxINTEGER,    sal_Int16,        nInteger )
     697        2810 : PUT( PutLong,     SbxLONG,       sal_Int32,        nLong )
     698        3089 : PUT( PutObject,   SbxOBJECT,     SbxBase*,         pObj )
     699           2 : PUT( PutSingle,   SbxSINGLE,     float,            nSingle )
     700           0 : PUT( PutULong,    SbxULONG,      sal_uInt32,       nULong )
     701           0 : PUT( PutUShort,   SbxUSHORT,     sal_uInt16,       nUShort )
     702           0 : PUT( PutInt64,    SbxSALINT64,   sal_Int64,        nInt64 )
     703           0 : PUT( PutUInt64,   SbxSALUINT64,  sal_uInt64,       uInt64 )
     704           0 : PUT( PutDecimal,  SbxDECIMAL,    SbxDecimal*,      pDecimal )
     705             : 
     706             : ////////////////////////// Setting of the data type
     707             : 
     708       95677 : bool SbxValue::IsFixed() const
     709             : {
     710       95677 :     return ((GetFlags() & SBX_FIXED) != SBX_NONE) || ((aData.eType & SbxBYREF) != 0);
     711             : }
     712             : 
     713             : // A variable is numeric, if it is EMPTY or really numeric
     714             : // or if it contains a complete convertible String
     715             : 
     716             : // #41692, implement it for RTL and Basic-Core separately
     717         635 : bool SbxValue::IsNumeric() const
     718             : {
     719         635 :     return ImpIsNumeric( /*bOnlyIntntl*/false );
     720             : }
     721             : 
     722           4 : bool SbxValue::IsNumericRTL() const
     723             : {
     724           4 :     return ImpIsNumeric( /*bOnlyIntntl*/true );
     725             : }
     726             : 
     727         639 : bool SbxValue::ImpIsNumeric( bool bOnlyIntntl ) const
     728             : {
     729             : 
     730         639 :     if( !CanRead() )
     731             :     {
     732           0 :         SetError( SbxERR_PROP_WRITEONLY );
     733           0 :         return false;
     734             :     }
     735             :     // Test downcast!!!
     736         639 :     if( this->ISA(SbxVariable) )
     737          18 :         const_cast<SbxVariable*>(static_cast<const SbxVariable*>(this))->Broadcast( SBX_HINT_DATAWANTED );
     738         639 :     SbxDataType t = GetType();
     739         639 :     if( t == SbxSTRING )
     740             :     {
     741         621 :         if( aData.pOUString )
     742             :         {
     743         620 :             OUString s( *aData.pOUString );
     744             :             double n;
     745             :             SbxDataType t2;
     746         620 :             sal_uInt16 nLen = 0;
     747         620 :             if( ImpScan( s, n, t2, &nLen, /*bAllowIntntl*/false, bOnlyIntntl ) == SbxERR_OK )
     748         620 :                 return nLen == s.getLength();
     749             :         }
     750           1 :         return false;
     751             :     }
     752             :     else
     753             :         return t == SbxEMPTY
     754          11 :             || ( t >= SbxINTEGER && t <= SbxCURRENCY )
     755          18 :             || ( t >= SbxCHAR && t <= SbxUINT );
     756             : }
     757             : 
     758           0 : SbxClassType SbxValue::GetClass() const
     759             : {
     760           0 :     return SbxCLASS_VALUE;
     761             : }
     762             : 
     763       95351 : SbxDataType SbxValue::GetType() const
     764             : {
     765       95351 :     return SbxDataType( aData.eType & 0x0FFF );
     766             : }
     767             : 
     768             : 
     769       37072 : bool SbxValue::SetType( SbxDataType t )
     770             : {
     771             :     DBG_ASSERT( !( t & 0xF000 ), "SetType of BYREF|ARRAY is forbidden!" );
     772       37072 :     if( ( t == SbxEMPTY && aData.eType == SbxVOID )
     773       36562 :      || ( aData.eType == SbxEMPTY && t == SbxVOID ) )
     774         565 :         return true;
     775       36507 :     if( ( t & 0x0FFF ) == SbxVARIANT )
     776             :     {
     777             :         // Try to set the data type to Variant
     778         167 :         ResetFlag( SBX_FIXED );
     779         167 :         if( IsFixed() )
     780             :         {
     781           0 :             SetError( SbxERR_CONVERSION );
     782           0 :             return false;
     783             :         }
     784         167 :         t = SbxEMPTY;
     785             :     }
     786       36507 :     if( ( t & 0x0FFF ) != ( aData.eType & 0x0FFF ) )
     787             :     {
     788       17120 :         if( !CanWrite() || IsFixed() )
     789             :         {
     790           0 :             SetError( SbxERR_CONVERSION );
     791           0 :             return false;
     792             :         }
     793             :         else
     794             :         {
     795             :             // De-allocate potential objects
     796       17120 :             switch( aData.eType )
     797             :             {
     798             :                 case SbxSTRING:
     799          18 :                     delete aData.pOUString;
     800          18 :                     break;
     801             :                 case SbxOBJECT:
     802          25 :                     if( aData.pObj && aData.pObj != this )
     803             :                     {
     804             :                         SAL_WARN("basic.sbx", "Not at Parent-Prop - otherwise CyclicRef");
     805          18 :                         SbxVariable *pThisVar = PTR_CAST(SbxVariable, this);
     806             :                         sal_uInt16 nSlotId = pThisVar
     807          18 :                                     ? ( (sal_Int16) ( pThisVar->GetUserData() & 0xFFFF ) )
     808          36 :                                     : 0;
     809             :                         DBG_ASSERT( nSlotId != 5345 || pThisVar->GetName() == "Parent",
     810             :                                     "SID_PARENTOBJECT is not named 'Parent'" );
     811          18 :                         bool bParentProp = 5345 == nSlotId;
     812          18 :                         if ( !bParentProp )
     813          18 :                             aData.pObj->ReleaseRef();
     814             :                     }
     815          25 :                     break;
     816       17077 :                 default: break;
     817             :             }
     818             :             // This works always, because the Float representations are 0 as well.
     819       17120 :             memset( &aData, 0, sizeof( SbxValues ) );
     820       17120 :             aData.eType = t;
     821             :         }
     822             :     }
     823       36507 :     return true;
     824             : }
     825             : 
     826          19 : bool SbxValue::Convert( SbxDataType eTo )
     827             : {
     828          19 :     eTo = SbxDataType( eTo & 0x0FFF );
     829          19 :     if( ( aData.eType & 0x0FFF ) == eTo )
     830          19 :         return true;
     831           0 :     if( !CanWrite() )
     832           0 :         return false;
     833           0 :     if( eTo == SbxVARIANT )
     834             :     {
     835             :         // Trial to set the data type to Variant
     836           0 :         ResetFlag( SBX_FIXED );
     837           0 :         if( IsFixed() )
     838             :         {
     839           0 :             SetError( SbxERR_CONVERSION );
     840           0 :             return false;
     841             :         }
     842             :         else
     843           0 :             return true;
     844             :     }
     845             :     // Converting from null doesn't work. Once null, always null!
     846           0 :     if( aData.eType == SbxNULL )
     847             :     {
     848           0 :         SetError( SbxERR_CONVERSION );
     849           0 :         return false;
     850             :     }
     851             : 
     852             :     // Conversion of the data:
     853           0 :     SbxValues aNew;
     854           0 :     aNew.eType = eTo;
     855           0 :     if( Get( aNew ) )
     856             :     {
     857             :         // The data type could be converted. It ends here with fixed elements,
     858             :         // because the data had not to be taken over
     859           0 :         if( !IsFixed() )
     860             :         {
     861           0 :             SetType( eTo );
     862           0 :             Put( aNew );
     863           0 :             SetModified( true );
     864             :         }
     865           0 :         Broadcast( SBX_HINT_CONVERTED );
     866           0 :         return true;
     867             :     }
     868             :     else
     869           0 :         return false;
     870             : }
     871             : ////////////////////////////////// Calculating
     872             : 
     873        3432 : bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp )
     874             : {
     875             : #if !HAVE_FEATURE_SCRIPTING
     876             :     const bool bVBAInterop = false;
     877             : #else
     878        3432 :     bool bVBAInterop =  SbiRuntime::isVBAEnabled();
     879             : #endif
     880        3432 :     SbxDataType eThisType = GetType();
     881        3432 :     SbxDataType eOpType = rOp.GetType();
     882        3432 :     SbxError eOld = GetError();
     883        3432 :     if( eOld != SbxERR_OK )
     884           0 :         ResetError();
     885        3432 :     if( !CanWrite() )
     886           0 :         SetError( SbxERR_PROP_READONLY );
     887        3432 :     else if( !rOp.CanRead() )
     888           0 :         SetError( SbxERR_PROP_WRITEONLY );
     889             :     // Special rule 1: If one operand is null, the result is null
     890        3432 :     else if( eThisType == SbxNULL || eOpType == SbxNULL )
     891           0 :         SetType( SbxNULL );
     892             :     // Special rule 2: If the operand is Empty, the result is the 2. operand
     893        3432 :     else if( eThisType == SbxEMPTY
     894           9 :     && !bVBAInterop
     895             :     )
     896           0 :         *this = rOp;
     897             :     // 1996-2-13: Don't test for SbxEMPTY before Get
     898             :     else
     899             :     {
     900        3432 :         SbxValues aL, aR;
     901        3432 :         bool bDecimal = false;
     902        3432 :         if( bVBAInterop && ( ( eThisType == SbxSTRING && eOpType != SbxSTRING && eOpType != SbxEMPTY ) ||
     903        1231 :              ( eThisType != SbxSTRING && eThisType != SbxEMPTY && eOpType == SbxSTRING ) ) &&
     904         362 :              ( eOp == SbxMUL || eOp == SbxDIV || eOp == SbxPLUS || eOp == SbxMINUS ) )
     905             :         {
     906             :             goto Lbl_OpIsDouble;
     907             :         }
     908        3420 :         else if( eThisType == SbxSTRING || eOp == SbxCAT || ( bVBAInterop && ( eOpType == SbxSTRING ) && (  eOp == SbxPLUS ) ) )
     909             :         {
     910        2851 :             if( eOp == SbxCAT || eOp == SbxPLUS )
     911             :             {
     912             :                 // From 1999-11-5, keep OUString in mind
     913        1426 :                 aL.eType = aR.eType = SbxSTRING;
     914        1426 :                 rOp.Get( aR );
     915             :                 // From 1999-12-8, #70399: Here call GetType() again, Get() can change the type!
     916        1426 :                 if( rOp.GetType() == SbxEMPTY )
     917           2 :                     goto Lbl_OpIsEmpty;
     918        1425 :                 Get( aL );
     919             : 
     920             :                 // #30576: To begin with test, if the conversion worked
     921        1425 :                 if( aL.pOUString != NULL && aR.pOUString != NULL )
     922             :                 {
     923        1425 :                     *aL.pOUString += *aR.pOUString;
     924             :                 }
     925             :                 // Not even Left OK?
     926           0 :                 else if( aL.pOUString == NULL )
     927             :                 {
     928           0 :                     aL.pOUString = new OUString();
     929             :                 }
     930        1425 :                 Put( aL );
     931             :             }
     932             :             else
     933           0 :                 SetError( SbxERR_CONVERSION );
     934             :         }
     935        1994 :         else if( eOpType == SbxSTRING && rOp.IsFixed() )
     936             :         {   // Numeric: there is no String allowed on the right side
     937           0 :             SetError( SbxERR_CONVERSION );
     938             :             // falls all the way out
     939             :         }
     940        1994 :         else if( ( eOp >= SbxIDIV && eOp <= SbxNOT ) || eOp == SbxMOD )
     941             :         {
     942         595 :             if( GetType() == eOpType )
     943             :             {
     944        1773 :                 if( GetType() == SbxSALUINT64 || GetType() == SbxSALINT64
     945        1182 :                  || GetType() == SbxCURRENCY  || GetType() == SbxULONG )
     946           0 :                     aL.eType = aR.eType = GetType();
     947         591 :                 else if ( bVBAInterop && eOpType == SbxBOOL )
     948          77 :                     aL.eType = aR.eType = SbxBOOL;
     949             :                 else
     950         514 :                     aL.eType = aR.eType = SbxLONG;
     951             :             }
     952             :             else
     953           4 :                 aL.eType = aR.eType = SbxLONG;
     954             : 
     955        1190 :             if( rOp.Get( aR ) )     // re-do Get after type assigns above
     956             :             {
     957         595 :                 if( rOp.GetType() == SbxEMPTY )
     958             :                 {
     959           0 :                     if ( !bVBAInterop || ( bVBAInterop && ( eOp != SbxNOT  ) ) )
     960             :                         goto Lbl_OpIsEmpty;
     961             :                 }
     962         595 :                 if( Get( aL ) ) switch( eOp )
     963             :                 {
     964             :                     case SbxIDIV:
     965           0 :                         if( aL.eType == SbxCURRENCY )
     966           0 :                             if( !aR.nInt64 ) SetError( SbxERR_ZERODIV );
     967             :                             else {
     968           0 :                                 aL.nInt64 /= aR.nInt64;
     969           0 :                                 aL.nInt64 *= CURRENCY_FACTOR;
     970             :                         }
     971           0 :                         else if( aL.eType == SbxSALUINT64 )
     972           0 :                             if( !aR.uInt64 ) SetError( SbxERR_ZERODIV );
     973           0 :                             else aL.uInt64 /= aR.uInt64;
     974           0 :                         else if( aL.eType == SbxSALINT64 )
     975           0 :                             if( !aR.nInt64 ) SetError( SbxERR_ZERODIV );
     976           0 :                             else aL.nInt64 /= aR.nInt64;
     977           0 :                         else if( aL.eType == SbxLONG )
     978           0 :                             if( !aR.nLong ) SetError( SbxERR_ZERODIV );
     979           0 :                             else aL.nLong /= aR.nLong;
     980             :                         else
     981           0 :                             if( !aR.nULong ) SetError( SbxERR_ZERODIV );
     982           0 :                             else aL.nULong /= aR.nULong;
     983           0 :                         break;
     984             :                     case SbxMOD:
     985           0 :                         if( aL.eType == SbxCURRENCY || aL.eType == SbxSALINT64 )
     986           0 :                             if( !aR.nInt64 ) SetError( SbxERR_ZERODIV );
     987           0 :                             else aL.nInt64 %= aR.nInt64;
     988           0 :                         else if( aL.eType == SbxSALUINT64 )
     989           0 :                             if( !aR.uInt64 ) SetError( SbxERR_ZERODIV );
     990           0 :                             else aL.uInt64 %= aR.uInt64;
     991           0 :                         else if( aL.eType == SbxLONG )
     992           0 :                             if( !aR.nLong ) SetError( SbxERR_ZERODIV );
     993           0 :                             else aL.nLong %= aR.nLong;
     994             :                         else
     995           0 :                             if( !aR.nULong ) SetError( SbxERR_ZERODIV );
     996           0 :                             else aL.nULong %= aR.nULong;
     997           0 :                         break;
     998             :                     case SbxAND:
     999         100 :                         if( aL.eType != SbxLONG && aL.eType != SbxULONG )
    1000          49 :                             aL.nInt64 &= aR.nInt64;
    1001             :                         else
    1002          51 :                             aL.nLong &= aR.nLong;
    1003         100 :                         break;
    1004             :                     case SbxOR:
    1005         433 :                         if( aL.eType != SbxLONG && aL.eType != SbxULONG )
    1006           7 :                             aL.nInt64 |= aR.nInt64;
    1007             :                         else
    1008         426 :                             aL.nLong |= aR.nLong;
    1009         433 :                         break;
    1010             :                     case SbxXOR:
    1011           0 :                         if( aL.eType != SbxLONG && aL.eType != SbxULONG )
    1012           0 :                             aL.nInt64 ^= aR.nInt64;
    1013             :                         else
    1014           0 :                             aL.nLong ^= aR.nLong;
    1015           0 :                         break;
    1016             :                     case SbxEQV:
    1017           0 :                         if( aL.eType != SbxLONG && aL.eType != SbxULONG )
    1018           0 :                             aL.nInt64 = (aL.nInt64 & aR.nInt64) | (~aL.nInt64 & ~aR.nInt64);
    1019             :                         else
    1020           0 :                             aL.nLong = (aL.nLong & aR.nLong) | (~aL.nLong & ~aR.nLong);
    1021           0 :                         break;
    1022             :                     case SbxIMP:
    1023           0 :                         if( aL.eType != SbxLONG && aL.eType != SbxULONG )
    1024           0 :                             aL.nInt64 = ~aL.nInt64 | aR.nInt64;
    1025             :                         else
    1026           0 :                             aL.nLong = ~aL.nLong | aR.nLong;
    1027           0 :                         break;
    1028             :                     case SbxNOT:
    1029          62 :                         if( aL.eType != SbxLONG && aL.eType != SbxULONG )
    1030             :                         {
    1031          42 :                             if ( aL.eType != SbxBOOL )
    1032           0 :                                 aL.nInt64 = ~aL.nInt64;
    1033             :                             else
    1034          21 :                                 aL.nLong = ~aL.nLong;
    1035             :                         }
    1036             :                         else
    1037          41 :                             aL.nLong = ~aL.nLong;
    1038          62 :                         break;
    1039           0 :                     default: break;
    1040             :                 }
    1041             :             }
    1042             :         }
    1043        4197 :         else if( ( GetType() == SbxDECIMAL || rOp.GetType() == SbxDECIMAL )
    1044        1399 :               && ( eOp == SbxMUL || eOp == SbxDIV || eOp == SbxPLUS || eOp == SbxMINUS || eOp == SbxNEG ) )
    1045             :         {
    1046           0 :             aL.eType = aR.eType = SbxDECIMAL;
    1047           0 :             bDecimal = true;
    1048           0 :             if( rOp.Get( aR ) )
    1049             :             {
    1050           0 :                 if( rOp.GetType() == SbxEMPTY )
    1051             :                 {
    1052           0 :                     releaseDecimalPtr( aL.pDecimal );
    1053           0 :                     goto Lbl_OpIsEmpty;
    1054             :                 }
    1055           0 :                 if( Get( aL ) )
    1056             :                 {
    1057           0 :                     if( aL.pDecimal && aR.pDecimal )
    1058             :                     {
    1059           0 :                         bool bOk = true;
    1060           0 :                         switch( eOp )
    1061             :                         {
    1062             :                             case SbxMUL:
    1063           0 :                                 bOk = ( *(aL.pDecimal) *= *(aR.pDecimal) );
    1064           0 :                                 break;
    1065             :                             case SbxDIV:
    1066           0 :                                 if( aR.pDecimal->isZero() )
    1067           0 :                                     SetError( SbxERR_ZERODIV );
    1068             :                                 else
    1069           0 :                                     bOk = ( *(aL.pDecimal) /= *(aR.pDecimal) );
    1070           0 :                                 break;
    1071             :                             case SbxPLUS:
    1072           0 :                                 bOk = ( *(aL.pDecimal) += *(aR.pDecimal) );
    1073           0 :                                 break;
    1074             :                             case SbxMINUS:
    1075           0 :                                 bOk = ( *(aL.pDecimal) -= *(aR.pDecimal) );
    1076           0 :                                 break;
    1077             :                             case SbxNEG:
    1078           0 :                                 bOk = ( aL.pDecimal->neg() );
    1079           0 :                                 break;
    1080             :                             default:
    1081           0 :                                 SetError( SbxERR_NOTIMP );
    1082             :                         }
    1083           0 :                         if( !bOk )
    1084           0 :                             SetError( SbxERR_OVERFLOW );
    1085             :                     }
    1086             :                     else
    1087             :                     {
    1088           0 :                         SetError( SbxERR_CONVERSION );
    1089             :                     }
    1090             :                 }
    1091             :             }
    1092             :         }
    1093        1399 :         else if( GetType() == SbxCURRENCY || rOp.GetType() == SbxCURRENCY )
    1094             :         {
    1095           0 :             aL.eType = SbxCURRENCY;
    1096           0 :             aR.eType = SbxCURRENCY;
    1097             : 
    1098           0 :             if( rOp.Get( aR ) )
    1099             :             {
    1100           0 :                 if( rOp.GetType() == SbxEMPTY )
    1101           0 :                     goto Lbl_OpIsEmpty;
    1102             : 
    1103           0 :                 if( Get( aL ) ) switch( eOp )
    1104             :                 {
    1105             :                     double dTest;
    1106             :                     case SbxMUL:
    1107             :                         // first overflow check: see if product will fit - test real value of product (hence 2 curr factors)
    1108           0 :                         dTest = (double)aL.nInt64 * (double)aR.nInt64 / (double)CURRENCY_FACTOR_SQUARE;
    1109           0 :                         if( dTest < SbxMINCURR || SbxMAXCURR < dTest)
    1110             :                         {
    1111           0 :                             aL.nInt64 = SAL_MAX_INT64;
    1112           0 :                             if( dTest < SbxMINCURR ) aL.nInt64 = SAL_MIN_INT64;
    1113           0 :                             SetError( SbxERR_OVERFLOW );
    1114           0 :                             break;
    1115             :                         }
    1116             :                         // second overflow check: see if unscaled product overflows - if so use doubles
    1117           0 :                         dTest = (double)aL.nInt64 * (double)aR.nInt64;
    1118           0 :                         if( dTest < SAL_MIN_INT64 || SAL_MAX_INT64 < dTest)
    1119             :                         {
    1120           0 :                             aL.nInt64 = (sal_Int64)( dTest / (double)CURRENCY_FACTOR );
    1121           0 :                             break;
    1122             :                         }
    1123             :                         // precise calc: multiply then scale back (move decimal pt)
    1124           0 :                         aL.nInt64 *= aR.nInt64;
    1125           0 :                         aL.nInt64 /= CURRENCY_FACTOR;
    1126           0 :                         break;
    1127             : 
    1128             :                     case SbxDIV:
    1129           0 :                         if( !aR.nInt64 )
    1130             :                         {
    1131           0 :                             SetError( SbxERR_ZERODIV );
    1132           0 :                             break;
    1133             :                         }
    1134             :                         // first overflow check: see if quotient will fit - calc real value of quotient (curr factors cancel)
    1135           0 :                         dTest = (double)aL.nInt64 / (double)aR.nInt64;
    1136           0 :                         if( dTest < SbxMINCURR || SbxMAXCURR < dTest)
    1137             :                         {
    1138           0 :                             SetError( SbxERR_OVERFLOW );
    1139           0 :                             break;
    1140             :                         }
    1141             :                         // second overflow check: see if scaled dividend overflows - if so use doubles
    1142           0 :                         dTest = (double)aL.nInt64 * (double)CURRENCY_FACTOR;
    1143           0 :                         if( dTest < SAL_MIN_INT64 || SAL_MAX_INT64 < dTest)
    1144             :                         {
    1145           0 :                             aL.nInt64 = (sal_Int64)(dTest / (double)aR.nInt64);
    1146           0 :                             break;
    1147             :                         }
    1148             :                         // precise calc: scale (move decimal pt) then divide
    1149           0 :                         aL.nInt64 *= CURRENCY_FACTOR;
    1150           0 :                         aL.nInt64 /= aR.nInt64;
    1151           0 :                         break;
    1152             : 
    1153             :                     case SbxPLUS:
    1154           0 :                         dTest = ( (double)aL.nInt64 + (double)aR.nInt64 ) / (double)CURRENCY_FACTOR;
    1155           0 :                         if( dTest < SbxMINCURR || SbxMAXCURR < dTest)
    1156             :                         {
    1157           0 :                             SetError( SbxERR_OVERFLOW );
    1158           0 :                             break;
    1159             :                         }
    1160           0 :                         aL.nInt64 += aR.nInt64;
    1161           0 :                         break;
    1162             : 
    1163             :                     case SbxMINUS:
    1164           0 :                         dTest = ( (double)aL.nInt64 - (double)aR.nInt64 ) / (double)CURRENCY_FACTOR;
    1165           0 :                         if( dTest < SbxMINCURR || SbxMAXCURR < dTest)
    1166             :                         {
    1167           0 :                             SetError( SbxERR_OVERFLOW );
    1168           0 :                             break;
    1169             :                         }
    1170           0 :                         aL.nInt64 -= aR.nInt64;
    1171           0 :                         break;
    1172             :                     case SbxNEG:
    1173           0 :                         aL.nInt64 = -aL.nInt64;
    1174           0 :                         break;
    1175             :                     default:
    1176           0 :                         SetError( SbxERR_NOTIMP );
    1177             :                 }
    1178             :             }
    1179             :         }
    1180             :         else
    1181             : Lbl_OpIsDouble:
    1182             :         {   // other types and operators including Date, Double and Single
    1183        1411 :             aL.eType = aR.eType = SbxDOUBLE;
    1184        1411 :             if( rOp.Get( aR ) )
    1185             :             {
    1186        1411 :                 if( rOp.GetType() == SbxEMPTY )
    1187             :                 {
    1188           0 :                     if ( !bVBAInterop || ( bVBAInterop && ( eOp != SbxNEG ) ) )
    1189             :                         goto Lbl_OpIsEmpty;
    1190             :                 }
    1191        1411 :                 if( Get( aL ) )
    1192             :                 {
    1193        1403 :                     switch( eOp )
    1194             :                     {
    1195             :                         case SbxEXP:
    1196           0 :                             aL.nDouble = pow( aL.nDouble, aR.nDouble );
    1197           0 :                             break;
    1198             :                         case SbxMUL:
    1199          18 :                             aL.nDouble *= aR.nDouble; break;
    1200             :                         case SbxDIV:
    1201           0 :                             if( !aR.nDouble ) SetError( SbxERR_ZERODIV );
    1202           0 :                             else aL.nDouble /= aR.nDouble; break;
    1203             :                         case SbxPLUS:
    1204        1337 :                             aL.nDouble += aR.nDouble; break;
    1205             :                         case SbxMINUS:
    1206          37 :                             aL.nDouble -= aR.nDouble; break;
    1207             :                         case SbxNEG:
    1208          11 :                             aL.nDouble = -aL.nDouble; break;
    1209             :                         default:
    1210           0 :                             SetError( SbxERR_NOTIMP );
    1211             :                     }
    1212             :                     // Date with "+" or "-" needs special handling that
    1213             :                     // forces the Date type. If the operation is '+' the
    1214             :                     // result is always a Date, if '-' the result is only
    1215             :                     // a Date if one of lhs or rhs ( but not both ) is already
    1216             :                     // a Date
    1217        1403 :                     if( ( GetType() == SbxDATE || rOp.GetType() == SbxDATE ) )
    1218             :                     {
    1219           0 :                         if( eOp == SbxPLUS  || ( ( eOp == SbxMINUS ) &&  ( GetType() != rOp.GetType() ) ) )
    1220           0 :                             aL.eType = SbxDATE;
    1221             :                     }
    1222             : 
    1223             :                 }
    1224             :             }
    1225             : 
    1226             :         }
    1227        3431 :         if( !IsError() )
    1228        3423 :             Put( aL );
    1229        3431 :         if( bDecimal )
    1230             :         {
    1231           0 :             releaseDecimalPtr( aL.pDecimal );
    1232           0 :             releaseDecimalPtr( aR.pDecimal );
    1233             :         }
    1234             :     }
    1235             : Lbl_OpIsEmpty:
    1236             : 
    1237        3432 :     bool bRes = !IsError();
    1238        3432 :     if( bRes && eOld != SbxERR_OK )
    1239           0 :         SetError( eOld );
    1240        3432 :     return bRes;
    1241             : }
    1242             : 
    1243             : // The comparison routine deliver TRUE or FALSE.
    1244             : 
    1245        3152 : bool SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const
    1246             : {
    1247             : #if !HAVE_FEATURE_SCRIPTING
    1248             :     const bool bVBAInterop = false;
    1249             : #else
    1250        3152 :     bool bVBAInterop =  SbiRuntime::isVBAEnabled();
    1251             : #endif
    1252             : 
    1253        3152 :     bool bRes = false;
    1254        3152 :     SbxError eOld = GetError();
    1255        3152 :     if( eOld != SbxERR_OK )
    1256           0 :         ResetError();
    1257        3152 :     if( !CanRead() || !rOp.CanRead() )
    1258           0 :         SetError( SbxERR_PROP_WRITEONLY );
    1259        3152 :     else if( GetType() == SbxNULL && rOp.GetType() == SbxNULL && !bVBAInterop )
    1260             :     {
    1261           0 :         bRes = true;
    1262             :     }
    1263        3152 :     else if( GetType() == SbxEMPTY && rOp.GetType() == SbxEMPTY )
    1264           3 :         bRes = !bVBAInterop || ( eOp == SbxEQ );
    1265             :     // Special rule 1: If an operand is null, the result is FALSE
    1266        3149 :     else if( GetType() == SbxNULL || rOp.GetType() == SbxNULL )
    1267           0 :         bRes = false;
    1268             :     // Special rule 2: If both are variant and one is numeric
    1269             :     // and the other is a String, num is < str
    1270        7046 :     else if( !IsFixed() && !rOp.IsFixed()
    1271        3789 :      && ( rOp.GetType() == SbxSTRING && GetType() != SbxSTRING && IsNumeric() ) && !bVBAInterop
    1272             :     )
    1273           1 :         bRes = eOp == SbxLT || eOp == SbxLE || eOp == SbxNE;
    1274        7043 :     else if( !IsFixed() && !rOp.IsFixed()
    1275         639 :      && ( GetType() == SbxSTRING && rOp.GetType() != SbxSTRING && rOp.IsNumeric() )
    1276        3148 : && !bVBAInterop
    1277             :     )
    1278           0 :         bRes = eOp == SbxGT || eOp == SbxGE || eOp == SbxNE;
    1279             :     else
    1280             :     {
    1281        3148 :         SbxValues aL, aR;
    1282             :         // If one of the operands is a String,
    1283             :         // a String comparing take place
    1284        3148 :         if( GetType() == SbxSTRING || rOp.GetType() == SbxSTRING )
    1285             :         {
    1286         509 :             aL.eType = aR.eType = SbxSTRING;
    1287         509 :             if( Get( aL ) && rOp.Get( aR ) ) switch( eOp )
    1288             :             {
    1289             :                 case SbxEQ:
    1290         268 :                     bRes = ( *aL.pOUString == *aR.pOUString ); break;
    1291             :                 case SbxNE:
    1292         241 :                     bRes = ( *aL.pOUString != *aR.pOUString ); break;
    1293             :                 case SbxLT:
    1294           0 :                     bRes = ( *aL.pOUString <  *aR.pOUString ); break;
    1295             :                 case SbxGT:
    1296           0 :                     bRes = ( *aL.pOUString >  *aR.pOUString ); break;
    1297             :                 case SbxLE:
    1298           0 :                     bRes = ( *aL.pOUString <= *aR.pOUString ); break;
    1299             :                 case SbxGE:
    1300           0 :                     bRes = ( *aL.pOUString >= *aR.pOUString ); break;
    1301             :                 default:
    1302           0 :                     SetError( SbxERR_NOTIMP );
    1303             :             }
    1304             :         }
    1305             :         // From 1995-12-19: If SbxSINGLE participate, then convert to SINGLE,
    1306             :         //              otherwise it shows a numeric error
    1307        2639 :         else if( GetType() == SbxSINGLE || rOp.GetType() == SbxSINGLE )
    1308             :         {
    1309           0 :             aL.eType = aR.eType = SbxSINGLE;
    1310           0 :             if( Get( aL ) && rOp.Get( aR ) )
    1311           0 :               switch( eOp )
    1312             :             {
    1313             :                 case SbxEQ:
    1314           0 :                     bRes = ( aL.nSingle == aR.nSingle ); break;
    1315             :                 case SbxNE:
    1316           0 :                     bRes = ( aL.nSingle != aR.nSingle ); break;
    1317             :                 case SbxLT:
    1318           0 :                     bRes = ( aL.nSingle <  aR.nSingle ); break;
    1319             :                 case SbxGT:
    1320           0 :                     bRes = ( aL.nSingle >  aR.nSingle ); break;
    1321             :                 case SbxLE:
    1322           0 :                     bRes = ( aL.nSingle <= aR.nSingle ); break;
    1323             :                 case SbxGE:
    1324           0 :                     bRes = ( aL.nSingle >= aR.nSingle ); break;
    1325             :                 default:
    1326           0 :                     SetError( SbxERR_NOTIMP );
    1327             :             }
    1328             :         }
    1329        2639 :         else if( GetType() == SbxDECIMAL && rOp.GetType() == SbxDECIMAL )
    1330             :         {
    1331           0 :             aL.eType = aR.eType = SbxDECIMAL;
    1332           0 :             Get( aL );
    1333           0 :             rOp.Get( aR );
    1334           0 :             if( aL.pDecimal && aR.pDecimal )
    1335             :             {
    1336           0 :                 SbxDecimal::CmpResult eRes = compare( *aL.pDecimal, *aR.pDecimal );
    1337           0 :                 switch( eOp )
    1338             :                 {
    1339             :                     case SbxEQ:
    1340           0 :                         bRes = ( eRes == SbxDecimal::EQ ); break;
    1341             :                     case SbxNE:
    1342           0 :                         bRes = ( eRes != SbxDecimal::EQ ); break;
    1343             :                     case SbxLT:
    1344           0 :                         bRes = ( eRes == SbxDecimal::LT ); break;
    1345             :                     case SbxGT:
    1346           0 :                         bRes = ( eRes == SbxDecimal::GT ); break;
    1347             :                     case SbxLE:
    1348           0 :                         bRes = ( eRes != SbxDecimal::GT ); break;
    1349             :                     case SbxGE:
    1350           0 :                         bRes = ( eRes != SbxDecimal::LT ); break;
    1351             :                     default:
    1352           0 :                         SetError( SbxERR_NOTIMP );
    1353           0 :                 }
    1354             :             }
    1355             :             else
    1356             :             {
    1357           0 :                 SetError( SbxERR_CONVERSION );
    1358             :             }
    1359           0 :             releaseDecimalPtr( aL.pDecimal );
    1360           0 :             releaseDecimalPtr( aR.pDecimal );
    1361             :         }
    1362             :         // Everything else comparing on a SbxDOUBLE-Basis
    1363             :         else
    1364             :         {
    1365        2639 :             aL.eType = aR.eType = SbxDOUBLE;
    1366        2639 :             bool bGetL = Get( aL );
    1367        2639 :             bool bGetR = rOp.Get( aR );
    1368        5278 :             if( bGetL && bGetR )
    1369        2639 :               switch( eOp )
    1370             :             {
    1371             :                 case SbxEQ:
    1372        1732 :                     bRes = ( aL.nDouble == aR.nDouble ); break;
    1373             :                 case SbxNE:
    1374         276 :                     bRes = ( aL.nDouble != aR.nDouble ); break;
    1375             :                 case SbxLT:
    1376          41 :                     bRes = ( aL.nDouble <  aR.nDouble ); break;
    1377             :                 case SbxGT:
    1378         586 :                     bRes = ( aL.nDouble >  aR.nDouble ); break;
    1379             :                 case SbxLE:
    1380           0 :                     bRes = ( aL.nDouble <= aR.nDouble ); break;
    1381             :                 case SbxGE:
    1382           4 :                     bRes = ( aL.nDouble >= aR.nDouble ); break;
    1383             :                 default:
    1384           0 :                     SetError( SbxERR_NOTIMP );
    1385             :             }
    1386             :             // at least one value was got
    1387             :             // if this is VBA then a conversion error for one
    1388             :             // side will yield a false result of an equality test
    1389           0 :             else if ( bGetR || bGetL )
    1390             :             {
    1391           0 :                 if ( bVBAInterop && eOp == SbxEQ && GetError() == SbxERR_CONVERSION )
    1392             :                 {
    1393           0 :                     ResetError();
    1394           0 :                     bRes = false;
    1395             :                 }
    1396             :             }
    1397             :         }
    1398             :     }
    1399        3152 :     if( eOld != SbxERR_OK )
    1400           0 :         SetError( eOld );
    1401        3152 :     return bRes;
    1402             : }
    1403             : 
    1404             : ///////////////////////////// Reading/Writing
    1405             : 
    1406           0 : bool SbxValue::LoadData( SvStream& r, sal_uInt16 )
    1407             : {
    1408             :     // #TODO see if these types are really dumped to any stream
    1409             :     // more than likely this is functionality used in the binfilter alone
    1410           0 :     SbxValue::Clear();
    1411             :     sal_uInt16 nType;
    1412           0 :     r.ReadUInt16( nType );
    1413           0 :     aData.eType = SbxDataType( nType );
    1414           0 :     switch( nType )
    1415             :     {
    1416             :         case SbxBOOL:
    1417             :         case SbxINTEGER:
    1418           0 :             r.ReadInt16( aData.nInteger ); break;
    1419             :         case SbxLONG:
    1420           0 :             r.ReadInt32( aData.nLong ); break;
    1421             :         case SbxSINGLE:
    1422             :         {
    1423             :             // Floats as ASCII
    1424             :             OUString aVal = read_uInt16_lenPrefixed_uInt8s_ToOUString(r,
    1425           0 :                 RTL_TEXTENCODING_ASCII_US);
    1426             :             double d;
    1427             :             SbxDataType t;
    1428           0 :             if( ImpScan( aVal, d, t, NULL ) != SbxERR_OK || t == SbxDOUBLE )
    1429             :             {
    1430           0 :                 aData.nSingle = 0.0F;
    1431           0 :                 return false;
    1432             :             }
    1433           0 :             aData.nSingle = (float) d;
    1434           0 :             break;
    1435             :         }
    1436             :         case SbxDATE:
    1437             :         case SbxDOUBLE:
    1438             :         {
    1439             :             // Floats as ASCII
    1440             :             OUString aVal = read_uInt16_lenPrefixed_uInt8s_ToOUString(r,
    1441           0 :                 RTL_TEXTENCODING_ASCII_US);
    1442             :             SbxDataType t;
    1443           0 :             if( ImpScan( aVal, aData.nDouble, t, NULL ) != SbxERR_OK )
    1444             :             {
    1445           0 :                 aData.nDouble = 0.0;
    1446           0 :                 return false;
    1447             :             }
    1448           0 :             break;
    1449             :         }
    1450             :         case SbxSALINT64:
    1451           0 :             r.ReadInt64(aData.nInt64);
    1452           0 :             break;
    1453             :         case SbxSALUINT64:
    1454           0 :             r.ReadUInt64( aData.uInt64 );
    1455           0 :             break;
    1456             :         case SbxCURRENCY:
    1457             :         {
    1458           0 :             sal_uInt32 tmpHi = 0;
    1459           0 :             sal_uInt32 tmpLo = 0;
    1460           0 :             r.ReadUInt32( tmpHi ).ReadUInt32( tmpLo );
    1461           0 :             aData.nInt64 = ((sal_Int64)tmpHi << 32);
    1462           0 :             aData.nInt64 |= (sal_Int64)tmpLo;
    1463           0 :             break;
    1464             :         }
    1465             :         case SbxSTRING:
    1466             :         {
    1467             :             OUString aVal = read_uInt16_lenPrefixed_uInt8s_ToOUString(r,
    1468           0 :                 RTL_TEXTENCODING_ASCII_US);
    1469           0 :             if( !aVal.isEmpty() )
    1470           0 :                     aData.pOUString = new OUString( aVal );
    1471             :                 else
    1472           0 :                     aData.pOUString = NULL; // JSM 1995-09-22
    1473           0 :                 break;
    1474             :             }
    1475             :             case SbxERROR:
    1476             :             case SbxUSHORT:
    1477           0 :                 r.ReadUInt16( aData.nUShort ); break;
    1478             :             case SbxOBJECT:
    1479             :             {
    1480             :                 sal_uInt8 nMode;
    1481           0 :                 r.ReadUChar( nMode );
    1482           0 :                 switch( nMode )
    1483             :                 {
    1484             :                     case 0:
    1485           0 :                         aData.pObj = NULL;
    1486           0 :                         break;
    1487             :                     case 1:
    1488           0 :                         aData.pObj = SbxBase::Load( r );
    1489           0 :                         return ( aData.pObj != NULL );
    1490             :                     case 2:
    1491           0 :                         aData.pObj = this;
    1492           0 :                         break;
    1493             :                 }
    1494           0 :                 break;
    1495             :             }
    1496             :             case SbxCHAR:
    1497             :             {
    1498             :                 char c;
    1499           0 :                 r.ReadChar( c );
    1500           0 :                 aData.nChar = c;
    1501           0 :                 break;
    1502             :             }
    1503             :             case SbxBYTE:
    1504           0 :                 r.ReadUChar( aData.nByte ); break;
    1505             :             case SbxULONG:
    1506           0 :                 r.ReadUInt32( aData.nULong ); break;
    1507             :             case SbxINT:
    1508             :             {
    1509             :                 sal_uInt8 n;
    1510           0 :                 r.ReadUChar( n );
    1511             :                 // Match the Int on this system?
    1512           0 :                 if( n > SAL_TYPES_SIZEOFINT )
    1513           0 :                     r.ReadInt32( aData.nLong ), aData.eType = SbxLONG;
    1514             :                 else {
    1515             :                     sal_Int32 nInt;
    1516           0 :                     r.ReadInt32( nInt );
    1517           0 :                     aData.nInt = nInt;
    1518             :                 }
    1519           0 :                 break;
    1520             :             }
    1521             :             case SbxUINT:
    1522             :             {
    1523             :                 sal_uInt8 n;
    1524           0 :                 r.ReadUChar( n );
    1525             :                 // Match the UInt on this system?
    1526           0 :                 if( n > SAL_TYPES_SIZEOFINT )
    1527           0 :                     r.ReadUInt32( aData.nULong ), aData.eType = SbxULONG;
    1528             :                 else {
    1529             :                     sal_uInt32 nUInt;
    1530           0 :                     r.ReadUInt32( nUInt );
    1531           0 :                     aData.nUInt = nUInt;
    1532             :                 }
    1533           0 :                 break;
    1534             :             }
    1535             :             case SbxEMPTY:
    1536             :             case SbxNULL:
    1537             :             case SbxVOID:
    1538           0 :                 break;
    1539             :             case SbxDATAOBJECT:
    1540           0 :                 r.ReadInt32( aData.nLong );
    1541           0 :                 break;
    1542             :             // #78919 For backwards compatibility
    1543             :             case SbxWSTRING:
    1544             :             case SbxWCHAR:
    1545           0 :                 break;
    1546             :             default:
    1547           0 :                 memset (&aData,0,sizeof(aData));
    1548           0 :                 ResetFlag(SBX_FIXED);
    1549           0 :                 aData.eType = SbxNULL;
    1550             :                 DBG_ASSERT( false, "Loaded a non-supported data type" );
    1551             : 
    1552           0 :                 return false;
    1553             :         }
    1554           0 :         return true;
    1555             :     }
    1556             : 
    1557           0 :     bool SbxValue::StoreData( SvStream& r ) const
    1558             :     {
    1559           0 :         sal_uInt16 nType = sal::static_int_cast< sal_uInt16 >(aData.eType);
    1560           0 :         r.WriteUInt16( nType );
    1561           0 :         switch( nType & 0x0FFF )
    1562             :         {
    1563             :             case SbxBOOL:
    1564             :             case SbxINTEGER:
    1565           0 :                 r.WriteInt16( aData.nInteger ); break;
    1566             :             case SbxLONG:
    1567           0 :                 r.WriteInt32( aData.nLong ); break;
    1568             :             case SbxDATE:
    1569             :                 // #49935: Save as double, otherwise an error during the read in
    1570           0 :                 const_cast<SbxValue*>(this)->aData.eType = (SbxDataType)( ( nType & 0xF000 ) | SbxDOUBLE );
    1571           0 :                 write_uInt16_lenPrefixed_uInt8s_FromOUString(r, GetCoreString(), RTL_TEXTENCODING_ASCII_US);
    1572           0 :                 const_cast<SbxValue*>(this)->aData.eType = (SbxDataType)nType;
    1573           0 :                 break;
    1574             :             case SbxSINGLE:
    1575             :             case SbxDOUBLE:
    1576           0 :                 write_uInt16_lenPrefixed_uInt8s_FromOUString(r, GetCoreString(), RTL_TEXTENCODING_ASCII_US);
    1577           0 :                 break;
    1578             :             case SbxSALUINT64:
    1579             :             case SbxSALINT64:
    1580             :                 // see comment in SbxValue::StoreData
    1581           0 :                 r.WriteUInt64( aData.uInt64 );
    1582           0 :                 break;
    1583             :             case SbxCURRENCY:
    1584             :             {
    1585           0 :                 sal_Int32 tmpHi = ( (aData.nInt64 >> 32) &  0xFFFFFFFF );
    1586           0 :                 sal_Int32 tmpLo = ( sal_Int32 )aData.nInt64;
    1587           0 :                 r.WriteInt32( tmpHi ).WriteInt32( tmpLo );
    1588           0 :                 break;
    1589             :             }
    1590             :             case SbxSTRING:
    1591           0 :                 if( aData.pOUString )
    1592             :                 {
    1593           0 :                     write_uInt16_lenPrefixed_uInt8s_FromOUString(r, *aData.pOUString, RTL_TEXTENCODING_ASCII_US);
    1594             :                 }
    1595             :                 else
    1596             :                 {
    1597           0 :                     write_uInt16_lenPrefixed_uInt8s_FromOUString(r, OUString(), RTL_TEXTENCODING_ASCII_US);
    1598             :             }
    1599           0 :             break;
    1600             :         case SbxERROR:
    1601             :         case SbxUSHORT:
    1602           0 :             r.WriteUInt16( aData.nUShort ); break;
    1603             :         case SbxOBJECT:
    1604             :             // to save itself as Objectptr does not work!
    1605           0 :             if( aData.pObj )
    1606             :             {
    1607           0 :                 if( PTR_CAST(SbxValue,aData.pObj) != this )
    1608             :                 {
    1609           0 :                     r.WriteUChar( 1 );
    1610           0 :                     return aData.pObj->Store( r );
    1611             :                 }
    1612             :                 else
    1613           0 :                     r.WriteUChar( 2 );
    1614             :             }
    1615             :             else
    1616           0 :                 r.WriteUChar( 0 );
    1617           0 :             break;
    1618             :         case SbxCHAR:
    1619             :         {
    1620           0 :             char c = sal::static_int_cast< char >(aData.nChar);
    1621           0 :             r.WriteChar( c );
    1622           0 :             break;
    1623             :         }
    1624             :         case SbxBYTE:
    1625           0 :             r.WriteUChar( aData.nByte ); break;
    1626             :         case SbxULONG:
    1627           0 :             r.WriteUInt32( aData.nULong ); break;
    1628             :         case SbxINT:
    1629             :         {
    1630           0 :             sal_uInt8 n = SAL_TYPES_SIZEOFINT;
    1631           0 :             r.WriteUChar( n ).WriteInt32( aData.nInt );
    1632           0 :             break;
    1633             :         }
    1634             :         case SbxUINT:
    1635             :         {
    1636           0 :             sal_uInt8 n = SAL_TYPES_SIZEOFINT;
    1637           0 :             r.WriteUChar( n ).WriteUInt32( aData.nUInt );
    1638           0 :             break;
    1639             :         }
    1640             :         case SbxEMPTY:
    1641             :         case SbxNULL:
    1642             :         case SbxVOID:
    1643           0 :             break;
    1644             :         case SbxDATAOBJECT:
    1645           0 :             r.WriteInt32( aData.nLong );
    1646           0 :             break;
    1647             :         // #78919 For backwards compatibility
    1648             :         case SbxWSTRING:
    1649             :         case SbxWCHAR:
    1650           0 :             break;
    1651             :         default:
    1652             :             DBG_ASSERT( false, "Saving a non-supported data type" );
    1653           0 :             return false;
    1654             :     }
    1655           0 :     return true;
    1656             : }
    1657             : 
    1658             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11