basic/source/sbx/sbxvalue.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: sbxvalue.cxx,v $
  10  * $Revision: 1.14 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basic.hxx"
  33
  34 #define _TLBIGINT_INT64
  35 #include <tools/bigint.hxx>
  36 #include <tools/stream.hxx>
  37
  38 #include <basic/sbx.hxx>
  39 #include "sbxconv.hxx"
  40 #include <math.h>
  41 #include "runtime.hxx"
  42 // AB 29.10.99 Unicode
  43 #ifndef _USE_NO_NAMESPACE
  44 using namespace rtl;
  45 #endif
  46
  47
  48 TYPEINIT1(SbxValue,SbxBase)
  49
  50 /////////////////////////// SbxINT64 /////////////////////////////////////
  51 SbxINT64 &SbxINT64::operator -= ( const SbxINT64 &r )
  52 {
  53     BigInt b( *this );
  54     b -= BigInt( r );
  55     b.INT64( this );
  56     return *this;
  57 }
  58 SbxINT64 &SbxINT64::operator += ( const SbxINT64 &r )
  59 {
  60     BigInt b( *this );
  61     b += BigInt( r );
  62     b.INT64( this );
  63     return *this;
  64 }
  65 SbxINT64 &SbxINT64::operator *= ( const SbxINT64 &r )
  66 {
  67     BigInt b( *this );
  68     b *= BigInt( r );
  69     b.INT64( this );
  70     return *this;
  71 }
  72 SbxINT64 &SbxINT64::operator %= ( const SbxINT64 &r )
  73 {
  74     BigInt b( *this );
  75     b %= BigInt( r );
  76     b.INT64( this );
  77     return *this;
  78 }
  79 SbxINT64 &SbxINT64::operator /= ( const SbxINT64 &r )
  80 {
  81     BigInt b( *this );
  82     b /= BigInt( r );
  83     b.INT64( this );
  84     return *this;
  85 }
  86 SbxINT64 &SbxINT64::operator &= ( const SbxINT64 &r )
  87 {
  88     nHigh &= r.nHigh;
  89     nLow  &= r.nLow;
  90     return *this;
  91 }
  92 SbxINT64 &SbxINT64::operator |= ( const SbxINT64 &r )
  93 {
  94     nHigh |= r.nHigh;
  95     nLow  |= r.nLow;
  96     return *this;
  97 }
  98 SbxINT64 &SbxINT64::operator ^= ( const SbxINT64 &r )
  99 {
 100     nHigh ^= r.nHigh;
 101     nLow  ^= r.nLow;
 102     return *this;
 103 }
 104
 105 SbxINT64 operator - ( const SbxINT64 &l, const SbxINT64 &r )
 106 {
 107     SbxINT64 a(l);
 108     a -= r;
 109     return a;
 110 }
 111 SbxINT64 operator + ( const SbxINT64 &l, const SbxINT64 &r )
 112 {
 113     SbxINT64 a(l);
 114     a += r;
 115     return a;
 116 }
 117 SbxINT64 operator / ( const SbxINT64 &l, const SbxINT64 &r )
 118 {
 119     SbxINT64 a(l);
 120     a /= r;
 121     return a;
 122 }
 123 SbxINT64 operator % ( const SbxINT64 &l, const SbxINT64 &r )
 124 {
 125     SbxINT64 a(l);
 126     a %= r;
 127     return a;
 128 }
 129 SbxINT64 operator * ( const SbxINT64 &l, const SbxINT64 &r )
 130 {
 131     SbxINT64 a(l);
 132     a *= r;
 133     return a;
 134 }
 135 SbxINT64 operator & ( const SbxINT64 &l, const SbxINT64 &r )
 136 {
 137     SbxINT64 a;
 138     a.nHigh = r.nHigh & l.nHigh;
 139     a.nLow  = r.nLow  & l.nLow;
 140     return a;
 141 }
 142 SbxINT64 operator | ( const SbxINT64 &l, const SbxINT64 &r )
 143 {
 144     SbxINT64 a;
 145     a.nHigh = r.nHigh | l.nHigh;
 146     a.nLow  = r.nLow  | l.nLow;
 147     return a;
 148 }
 149 SbxINT64 operator ^ ( const SbxINT64 &r, const SbxINT64 &l )
 150 {
 151     SbxINT64 a;
 152     a.nHigh = r.nHigh ^ l.nHigh;
 153     a.nLow  = r.nLow  ^ l.nLow;
 154     return a;
 155 }
 156
 157 SbxINT64 operator - ( const SbxINT64 &r )
 158 {
 159     SbxINT64 a( r );
 160     a.CHS();
 161     return a;
 162 }
 163 SbxINT64 operator ~ ( const SbxINT64 &r )
 164 {
 165     SbxINT64 a;
 166     a.nHigh = ~r.nHigh;
 167     a.nLow  = ~r.nLow;
 168     return a;
 169 }
 170
 171 SbxUINT64 &SbxUINT64::operator %= ( const SbxUINT64 &r )
 172 {
 173     BigInt b( *this );
 174     b %= BigInt( r );
 175     b.UINT64( this );
 176     return *this;
 177 }
 178 SbxUINT64 &SbxUINT64::operator /= ( const SbxUINT64 &r )
 179 {
 180     BigInt b( *this );
 181     b /= BigInt( r );
 182     b.UINT64( this );
 183     return *this;
 184 }
 185 /////////////////////////// Fehlerbehandlung /////////////////////////////
 186
 187 #ifdef _USED
 188 // NOCH NACHZUBAUEN!
 189
 190 // Das Default-Handling setzt nur den Fehlercode.
 191
 192 #ifndef WNT
 193 #if defined ( UNX )
 194 int matherr( struct exception* p )
 195 #else
 196 int matherr( struct _exception* p )
 197 #endif
 198 {
 199     switch( p->type )
 200     {
 201 #if defined ( UNX )
 202         case OVERFLOW: SbxBase::SetError( SbxERR_OVERFLOW ); break;
 203 #else
 204         case _OVERFLOW: SbxBase::SetError( SbxERR_OVERFLOW ); break;
 205 #endif
 206         default:                SbxBase::SetError( SbxERR_NOTIMP ); break;
 207     }
 208     return TRUE;
 209 }
 210 #endif
 211
 212 #endif // _USED
 213
 214
 215 ///////////////////////////// Konstruktoren //////////////////////////////
 216
 217 SbxValue::SbxValue() : SbxBase()
 218 {
 219     aData.eType = SbxEMPTY;
 220 }
 221
 222 SbxValue::SbxValue( SbxDataType t, void* p ) : SbxBase()
 223 {
 224     int n = t & 0x0FFF;
 225     if( p )
 226         n |= SbxBYREF;
 227     if( n == SbxVARIANT )
 228         n = SbxEMPTY;
 229     else
 230         SetFlag( SBX_FIXED );
 231     if( p )
 232     switch( t & 0x0FFF )
 233     {
 234         case SbxINTEGER:        n |= SbxBYREF; aData.pInteger = (INT16*) p; break;
 235         case SbxULONG64:        n |= SbxBYREF; aData.pULong64 = (SbxUINT64*) p; break;
 236         case SbxLONG64:
 237         case SbxCURRENCY:       n |= SbxBYREF; aData.pLong64 = (SbxINT64*) p; break;
 238         case SbxLONG:           n |= SbxBYREF; aData.pLong = (INT32*) p; break;
 239         case SbxSINGLE:         n |= SbxBYREF; aData.pSingle = (float*) p; break;
 240         case SbxDATE:
 241         case SbxDOUBLE:         n |= SbxBYREF; aData.pDouble = (double*) p; break;
 242         case SbxSTRING:         n |= SbxBYREF; aData.pString = (XubString*) p; break;
 243         case SbxERROR:
 244         case SbxUSHORT:
 245         case SbxBOOL:           n |= SbxBYREF; aData.pUShort = (UINT16*) p; break;
 246         case SbxULONG:          n |= SbxBYREF; aData.pULong = (UINT32*) p; break;
 247         case SbxCHAR:           n |= SbxBYREF; aData.pChar = (xub_Unicode*) p; break;
 248         case SbxBYTE:           n |= SbxBYREF; aData.pByte = (BYTE*) p; break;
 249         case SbxINT:            n |= SbxBYREF; aData.pInt = (int*) p; break;
 250         case SbxOBJECT:
 251             aData.pObj = (SbxBase*) p;
 252             if( p )
 253                 aData.pObj->AddRef();
 254             break;
 255         case SbxDECIMAL:
 256             aData.pDecimal = (SbxDecimal*) p;
 257             if( p )
 258                 aData.pDecimal->addRef();
 259             break;
 260         default:
 261             DBG_ASSERT( !this, "Angabe eines Pointers unzulaessig" );
 262             n = SbxNULL;
 263     }
 264     else
 265         memset( &aData, 0, sizeof( SbxValues ) );
 266     aData.eType = SbxDataType( n );
 267 }
 268
 269 SbxValue::SbxValue( const SbxValue& r )
 270     : SvRefBase( r ), SbxBase( r )
 271 {
 272     if( !r.CanRead() )
 273     {
 274         SetError( SbxERR_PROP_WRITEONLY );
 275         if( !IsFixed() )
 276             aData.eType = SbxNULL;
 277     }
 278     else
 279     {
 280         ((SbxValue*) &r)->Broadcast( SBX_HINT_DATAWANTED );
 281         aData = r.aData;
 282         // Pointer kopieren, Referenzen inkrementieren
 283         switch( aData.eType )
 284         {
 285             case SbxSTRING:
 286                 if( aData.pString )
 287                     aData.pString = new XubString( *aData.pString );
 288                 break;
 289             case SbxOBJECT:
 290                 if( aData.pObj )
 291                     aData.pObj->AddRef();
 292                 break;
 293             case SbxDECIMAL:
 294                 if( aData.pDecimal )
 295                     aData.pDecimal->addRef();
 296                 break;
 297             default: break;
 298         }
 299     }
 300 }
 301
 302 SbxValue& SbxValue::operator=( const SbxValue& r )
 303 {
 304     if( &r != this )
 305     {
 306         if( !CanWrite() )
 307             SetError( SbxERR_PROP_READONLY );
 308         else
 309         {
 310             // string -> byte array
 311             if( IsFixed() && (aData.eType == SbxOBJECT)
 312                 && aData.pObj && ( aData.pObj->GetType() == (SbxARRAY | SbxBYTE) )
 313                 && (r.aData.eType == SbxSTRING) )
 314             {
 315                 String aStr = r.GetString();
 316                 SbxArray* pArr = StringToByteArray(aStr);
 317                 PutObject(pArr);
 318                 return *this;
 319             }
 320             // byte array -> string
 321             if( r.IsFixed() && (r.aData.eType == SbxOBJECT)
 322                 && r.aData.pObj && ( r.aData.pObj->GetType() == (SbxARRAY | SbxBYTE) )
 323                 && (aData.eType == SbxSTRING) )
 324             {
 325                 SbxBase* pObj = r.GetObject();
 326                 SbxArray* pArr = PTR_CAST(SbxArray, pObj);
 327                 if( pArr )
 328                 {
 329                     String aStr = ByteArrayToString( pArr );
 330                     PutString(aStr);
 331                     return *this;
 332                 }
 333             }
 334             // Den Inhalt der Variablen auslesen
 335             SbxValues aNew;
 336             if( IsFixed() )
 337                 // fest: dann muss der Typ stimmen
 338                 aNew.eType = aData.eType;
 339             else if( r.IsFixed() )
 340                 // Quelle fest: Typ uebernehmen
 341                 aNew.eType = SbxDataType( r.aData.eType & 0x0FFF );
 342             else
 343                 // beides Variant: dann isses egal
 344                 aNew.eType = SbxVARIANT;
 345             if( r.Get( aNew ) )
 346                 Put( aNew );
 347         }
 348     }
 349     return *this;
 350 }
 351
 352 SbxValue::~SbxValue()
 353 {
 354 #ifndef C50
 355     Broadcast( SBX_HINT_DYING );
 356     SetFlag( SBX_WRITE );
 357     SbxValue::Clear();
 358 #else
 359     // Provisorischer Fix fuer Solaris 5.0 Compiler Bug
 360     // bei Nutzung virtueller Vererbung. Virtuelle Calls
 361     // im Destruktor vermeiden. Statt Clear() zu rufen
 362     // moegliche Objekt-Referenzen direkt freigeben.
 363     if( aData.eType == SbxOBJECT )
 364     {
 365         if( aData.pObj && aData.pObj != this )
 366         {
 367             HACK(nicht bei Parent-Prop - sonst CyclicRef)
 368             SbxVariable *pThisVar = PTR_CAST(SbxVariable, this);
 369             BOOL bParentProp = pThisVar && 5345 ==
 370             ( (INT16) ( pThisVar->GetUserData() & 0xFFFF ) );
 371             if ( !bParentProp )
 372                 aData.pObj->ReleaseRef();
 373         }
 374     }
 375     else if( aData.eType == SbxDECIMAL )
 376     {
 377         releaseDecimalPtr( aData.pDecimal );
 378     }
 379 #endif
 380 }
 381
 382 void SbxValue::Clear()
 383 {
 384     switch( aData.eType )
 385     {
 386         case SbxNULL:
 387         case SbxEMPTY:
 388         case SbxVOID:
 389             break;
 390         case SbxSTRING:
 391             delete aData.pString; aData.pString = NULL;
 392             break;
 393         case SbxOBJECT:
 394             if( aData.pObj )
 395             {
 396                 if( aData.pObj != this )
 397                 {
 398                     HACK(nicht bei Parent-Prop - sonst CyclicRef)
 399                     SbxVariable *pThisVar = PTR_CAST(SbxVariable, this);
 400                     BOOL bParentProp = pThisVar && 5345 ==
 401                     ( (INT16) ( pThisVar->GetUserData() & 0xFFFF ) );
 402                     if ( !bParentProp )
 403                         aData.pObj->ReleaseRef();
 404                 }
 405                 aData.pObj = NULL;
 406             }
 407             break;
 408         case SbxDECIMAL:
 409             if( aData.eType == SbxDECIMAL )
 410                 releaseDecimalPtr( aData.pDecimal );
 411             break;
 412         case SbxDATAOBJECT:
 413             aData.pData = NULL; break;
 414         default:
 415         {
 416             SbxValues aEmpty;
 417             memset( &aEmpty, 0, sizeof( SbxValues ) );
 418             aEmpty.eType = GetType();
 419             Put( aEmpty );
 420         }
 421     }
 422 }
 423
 424 // Dummy
 425
 426 void SbxValue::Broadcast( ULONG )
 427 {}
 428
 429 //////////////////////////// Daten auslesen //////////////////////////////
 430
 431 // Ermitteln der "richtigen" Variablen. Falls es ein Objekt ist, wird
 432 // entweder das Objekt selbst oder dessen Default-Property angesprochen.
 433 // Falls die Variable eine Variable oder ein Objekt enthaelt, wird
 434 // dieses angesprochen.
 435
 436 SbxValue* SbxValue::TheRealValue() const
 437 {
 438     return TheRealValue( TRUE );
 439 }
 440
 441 // #55226 Zusaetzliche Info transportieren
 442 SbxValue* SbxValue::TheRealValue( BOOL bObjInObjError ) const
 443 {
 444     SbxValue* p = (SbxValue*) this;
 445     for( ;; )
 446     {
 447         SbxDataType t = SbxDataType( p->aData.eType & 0x0FFF );
 448         if( t == SbxOBJECT )
 449         {
 450             // Der Block enthaelt ein Objekt oder eine Variable
 451             SbxObject* pObj = PTR_CAST(SbxObject,p->aData.pObj);
 452             if( pObj )
 453             {
 454                 // Hat das Objekt eine Default-Property?
 455                 SbxVariable* pDflt = pObj->GetDfltProperty();
 456
 457                 // Falls dies ein Objekt ist und sich selbst enthaelt,
 458                 // koennen wir nicht darauf zugreifen
 459                 // #55226# Die alte Bedingung, um einen Fehler zu setzen,
 460                 // ist nicht richtig, da z.B. eine ganz normale Variant-
 461                 // Variable mit Objekt davon betroffen sein kann, wenn ein
 462                 // anderer Wert zugewiesen werden soll. Daher mit Flag.
 463                 if( bObjInObjError && !pDflt &&
 464                     ((SbxValue*) pObj)->aData.eType == SbxOBJECT &&
 465                     ((SbxValue*) pObj)->aData.pObj == pObj )
 466                 {
 467                     SetError( SbxERR_BAD_PROP_VALUE );
 468                     p = NULL;
 469                 }
 470                 else if( pDflt )
 471                     p = pDflt;
 472                 /* ALT:
 473                 else
 474                     p = pDflt ? pDflt : (SbxVariable*) pObj;
 475                 */
 476                 break;
 477             }
 478             // Haben wir ein Array?
 479             SbxArray* pArray = PTR_CAST(SbxArray,p->aData.pObj);
 480             if( pArray )
 481             {
 482                 // Ggf. Parameter holen
 483                 SbxArray* pPar = NULL;
 484                 SbxVariable* pVar = PTR_CAST(SbxVariable,p);
 485                 if( pVar )
 486                     pPar = pVar->GetParameters();
 487                 if( pPar )
 488                 {
 489                     // Haben wir ein dimensioniertes Array?
 490                     SbxDimArray* pDimArray = PTR_CAST(SbxDimArray,p->aData.pObj);
 491                     if( pDimArray )
 492                         p = pDimArray->Get( pPar );
 493                     else
 494                         p = pArray->Get( pPar->Get( 1 )->GetInteger() );
 495                     break;
 496                 }
 497             }
 498             // Sonst einen SbxValue annehmen
 499             SbxValue* pVal = PTR_CAST(SbxValue,p->aData.pObj);
 500             if( pVal )
 501                 p = pVal;
 502             else
 503                 break;
 504         }
 505         else
 506             break;
 507     }
 508     return p;
 509 }
 510
 511 BOOL SbxValue::Get( SbxValues& rRes ) const
 512 {
 513     BOOL bRes = FALSE;
 514     SbxError eOld = GetError();
 515     if( eOld != SbxERR_OK )
 516         ResetError();
 517     if( !CanRead() )
 518     {
 519         SetError( SbxERR_PROP_WRITEONLY );
 520         rRes.pObj = NULL;
 521     }
 522     else
 523     {
 524         // Falls nach einem Objekt oder einem VARIANT gefragt wird, nicht
 525         // die wahren Werte suchen
 526         SbxValue* p = (SbxValue*) this;
 527         if( rRes.eType != SbxOBJECT && rRes.eType != SbxVARIANT )
 528             p = TheRealValue();
 529         if( p )
 530         {
 531             p->Broadcast( SBX_HINT_DATAWANTED );
 532             switch( rRes.eType )
 533             {
 534                 case SbxEMPTY:
 535                 case SbxVOID:
 536                 case SbxNULL:    break;
 537                 case SbxVARIANT: rRes = p->aData; break;
 538                 case SbxINTEGER: rRes.nInteger = ImpGetInteger( &p->aData ); break;
 539                 case SbxLONG:    rRes.nLong = ImpGetLong( &p->aData ); break;
 540                 case SbxSALINT64:       rRes.nInt64 = ImpGetInt64( &p->aData ); break;
 541                 case SbxSALUINT64:      rRes.uInt64 = ImpGetUInt64( &p->aData ); break;
 542                 case SbxSINGLE:  rRes.nSingle = ImpGetSingle( &p->aData ); break;
 543                 case SbxDOUBLE:  rRes.nDouble = ImpGetDouble( &p->aData ); break;
 544                 case SbxCURRENCY:rRes.nLong64 = ImpGetCurrency( &p->aData ); break;
 545                 case SbxDECIMAL: rRes.pDecimal = ImpGetDecimal( &p->aData ); break;
 546                 case SbxDATE:    rRes.nDouble = ImpGetDate( &p->aData ); break;
 547                 case SbxBOOL:
 548                     rRes.nUShort = sal::static_int_cast< UINT16 >(
 549                         ImpGetBool( &p->aData ) );
 550                     break;
 551                 case SbxCHAR:    rRes.nChar = ImpGetChar( &p->aData ); break;
 552                 case SbxBYTE:    rRes.nByte = ImpGetByte( &p->aData ); break;
 553                 case SbxUSHORT:  rRes.nUShort = ImpGetUShort( &p->aData ); break;
 554                 case SbxULONG:   rRes.nULong = ImpGetULong( &p->aData ); break;
 555                 case SbxLPSTR:
 556                 case SbxSTRING:  p->aPic = ImpGetString( &p->aData );
 557                                  rRes.pString = &p->aPic; break;
 558                 case SbxCoreSTRING:     p->aPic = ImpGetCoreString( &p->aData );
 559                                     rRes.pString = &p->aPic; break;
 560                 case SbxINT:
 561 #if SAL_TYPES_SIZEOFINT == 2
 562                     rRes.nInt = (int) ImpGetInteger( &p->aData );
 563 #else
 564                     rRes.nInt = (int) ImpGetLong( &p->aData );
 565 #endif
 566                     break;
 567                 case SbxUINT:
 568 #if SAL_TYPES_SIZEOFINT == 2
 569                     rRes.nUInt = (int) ImpGetUShort( &p->aData );
 570 #else
 571                     rRes.nUInt = (int) ImpGetULong( &p->aData );
 572 #endif
 573                     break;
 574                 case SbxOBJECT:
 575                     if( p->aData.eType == SbxOBJECT )
 576                         rRes.pObj = p->aData.pObj;
 577                     else
 578                     {
 579                         SetError( SbxERR_NO_OBJECT );
 580                         rRes.pObj = NULL;
 581                     }
 582                     break;
 583                 default:
 584                     if( p->aData.eType == rRes.eType )
 585                         rRes = p->aData;
 586                     else
 587                     {
 588                         SetError( SbxERR_CONVERSION );
 589                         rRes.pObj = NULL;
 590                     }
 591             }
 592         }
 593         else
 594         {
 595             // Objekt enthielt sich selbst
 596             SbxDataType eTemp = rRes.eType;
 597             memset( &rRes, 0, sizeof( SbxValues ) );
 598             rRes.eType = eTemp;
 599         }
 600     }
 601     if( !IsError() )
 602     {
 603         bRes = TRUE;
 604         if( eOld != SbxERR_OK )
 605             SetError( eOld );
 606     }
 607     return bRes;
 608 }
 609
 610 BOOL SbxValue::GetNoBroadcast( SbxValues& rRes )
 611 {
 612     USHORT nFlags_ = GetFlags();
 613     SetFlag( SBX_NO_BROADCAST );
 614     BOOL bRes = Get( rRes );
 615     SetFlags( nFlags_ );
 616     return bRes;
 617 }
 618
 619 const XubString& SbxValue::GetString() const
 620 {
 621     SbxValues aRes;
 622     aRes.eType = SbxSTRING;
 623     if( Get( aRes ) )
 624         // Geht in Ordnung, da Ptr eine Kopie ist
 625         return *aRes.pString;
 626     else
 627     {
 628         ((SbxValue*) this)->aPic.Erase();
 629         return aPic;
 630     }
 631 }
 632
 633 const XubString& SbxValue::GetCoreString() const
 634 {
 635     SbxValues aRes;
 636     aRes.eType = SbxCoreSTRING;
 637     if( Get( aRes ) )
 638         // Geht in Ordnung, da Ptr eine Kopie ist
 639         return *aRes.pString;
 640     else
 641     {
 642         ((SbxValue*) this)->aPic.Erase();
 643         return aPic;
 644     }
 645 }
 646
 647 BOOL SbxValue::HasObject() const
 648 {
 649     ErrCode eErr = GetError();
 650     SbxValues aRes;
 651     aRes.eType = SbxOBJECT;
 652     Get( aRes );
 653     SetError( eErr );
 654     return 0 != aRes.pObj;
 655 }
 656
 657 BOOL SbxValue::GetBool() const
 658 {
 659     SbxValues aRes;
 660     aRes.eType = SbxBOOL;
 661     Get( aRes );
 662     return BOOL( aRes.nUShort != 0 );
 663 }
 664
 665 #define GET( g, e, t, m ) \
 666 t SbxValue::g() const { SbxValues aRes(e); Get( aRes ); return aRes.m; }
 667
 668 GET( GetByte,     SbxBYTE,       BYTE,             nByte )
 669 GET( GetChar,     SbxCHAR,       xub_Unicode,           nChar )
 670 GET( GetCurrency, SbxCURRENCY,   SbxINT64,         nLong64 )
 671 GET( GetDate,     SbxDATE,       double,           nDouble )
 672 GET( GetData,     SbxDATAOBJECT, void*,            pData )
 673 GET( GetDouble,   SbxDOUBLE,     double,           nDouble )
 674 GET( GetErr,      SbxERROR,      UINT16,           nUShort )
 675 GET( GetInt,      SbxINT,        int,              nInt )
 676 GET( GetInteger,  SbxINTEGER,    INT16,            nInteger )
 677 GET( GetLong,     SbxLONG,       INT32,            nLong )
 678 GET( GetLong64,   SbxLONG64,     SbxINT64,         nLong64 )
 679 GET( GetObject,   SbxOBJECT,     SbxBase*,         pObj )
 680 GET( GetSingle,   SbxSINGLE,     float,            nSingle )
 681 GET( GetULong,    SbxULONG,      UINT32,           nULong )
 682 GET( GetULong64,  SbxULONG64,    SbxUINT64,        nULong64 )
 683 GET( GetUShort,   SbxUSHORT,     UINT16,           nUShort )
 684 GET( GetInt64,    SbxSALINT64,   sal_Int64,        nInt64 )
 685 GET( GetUInt64,   SbxSALUINT64,  sal_uInt64,       uInt64 )
 686 GET( GetDecimal,  SbxDECIMAL,    SbxDecimal*,      pDecimal )
 687
 688
 689 //////////////////////////// Daten schreiben /////////////////////////////
 690
 691 BOOL SbxValue::Put( const SbxValues& rVal )
 692 {
 693     BOOL bRes = FALSE;
 694     SbxError eOld = GetError();
 695     if( eOld != SbxERR_OK )
 696         ResetError();
 697     if( !CanWrite() )
 698         SetError( SbxERR_PROP_READONLY );
 699     else if( rVal.eType & 0xF000 )
 700         SetError( SbxERR_NOTIMP );
 701     else
 702     {
 703         // Falls nach einem Objekt gefragt wird, nicht
 704         // die wahren Werte suchen
 705         SbxValue* p = this;
 706         if( rVal.eType != SbxOBJECT )
 707             p = TheRealValue( FALSE );  // #55226 Hier keinen Fehler erlauben
 708         if( p )
 709         {
 710             if( !p->CanWrite() )
 711                 SetError( SbxERR_PROP_READONLY );
 712             else if( p->IsFixed() || p->SetType( (SbxDataType) ( rVal.eType & 0x0FFF ) ) )
 713               switch( rVal.eType & 0x0FFF )
 714             {
 715                 case SbxEMPTY:
 716                 case SbxVOID:
 717                 case SbxNULL:           break;
 718                 case SbxINTEGER:        ImpPutInteger( &p->aData, rVal.nInteger ); break;
 719                 case SbxLONG:           ImpPutLong( &p->aData, rVal.nLong ); break;
 720                 case SbxSALINT64:       ImpPutInt64( &p->aData, rVal.nInt64 ); break;
 721                 case SbxSALUINT64:      ImpPutUInt64( &p->aData, rVal.uInt64 ); break;
 722                 case SbxSINGLE:         ImpPutSingle( &p->aData, rVal.nSingle ); break;
 723                 case SbxDOUBLE:         ImpPutDouble( &p->aData, rVal.nDouble ); break;
 724                 case SbxCURRENCY:       ImpPutCurrency( &p->aData, rVal.nLong64 ); break;
 725                 case SbxDECIMAL:        ImpPutDecimal( &p->aData, rVal.pDecimal ); break;
 726                 case SbxDATE:           ImpPutDate( &p->aData, rVal.nDouble ); break;
 727                 case SbxBOOL:           ImpPutBool( &p->aData, rVal.nInteger ); break;
 728                 case SbxCHAR:           ImpPutChar( &p->aData, rVal.nChar ); break;
 729                 case SbxBYTE:           ImpPutByte( &p->aData, rVal.nByte ); break;
 730                 case SbxUSHORT:         ImpPutUShort( &p->aData, rVal.nUShort ); break;
 731                 case SbxULONG:          ImpPutULong( &p->aData, rVal.nULong ); break;
 732                 case SbxLPSTR:
 733                 case SbxSTRING:         ImpPutString( &p->aData, rVal.pString ); break;
 734                 case SbxINT:
 735 #if SAL_TYPES_SIZEOFINT == 2
 736                     ImpPutInteger( &p->aData, (INT16) rVal.nInt );
 737 #else
 738                     ImpPutLong( &p->aData, (INT32) rVal.nInt );
 739 #endif
 740                     break;
 741                 case SbxUINT:
 742 #if SAL_TYPES_SIZEOFINT == 2
 743                     ImpPutUShort( &p->aData, (UINT16) rVal.nUInt );
 744 #else
 745                     ImpPutULong( &p->aData, (UINT32) rVal.nUInt );
 746 #endif
 747                     break;
 748                 case SbxOBJECT:
 749                     if( !p->IsFixed() || p->aData.eType == SbxOBJECT )
 750                     {
 751                         // ist schon drin
 752                         if( p->aData.eType == SbxOBJECT && p->aData.pObj == rVal.pObj )
 753                             break;
 754
 755                         // Nur den Werteteil loeschen!
 756                         p->SbxValue::Clear();
 757
 758                         // eingentliche Zuweisung
 759                         p->aData.pObj = rVal.pObj;
 760
 761                         // ggf. Ref-Count mitzaehlen
 762                         if( p->aData.pObj && p->aData.pObj != p )
 763                         {
 764                             if ( p != this )
 765                             {
 766                                 DBG_ERROR( "TheRealValue" );
 767                             }
 768                             HACK(nicht bei Parent-Prop - sonst CyclicRef)
 769                             SbxVariable *pThisVar = PTR_CAST(SbxVariable, this);
 770                             BOOL bParentProp = pThisVar && 5345 ==
 771                                     ( (INT16) ( pThisVar->GetUserData() & 0xFFFF ) );
 772                             if ( !bParentProp )
 773                                 p->aData.pObj->AddRef();
 774                         }
 775                     }
 776                     else
 777                         SetError( SbxERR_CONVERSION );
 778                     break;
 779                 default:
 780                     if( p->aData.eType == rVal.eType )
 781                         p->aData = rVal;
 782                     else
 783                     {
 784                         SetError( SbxERR_CONVERSION );
 785                         if( !p->IsFixed() )
 786                             p->aData.eType = SbxNULL;
 787                     }
 788             }
 789             if( !IsError() )
 790             {
 791                 p->SetModified( TRUE );
 792                 p->Broadcast( SBX_HINT_DATACHANGED );
 793                 if( eOld != SbxERR_OK )
 794                     SetError( eOld );
 795                 bRes = TRUE;
 796             }
 797         }
 798     }
 799     return bRes;
 800 }
 801
 802 // AB, 28.3.96:
 803 // Methode, um bei speziellen Typen eine Vorbehandlung des Strings
 804 // durchzufuehren. Insbesondere erforderlich fuer BASIC-IDE, damit
 805 // die Ausgaben im Watch-Fenster mit PutStringExt zurueckgeschrieben
 806 // werden koennen, wenn Floats mit ',' als Dezimaltrenner oder BOOLs
 807 // explizit mit "TRUE" oder "FALSE" angegeben werden.
 808 // Implementierung in ImpConvStringExt (SBXSCAN.CXX)
 809 BOOL SbxValue::PutStringExt( const XubString& r )
 810 {
 811     // Kopieren, bei Unicode gleich konvertieren
 812     String aStr( r );
 813
 814     // Eigenen Typ bestimmen (nicht wie in Put() mit TheRealValue(),
 815     // Objekte werden sowieso nicht behandelt)
 816     SbxDataType eTargetType = SbxDataType( aData.eType & 0x0FFF );
 817
 818     // Source-Value basteln
 819     SbxValues aRes;
 820     aRes.eType = SbxSTRING;
 821
 822     // Nur, wenn wirklich was konvertiert wurde, Kopie nehmen,
 823     // sonst Original (Unicode bleibt erhalten)
 824     BOOL bRet;
 825     if( ImpConvStringExt( aStr, eTargetType ) )
 826         aRes.pString = (XubString*)&aStr;
 827     else
 828         aRes.pString = (XubString*)&r;
 829
 830     // #34939: Bei Strings. die eine Zahl enthalten und wenn this einen
 831     // Num-Typ hat, Fixed-Flag setzen, damit der Typ nicht veraendert wird
 832     USHORT nFlags_ = GetFlags();
 833     if( ( eTargetType >= SbxINTEGER && eTargetType <= SbxCURRENCY ) ||
 834         ( eTargetType >= SbxCHAR && eTargetType <= SbxUINT ) ||
 835         eTargetType == SbxBOOL )
 836     {
 837         SbxValue aVal;
 838         aVal.Put( aRes );
 839         if( aVal.IsNumeric() )
 840             SetFlag( SBX_FIXED );
 841     }
 842
 843     Put( aRes );
 844     bRet = BOOL( !IsError() );
 845
 846     // Falls das mit dem FIXED einen Error gegeben hat, zuruecksetzen
 847     // (UI-Aktion sollte keinen Error ergeben, sondern nur scheitern)
 848     if( !bRet )
 849         ResetError();
 850
 851     SetFlags( nFlags_ );
 852     return bRet;
 853 }
 854
 855 BOOL SbxValue::PutString( const xub_Unicode* p )
 856 {
 857     XubString aVal( p );
 858     SbxValues aRes;
 859     aRes.eType = SbxSTRING;
 860     aRes.pString = &aVal;
 861     Put( aRes );
 862     return BOOL( !IsError() );
 863 }
 864
 865 BOOL SbxValue::PutBool( BOOL b )
 866 {
 867     SbxValues aRes;
 868     aRes.eType = SbxBOOL;
 869     aRes.nUShort = sal::static_int_cast< UINT16 >(b ? SbxTRUE : SbxFALSE);
 870     Put( aRes );
 871     return BOOL( !IsError() );
 872 }
 873
 874 BOOL SbxValue::PutEmpty()
 875 {
 876     BOOL bRet = SetType( SbxEMPTY );
 877         SetModified( TRUE );
 878     return bRet;
 879 }
 880
 881 BOOL SbxValue::PutNull()
 882 {
 883     BOOL bRet = SetType( SbxNULL );
 884     if( bRet )
 885         SetModified( TRUE );
 886     return bRet;
 887 }
 888
 889
 890 // Special decimal methods
 891 BOOL SbxValue::PutDecimal( com::sun::star::bridge::oleautomation::Decimal& rAutomationDec )
 892 {
 893     SbxValue::Clear();
 894     aData.pDecimal = new SbxDecimal( rAutomationDec );
 895     aData.pDecimal->addRef();
 896     aData.eType = SbxDECIMAL;
 897     return TRUE;
 898 }
 899
 900 BOOL SbxValue::fillAutomationDecimal
 901     ( com::sun::star::bridge::oleautomation::Decimal& rAutomationDec )
 902 {
 903     SbxDecimal* pDecimal = GetDecimal();
 904     if( pDecimal != NULL )
 905     {
 906         pDecimal->fillAutomationDecimal( rAutomationDec );
 907         return TRUE;
 908     }
 909     return FALSE;
 910 }
 911
 912
 913 BOOL SbxValue::PutpChar( const xub_Unicode* p )
 914 {
 915     XubString aVal( p );
 916     SbxValues aRes;
 917     aRes.eType = SbxLPSTR;
 918     aRes.pString = &aVal;
 919     Put( aRes );
 920     return BOOL( !IsError() );
 921 }
 922
 923 BOOL SbxValue::PutString( const XubString& r )
 924 {
 925     SbxValues aRes;
 926     aRes.eType = SbxSTRING;
 927     aRes.pString = (XubString*) &r;
 928     Put( aRes );
 929     return BOOL( !IsError() );
 930 }
 931
 932
 933 #define PUT( p, e, t, m ) \
 934 BOOL SbxValue::p( t n ) \
 935 { SbxValues aRes(e); aRes.m = n; Put( aRes ); return BOOL( !IsError() ); }
 936
 937 PUT( PutByte,     SbxBYTE,       BYTE,             nByte )
 938 PUT( PutChar,     SbxCHAR,       xub_Unicode,      nChar )
 939 PUT( PutCurrency, SbxCURRENCY,   const SbxINT64&,  nLong64 )
 940 PUT( PutDate,     SbxDATE,       double,           nDouble )
 941 PUT( PutData,     SbxDATAOBJECT, void*,            pData )
 942 PUT( PutDouble,   SbxDOUBLE,     double,           nDouble )
 943 PUT( PutErr,      SbxERROR,      UINT16,           nUShort )
 944 PUT( PutInt,      SbxINT,        int,              nInt )
 945 PUT( PutInteger,  SbxINTEGER,    INT16,            nInteger )
 946 PUT( PutLong,     SbxLONG,       INT32,            nLong )
 947 PUT( PutLong64,   SbxLONG64,     const SbxINT64&,  nLong64 )
 948 PUT( PutObject,   SbxOBJECT,     SbxBase*,         pObj )
 949 PUT( PutSingle,   SbxSINGLE,     float,            nSingle )
 950 PUT( PutULong,    SbxULONG,      UINT32,           nULong )
 951 PUT( PutULong64,  SbxULONG64,    const SbxUINT64&, nULong64 )
 952 PUT( PutUShort,   SbxUSHORT,     UINT16,           nUShort )
 953 PUT( PutInt64,    SbxSALINT64,   sal_Int64,        nInt64 )
 954 PUT( PutUInt64,   SbxSALUINT64,  sal_uInt64,       uInt64 )
 955 PUT( PutDecimal,  SbxDECIMAL,    SbxDecimal*,      pDecimal )
 956
 957
 958 ////////////////////////// Setzen des Datentyps ///////////////////////////
 959
 960 BOOL SbxValue::IsFixed() const
 961 {
 962     return ( (GetFlags() & SBX_FIXED) | (aData.eType & SbxBYREF) ) != 0;
 963 }
 964
 965 // Eine Variable ist numerisch, wenn sie EMPTY oder wirklich numerisch ist
 966 // oder einen vollstaendig konvertierbaren String enthaelt
 967
 968 // #41692, fuer RTL und Basic-Core getrennt implementieren
 969 BOOL SbxValue::IsNumeric() const
 970 {
 971     return ImpIsNumeric( /*bOnlyIntntl*/FALSE );
 972 }
 973
 974 BOOL SbxValue::IsNumericRTL() const
 975 {
 976     return ImpIsNumeric( /*bOnlyIntntl*/TRUE );
 977 }
 978
 979 BOOL SbxValue::ImpIsNumeric( BOOL bOnlyIntntl ) const
 980 {
 981
 982     if( !CanRead() )
 983     {
 984         SetError( SbxERR_PROP_WRITEONLY ); return FALSE;
 985     }
 986     // Downcast pruefen!!!
 987     if( this->ISA(SbxVariable) )
 988         ((SbxVariable*)this)->Broadcast( SBX_HINT_DATAWANTED );
 989     SbxDataType t = GetType();
 990     if( t == SbxSTRING )
 991     {
 992         if( aData.pString )
 993         {
 994             XubString s( *aData.pString );
 995             double n;
 996             SbxDataType t2;
 997             USHORT nLen = 0;
 998             if( ImpScan( s, n, t2, &nLen, /*bAllowIntntl*/FALSE, bOnlyIntntl ) == SbxERR_OK )
 999                 return BOOL( nLen == s.Len() );
1000         }
1001         return FALSE;
1002     }
1003     else
1004         return BOOL( t == SbxEMPTY
1005             || ( t >= SbxINTEGER && t <= SbxCURRENCY )
1006             || ( t >= SbxCHAR && t <= SbxUINT ) );
1007 }
1008
1009 SbxClassType SbxValue::GetClass() const
1010 {
1011     return SbxCLASS_VALUE;
1012 }
1013
1014 SbxDataType SbxValue::GetType() const
1015 {
1016     return SbxDataType( aData.eType & 0x0FFF );
1017 }
1018
1019 SbxDataType SbxValue::GetFullType() const
1020 {
1021     return aData.eType;
1022 }
1023
1024 BOOL SbxValue::SetType( SbxDataType t )
1025 {
1026     DBG_ASSERT( !( t & 0xF000 ), "Setzen von BYREF|ARRAY verboten!" );
1027     if( ( t == SbxEMPTY && aData.eType == SbxVOID )
1028      || ( aData.eType == SbxEMPTY && t == SbxVOID ) )
1029         return TRUE;
1030     if( ( t & 0x0FFF ) == SbxVARIANT )
1031     {
1032         // Versuch, den Datentyp auf Variant zu setzen
1033         ResetFlag( SBX_FIXED );
1034         if( IsFixed() )
1035         {
1036             SetError( SbxERR_CONVERSION ); return FALSE;
1037         }
1038         t = SbxEMPTY;
1039     }
1040     if( ( t & 0x0FFF ) != ( aData.eType & 0x0FFF ) )
1041     {
1042         if( !CanWrite() || IsFixed() )
1043         {
1044             SetError( SbxERR_CONVERSION ); return FALSE;
1045         }
1046         else
1047         {
1048             // Eventuelle Objekte freigeben
1049             switch( aData.eType )
1050             {
1051                 case SbxSTRING:
1052                     delete aData.pString;
1053                     break;
1054                 case SbxOBJECT:
1055                     if( aData.pObj && aData.pObj != this )
1056                     {
1057                         HACK(nicht bei Parent-Prop - sonst CyclicRef)
1058                         SbxVariable *pThisVar = PTR_CAST(SbxVariable, this);
1059                         UINT16 nSlotId = pThisVar
1060                                     ? ( (INT16) ( pThisVar->GetUserData() & 0xFFFF ) )
1061                                     : 0;
1062                         DBG_ASSERT( nSlotId != 5345 || pThisVar->GetName() == UniString::CreateFromAscii( "Parent" ),
1063                                     "SID_PARENTOBJECT heisst nicht 'Parent'" );
1064                         BOOL bParentProp = 5345 == nSlotId;
1065                         if ( !bParentProp )
1066                             aData.pObj->ReleaseRef();
1067                     }
1068                     break;
1069                 default: break;
1070             }
1071             // Das klappt immer, da auch die Float-Repraesentationen 0 sind.
1072             memset( &aData, 0, sizeof( SbxValues ) );
1073             aData.eType = t;
1074         }
1075     }
1076     return TRUE;
1077 }
1078
1079 BOOL SbxValue::Convert( SbxDataType eTo )
1080 {
1081     eTo = SbxDataType( eTo & 0x0FFF );
1082     if( ( aData.eType & 0x0FFF ) == eTo )
1083         return TRUE;
1084     if( !CanWrite() )
1085         return FALSE;
1086     if( eTo == SbxVARIANT )
1087     {
1088         // Versuch, den Datentyp auf Variant zu setzen
1089         ResetFlag( SBX_FIXED );
1090         if( IsFixed() )
1091         {
1092             SetError( SbxERR_CONVERSION ); return FALSE;
1093         }
1094         else
1095             return TRUE;
1096     }
1097     // Convert from Null geht niemals. Einmal Null, immer Null!
1098     if( aData.eType == SbxNULL )
1099     {
1100         SetError( SbxERR_CONVERSION ); return FALSE;
1101     }
1102
1103     // Konversion der Daten:
1104     SbxValues aNew;
1105     aNew.eType = eTo;
1106     if( Get( aNew ) )
1107     {
1108         // Der Datentyp konnte konvertiert werden. Bei Fixed-Elementen
1109         // ist hier Ende, da die Daten nicht uebernommen zu werden brauchen
1110         if( !IsFixed() )
1111         {
1112             SetType( eTo );
1113             Put( aNew );
1114             SetModified( TRUE );
1115         }
1116         Broadcast( SBX_HINT_CONVERTED );
1117         return TRUE;
1118     }
1119     else
1120         return FALSE;
1121 }
1122 ////////////////////////////////// Rechnen /////////////////////////////////
1123
1124 BOOL SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp )
1125 {
1126     bool bVBAInterop =  SbiRuntime::isVBAEnabled();
1127
1128     SbxDataType eThisType = GetType();
1129     SbxDataType eOpType = rOp.GetType();
1130     SbxError eOld = GetError();
1131     if( eOld != SbxERR_OK )
1132         ResetError();
1133     if( !CanWrite() )
1134         SetError( SbxERR_PROP_READONLY );
1135     else if( !rOp.CanRead() )
1136         SetError( SbxERR_PROP_WRITEONLY );
1137     // Sonderregel 1: Ist ein Operand Null, ist das Ergebnis Null
1138     else if( eThisType == SbxNULL || eOpType == SbxNULL )
1139         SetType( SbxNULL );
1140     // Sonderregel 2: Ist ein Operand Empty, ist das Ergebnis der 2. Operand
1141     else if( eThisType == SbxEMPTY
1142     && !bVBAInterop
1143     )
1144         *this = rOp;
1145     // 13.2.96: Nicht schon vor Get auf SbxEMPTY pruefen
1146     else
1147     {
1148         SbxValues aL, aR;
1149         bool bDecimal = false;
1150                 if( bVBAInterop && ( ( eThisType == SbxSTRING && eOpType != SbxSTRING && eOpType != SbxEMPTY ) ||
1151                          ( eThisType != SbxSTRING && eThisType != SbxEMPTY && eOpType == SbxSTRING ) ) &&
1152              ( eOp == SbxMUL || eOp == SbxDIV || eOp == SbxPLUS || eOp == SbxMINUS ) )
1153         {
1154             goto Lbl_OpIsDouble;
1155         }
1156         else if( eThisType == SbxSTRING || eOp == SbxCAT || ( bVBAInterop && ( eOpType == SbxSTRING ) && (  eOp == SbxPLUS ) ) )
1157         {
1158             if( eOp == SbxCAT || eOp == SbxPLUS )
1159             {
1160                 // AB 5.11.1999, OUString beruecksichtigen
1161                 aL.eType = aR.eType = SbxSTRING;
1162                 rOp.Get( aR );
1163                 // AB 8.12.1999, #70399: Hier wieder GetType() rufen, Get() kann Typ aendern!
1164                 if( rOp.GetType() == SbxEMPTY )
1165                     goto Lbl_OpIsEmpty;
1166                 Get( aL );
1167
1168                 // #30576: Erstmal testen, ob Wandlung geklappt hat
1169                 if( aL.pString != NULL && aR.pString != NULL )
1170                 {
1171                     *aL.pString += *aR.pString;
1172                 }
1173                 // Nicht einmal Left OK?
1174                 else if( aL.pString == NULL )
1175                 {
1176                     aL.pString = new String();
1177                 }
1178                 Put( aL );
1179             }
1180             else
1181                 SetError( SbxERR_CONVERSION );
1182         }
1183         else if( eOpType == SbxSTRING && rOp.IsFixed() )
1184         {       // Numerisch: rechts darf kein String stehen
1185             SetError( SbxERR_CONVERSION );
1186         }
1187         else if( ( eOp >= SbxIDIV && eOp <= SbxNOT ) || eOp == SbxMOD )
1188         {
1189             if( GetType() == eOpType )
1190             {
1191                 if( GetType() == SbxULONG64
1192                     || GetType() == SbxLONG64
1193                     || GetType() == SbxCURRENCY
1194                     || GetType() == SbxULONG )
1195                     aL.eType = aR.eType = GetType();
1196 //                              else if( GetType() == SbxDouble || GetType() == SbxSingle )
1197 //                                      aL.eType = aR.eType = SbxLONG64;
1198                                 else if ( bVBAInterop && eOpType == SbxBOOL )
1199                                         aL.eType = aR.eType = SbxBOOL;
1200                 else
1201                     aL.eType = aR.eType = SbxLONG;
1202             }
1203             else if( GetType() == SbxCURRENCY || eOpType == SbxCURRENCY
1204                      || GetType() == SbxULONG64 || eOpType == SbxULONG64
1205                      || GetType() == SbxLONG64 || eOpType == SbxLONG64 )
1206                 aL.eType = aR.eType = SbxLONG64;
1207 //                      else if( GetType() == SbxDouble || rOP.GetType() == SbxDouble
1208 //                               || GetType() == SbxSingle || rOP.GetType() == SbxSingle )
1209 //                              aL.eType = aR.eType = SbxLONG64;
1210             else
1211                 aL.eType = aR.eType = SbxLONG;
1212
1213             if( rOp.Get( aR ) )
1214             {
1215                 if( rOp.GetType() == SbxEMPTY )
1216                 {
1217                     if ( !bVBAInterop || ( bVBAInterop && ( eOp != SbxNOT  ) ) )
1218                         goto Lbl_OpIsEmpty;
1219                 }
1220                 if( Get( aL ) ) switch( eOp )
1221                 {
1222                     case SbxIDIV:
1223                         if( aL.eType == SbxCURRENCY )
1224                             aL.eType = SbxLONG64;
1225                         if( aL.eType == SbxLONG64 )
1226                             if( !aR.nLong64 ) SetError( SbxERR_ZERODIV );
1227                             else aL.nLong64 /= aR.nLong64;
1228                         else if( aL.eType == SbxULONG64 )
1229                             if( !aR.nULong64 ) SetError( SbxERR_ZERODIV );
1230                             else aL.nULong64 /= aR.nULong64;
1231                         else if( aL.eType == SbxLONG )
1232                             if( !aR.nLong ) SetError( SbxERR_ZERODIV );
1233                             else aL.nLong /= aR.nLong;
1234                         else
1235                             if( !aR.nULong ) SetError( SbxERR_ZERODIV );
1236                             else aL.nULong /= aR.nULong;
1237                         break;
1238                     case SbxMOD:
1239                         if( aL.eType == SbxCURRENCY )
1240                             aL.eType = SbxLONG64;
1241                         if( aL.eType == SbxLONG64 )
1242                             if( !aR.nLong64 ) SetError( SbxERR_ZERODIV );
1243                             else aL.nLong64 %= aR.nLong64;
1244                         else if( aL.eType == SbxULONG64 )
1245                             if( !aR.nULong64 ) SetError( SbxERR_ZERODIV );
1246                             else aL.nULong64 %= aR.nULong64;
1247                         else if( aL.eType == SbxLONG )
1248                             if( !aR.nLong ) SetError( SbxERR_ZERODIV );
1249                             else aL.nLong %= aR.nLong;
1250                         else
1251                             if( !aR.nULong ) SetError( SbxERR_ZERODIV );
1252                             else aL.nULong %= aR.nULong;
1253                         break;
1254                     case SbxAND:
1255                         if( aL.eType != SbxLONG && aL.eType != SbxULONG )
1256                             aL.nLong64 &= aR.nLong64;
1257                         else
1258                             aL.nLong &= aR.nLong;
1259                         break;
1260                     case SbxOR:
1261                         if( aL.eType != SbxLONG && aL.eType != SbxULONG )
1262                             aL.nLong64 |= aR.nLong64;
1263                         else
1264                             aL.nLong |= aR.nLong;
1265                         break;
1266                     case SbxXOR:
1267                         if( aL.eType != SbxLONG && aL.eType != SbxULONG )
1268                             aL.nLong64 ^= aR.nLong64;
1269                         else
1270                             aL.nLong ^= aR.nLong;
1271                         break;
1272                     case SbxEQV:
1273                         if( aL.eType != SbxLONG && aL.eType != SbxULONG )
1274                             aL.nLong64 = (aL.nLong64 & aR.nLong64) | (~aL.nLong64 & ~aR.nLong64);
1275                         else
1276                             aL.nLong = (aL.nLong & aR.nLong) | (~aL.nLong & ~aR.nLong);
1277                         break;
1278                     case SbxIMP:
1279                         if( aL.eType != SbxLONG && aL.eType != SbxULONG )
1280                             aL.nLong64 = ~aL.nLong64 | aR.nLong64;
1281                         else
1282                             aL.nLong = ~aL.nLong | aR.nLong;
1283                         break;
1284                     case SbxNOT:
1285                         if( aL.eType != SbxLONG && aL.eType != SbxULONG )
1286                                                 {
1287                                                         if ( aL.eType != SbxBOOL )
1288                             aL.nLong64 = ~aL.nLong64;
1289                         else
1290                             aL.nLong = ~aL.nLong;
1291                                                 }
1292                                                 else
1293                                                         aL.nLong = ~aL.nLong;
1294                         break;
1295                     default: break;
1296                 }
1297             }
1298         }
1299         else if( ( GetType() == SbxDECIMAL || rOp.GetType() == SbxDECIMAL ) &&
1300                  ( eOp == SbxMUL || eOp == SbxDIV || eOp == SbxPLUS || eOp == SbxMINUS || eOp == SbxNEG ) )
1301         {
1302             aL.eType = aR.eType = SbxDECIMAL;
1303             bDecimal = true;
1304             if( rOp.Get( aR ) )
1305             {
1306                 if( rOp.GetType() == SbxEMPTY )
1307                 {
1308                     releaseDecimalPtr( aL.pDecimal );
1309                     goto Lbl_OpIsEmpty;
1310                 }
1311                 if( Get( aL ) )
1312                 {
1313                     if( aL.pDecimal && aR.pDecimal )
1314                     {
1315                         bool bOk = true;
1316                         switch( eOp )
1317                         {
1318                             case SbxMUL:
1319                                 bOk = ( *(aL.pDecimal) *= *(aR.pDecimal) );
1320                                 break;
1321                             case SbxDIV:
1322                                 if( aR.pDecimal->isZero() )
1323                                     SetError( SbxERR_ZERODIV );
1324                                 else
1325                                     bOk = ( *(aL.pDecimal) /= *(aR.pDecimal) );
1326                                 break;
1327                             case SbxPLUS:
1328                                 bOk = ( *(aL.pDecimal) += *(aR.pDecimal) );
1329                                 break;
1330                             case SbxMINUS:
1331                                 bOk = ( *(aL.pDecimal) -= *(aR.pDecimal) );
1332                                 break;
1333                             case SbxNEG:
1334                                 bOk = ( aL.pDecimal->neg() );
1335                                 break;
1336                             default:
1337                                 SetError( SbxERR_NOTIMP );
1338                         }
1339                         if( !bOk )
1340                             SetError( SbxERR_OVERFLOW );
1341                     }
1342                     else
1343                     {
1344                         SetError( SbxERR_CONVERSION );
1345                     }
1346                 }
1347             }
1348         }
1349         else if( GetType() == SbxCURRENCY || rOp.GetType() == SbxCURRENCY )
1350         {
1351             aL.eType = SbxCURRENCY;
1352             aR.eType = SbxCURRENCY;
1353
1354             if( rOp.Get( aR ) )
1355             {
1356                 static BigInt n10K( 10000 );
1357
1358                 if( rOp.GetType() == SbxEMPTY )
1359                     goto Lbl_OpIsEmpty;
1360
1361                 if( Get( aL ) ) switch( eOp )
1362                 {
1363                     case SbxMUL:
1364                     {
1365                         // #i20704 Implement directly
1366                         BigInt b1( aL.nLong64 );
1367                         BigInt b2( aR.nLong64 );
1368                         b1 *= b2;
1369                         b1 /= n10K;
1370                         double d = double( b1 ) / 10000.0;
1371                         if( d > SbxMAXCURR || d < SbxMINCURR )
1372                             SetError( SbxERR_OVERFLOW );
1373                         else
1374                             b1.INT64( &aL.nLong64 );
1375                         break;
1376                     }
1377                     case SbxDIV:
1378                         if( !aR.nLong64 )
1379                         {
1380                             SetError( SbxERR_ZERODIV );
1381                         }
1382                         else
1383                         {
1384                             // #i20704 Implement directly
1385                             BigInt b1( aL.nLong64 );
1386                             BigInt b2( aR.nLong64 );
1387                             b1 *= n10K;
1388                             b1 /= b2;
1389                             double d = double( b1 ) / 10000.0;
1390                             if( d > SbxMAXCURR || d < SbxMINCURR )
1391                                 SetError( SbxERR_OVERFLOW );
1392                             else
1393                                 b1.INT64( &aL.nLong64 );
1394                         }
1395                         break;
1396                     case SbxPLUS:
1397                         aL.nLong64 += aR.nLong64; break;
1398                     case SbxMINUS:
1399                         aL.nLong64 -= aR.nLong64; break;
1400                     case SbxNEG:
1401                         aL.nLong64 = -aL.nLong64; break;
1402                     default:
1403                         SetError( SbxERR_NOTIMP );
1404                 }
1405             }
1406         }
1407         else
1408 Lbl_OpIsDouble:
1409         {       // Andere Operatoren
1410             aL.eType = aR.eType = SbxDOUBLE;
1411             if( rOp.Get( aR ) )
1412             {
1413                 if( rOp.GetType() == SbxEMPTY )
1414                 {
1415                     if ( !bVBAInterop || ( bVBAInterop && ( eOp != SbxNEG ) ) )
1416                         goto Lbl_OpIsEmpty;
1417                 }
1418                 if( Get( aL ) )
1419                 {
1420                     switch( eOp )
1421                     {
1422                         case SbxEXP:
1423                             aL.nDouble = pow( aL.nDouble, aR.nDouble );
1424                             break;
1425                         case SbxMUL:
1426                             aL.nDouble *= aR.nDouble; break;
1427                         case SbxDIV:
1428                             if( !aR.nDouble ) SetError( SbxERR_ZERODIV );
1429                             else aL.nDouble /= aR.nDouble; break;
1430                         case SbxPLUS:
1431                             aL.nDouble += aR.nDouble; break;
1432                         case SbxMINUS:
1433                             aL.nDouble -= aR.nDouble; break;
1434                         case SbxNEG:
1435                             aL.nDouble = -aL.nDouble; break;
1436                         default:
1437                             SetError( SbxERR_NOTIMP );
1438                     }
1439
1440                     // #45465 Date braucht bei + eine Spezial-Behandlung
1441                     if( eOp == SbxPLUS && (GetType() == SbxDATE || rOp.GetType() == SbxDATE ) )
1442                         aL.eType = SbxDATE;
1443                 }
1444             }
1445
1446         }
1447         if( !IsError() )
1448             Put( aL );
1449         if( bDecimal )
1450         {
1451             releaseDecimalPtr( aL.pDecimal );
1452             releaseDecimalPtr( aR.pDecimal );
1453         }
1454     }
1455 Lbl_OpIsEmpty:
1456
1457     BOOL bRes = BOOL( !IsError() );
1458     if( bRes && eOld != SbxERR_OK )
1459         SetError( eOld );
1460     return bRes;
1461 }
1462
1463 // Die Vergleichs-Routine liefert TRUE oder FALSE.
1464
1465 BOOL SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const
1466 {
1467     bool bVBAInterop =  SbiRuntime::isVBAEnabled();
1468
1469     BOOL bRes = FALSE;
1470     SbxError eOld = GetError();
1471     if( eOld != SbxERR_OK )
1472         ResetError();
1473     if( !CanRead() || !rOp.CanRead() )
1474         SetError( SbxERR_PROP_WRITEONLY );
1475     else if( GetType() == SbxNULL && rOp.GetType() == SbxNULL && !bVBAInterop )
1476     {
1477         bRes = TRUE;
1478     }
1479     else if( GetType() == SbxEMPTY && rOp.GetType() == SbxEMPTY )
1480                 bRes = !bVBAInterop ? TRUE : ( eOp == SbxEQ ? TRUE : FALSE );
1481     // Sonderregel 1: Ist ein Operand Null, ist das Ergebnis FALSE
1482     else if( GetType() == SbxNULL || rOp.GetType() == SbxNULL )
1483         bRes = FALSE;
1484     // Sonderregel 2: Wenn beide Variant sind und einer ist numerisch,
1485     // und der andere ein String, ist num < str
1486     else if( !IsFixed() && !rOp.IsFixed()
1487      && ( rOp.GetType() == SbxSTRING && GetType() != SbxSTRING && IsNumeric() ) && !bVBAInterop
1488     )
1489         bRes = BOOL( eOp == SbxLT || eOp == SbxLE || eOp == SbxNE );
1490     else if( !IsFixed() && !rOp.IsFixed()
1491      && ( GetType() == SbxSTRING && rOp.GetType() != SbxSTRING && rOp.IsNumeric() )
1492 && !bVBAInterop
1493     )
1494         bRes = BOOL( eOp == SbxGT || eOp == SbxGE || eOp == SbxNE );
1495     else
1496     {
1497         SbxValues aL, aR;
1498         // Wenn einer der Operanden ein String ist,
1499         // findet ein Stringvergleich statt
1500         if( GetType() == SbxSTRING || rOp.GetType() == SbxSTRING )
1501         {
1502             aL.eType = aR.eType = SbxSTRING;
1503             if( Get( aL ) && rOp.Get( aR ) ) switch( eOp )
1504             {
1505                 case SbxEQ:
1506                     bRes = BOOL( *aL.pString == *aR.pString ); break;
1507                 case SbxNE:
1508                     bRes = BOOL( *aL.pString != *aR.pString ); break;
1509                 case SbxLT:
1510                     bRes = BOOL( *aL.pString <  *aR.pString ); break;
1511                 case SbxGT:
1512                     bRes = BOOL( *aL.pString >  *aR.pString ); break;
1513                 case SbxLE:
1514                     bRes = BOOL( *aL.pString <= *aR.pString ); break;
1515                 case SbxGE:
1516                     bRes = BOOL( *aL.pString >= *aR.pString ); break;
1517                 default:
1518                     SetError( SbxERR_NOTIMP );
1519             }
1520         }
1521         // AB 19.12.95: Wenn SbxSINGLE beteiligt, auf SINGLE konvertieren,
1522         //                              sonst gibt es numerische Fehler
1523         else if( GetType() == SbxSINGLE || rOp.GetType() == SbxSINGLE )
1524         {
1525             aL.eType = aR.eType = SbxSINGLE;
1526             if( Get( aL ) && rOp.Get( aR ) )
1527               switch( eOp )
1528             {
1529                 case SbxEQ:
1530                     bRes = BOOL( aL.nSingle == aR.nSingle ); break;
1531                 case SbxNE:
1532                     bRes = BOOL( aL.nSingle != aR.nSingle ); break;
1533                 case SbxLT:
1534                     bRes = BOOL( aL.nSingle <  aR.nSingle ); break;
1535                 case SbxGT:
1536                     bRes = BOOL( aL.nSingle >  aR.nSingle ); break;
1537                 case SbxLE:
1538                     bRes = BOOL( aL.nSingle <= aR.nSingle ); break;
1539                 case SbxGE:
1540                     bRes = BOOL( aL.nSingle >= aR.nSingle ); break;
1541                 default:
1542                     SetError( SbxERR_NOTIMP );
1543             }
1544         }
1545         else if( GetType() == SbxDECIMAL && rOp.GetType() == SbxDECIMAL )
1546         {
1547             aL.eType = aR.eType = SbxDECIMAL;
1548             Get( aL );
1549             rOp.Get( aR );
1550             if( aL.pDecimal && aR.pDecimal )
1551             {
1552                 SbxDecimal::CmpResult eRes = compare( *aL.pDecimal, *aR.pDecimal );
1553                 switch( eOp )
1554                 {
1555                     case SbxEQ:
1556                         bRes = BOOL( eRes == SbxDecimal::EQ ); break;
1557                     case SbxNE:
1558                         bRes = BOOL( eRes != SbxDecimal::EQ ); break;
1559                     case SbxLT:
1560                         bRes = BOOL( eRes == SbxDecimal::LT ); break;
1561                     case SbxGT:
1562                         bRes = BOOL( eRes == SbxDecimal::GT ); break;
1563                     case SbxLE:
1564                         bRes = BOOL( eRes != SbxDecimal::GT ); break;
1565                     case SbxGE:
1566                         bRes = BOOL( eRes != SbxDecimal::LT ); break;
1567                     default:
1568                         SetError( SbxERR_NOTIMP );
1569                 }
1570             }
1571             else
1572             {
1573                 SetError( SbxERR_CONVERSION );
1574             }
1575             releaseDecimalPtr( aL.pDecimal );
1576             releaseDecimalPtr( aR.pDecimal );
1577         }
1578         // Alles andere auf SbxDOUBLE-Basis vergleichen
1579         else
1580         {
1581             aL.eType = aR.eType = SbxDOUBLE;
1582             //if( Get( aL ) && rOp.Get( aR ) )
1583             bool bGetL = Get( aL );
1584             bool bGetR = rOp.Get( aR );
1585             if( bGetL && bGetR )
1586               switch( eOp )
1587             {
1588                 case SbxEQ:
1589                     bRes = BOOL( aL.nDouble == aR.nDouble ); break;
1590                 case SbxNE:
1591                     bRes = BOOL( aL.nDouble != aR.nDouble ); break;
1592                 case SbxLT:
1593                     bRes = BOOL( aL.nDouble <  aR.nDouble ); break;
1594                 case SbxGT:
1595                     bRes = BOOL( aL.nDouble >  aR.nDouble ); break;
1596                 case SbxLE:
1597                     bRes = BOOL( aL.nDouble <= aR.nDouble ); break;
1598                 case SbxGE:
1599                     bRes = BOOL( aL.nDouble >= aR.nDouble ); break;
1600                 default:
1601                     SetError( SbxERR_NOTIMP );
1602             }
1603             // at least one value was got
1604             // if this is VBA then a conversion error for one
1605             // side will yield a false result of an equality test
1606             else if ( bGetR || bGetL )
1607             {
1608                 if ( bVBAInterop && eOp == SbxEQ && GetError() == SbxERR_CONVERSION )
1609                 {
1610                     ResetError();
1611                     bRes = FALSE;
1612                 }
1613             }
1614         }
1615     }
1616     if( eOld != SbxERR_OK )
1617         SetError( eOld );
1618     return bRes;
1619 }
1620
1621 ///////////////////////////// Lesen/Schreiben ////////////////////////////
1622
1623 BOOL SbxValue::LoadData( SvStream& r, USHORT )
1624 {
1625     SbxValue::Clear();
1626     UINT16 nType;
1627     r >> nType;
1628     aData.eType = SbxDataType( nType );
1629     switch( nType )
1630     {
1631         case SbxBOOL:
1632         case SbxINTEGER:
1633             r >> aData.nInteger; break;
1634         case SbxLONG:
1635             r >> aData.nLong; break;
1636         case SbxSINGLE:
1637         {
1638             // Floats als ASCII
1639             XubString aVal;
1640             r.ReadByteString( aVal, RTL_TEXTENCODING_ASCII_US );
1641             double d;
1642             SbxDataType t;
1643             if( ImpScan( aVal, d, t, NULL ) != SbxERR_OK || t == SbxDOUBLE )
1644             {
1645                 aData.nSingle = 0.0F;
1646                 return FALSE;
1647             }
1648             aData.nSingle = (float) d;
1649             break;
1650         }
1651         case SbxDATE:
1652         case SbxDOUBLE:
1653         {
1654             // Floats als ASCII
1655             XubString aVal;
1656             r.ReadByteString( aVal, RTL_TEXTENCODING_ASCII_US );
1657             SbxDataType t;
1658             if( ImpScan( aVal, aData.nDouble, t, NULL ) != SbxERR_OK )
1659             {
1660                 aData.nDouble = 0.0;
1661                 return FALSE;
1662             }
1663             break;
1664         }
1665         case SbxULONG64:
1666         {
1667             r >> aData.nULong64.nHigh >> aData.nULong64.nLow;
1668             break;
1669         }
1670         case SbxLONG64:
1671         case SbxCURRENCY:
1672         {
1673             r >> aData.nLong64.nHigh >> aData.nLong64.nLow;
1674             break;
1675         }
1676         case SbxSTRING:
1677         {
1678             XubString aVal;
1679             r.ReadByteString( aVal, RTL_TEXTENCODING_ASCII_US );
1680             if( aVal.Len() )
1681                 aData.pString = new XubString( aVal );
1682             else
1683                 aData.pString = NULL; // JSM 22.09.1995
1684             break;
1685         }
1686         case SbxERROR:
1687         case SbxUSHORT:
1688             r >> aData.nUShort; break;
1689         case SbxOBJECT:
1690         {
1691             BYTE nMode;
1692             r >> nMode;
1693             switch( nMode )
1694             {
1695                 case 0:
1696                     aData.pObj = NULL;
1697                     break;
1698                 case 1:
1699                     aData.pObj = SbxBase::Load( r );
1700                     return BOOL( aData.pObj != NULL );
1701                 case 2:
1702                     aData.pObj = this;
1703                     break;
1704             }
1705             break;
1706         }
1707         case SbxCHAR:
1708         {
1709             char c;
1710             r >> c;
1711             aData.nChar = c;
1712             break;
1713         }
1714         case SbxBYTE:
1715             r >> aData.nByte; break;
1716         case SbxULONG:
1717             r >> aData.nULong; break;
1718         case SbxINT:
1719         {
1720             BYTE n;
1721             r >> n;
1722             // Passt der Int auf diesem System?
1723             if( n > SAL_TYPES_SIZEOFINT )
1724                 r >> aData.nLong, aData.eType = SbxLONG;
1725             else
1726                 r >> aData.nInt;
1727             break;
1728         }
1729         case SbxUINT:
1730         {
1731             BYTE n;
1732             r >> n;
1733             // Passt der UInt auf diesem System?
1734             if( n > SAL_TYPES_SIZEOFINT )
1735                 r >> aData.nULong, aData.eType = SbxULONG;
1736             else
1737                 r >> (sal_uInt32&)aData.nUInt;
1738             break;
1739         }
1740         case SbxEMPTY:
1741         case SbxNULL:
1742         case SbxVOID:
1743             break;
1744         case SbxDATAOBJECT:
1745             r >> aData.nLong;
1746             break;
1747         // #78919 For backwards compatibility
1748         case SbxWSTRING:
1749         case SbxWCHAR:
1750             break;
1751         default:
1752             memset (&aData,0,sizeof(aData));
1753             ResetFlag(SBX_FIXED);
1754             aData.eType = SbxNULL;
1755             DBG_ASSERT( !this, "Nicht unterstuetzer Datentyp geladen" );
1756             return FALSE;
1757     }
1758     return TRUE;
1759 }
1760
1761 BOOL SbxValue::StoreData( SvStream& r ) const
1762 {
1763     UINT16 nType = sal::static_int_cast< UINT16 >(aData.eType);
1764     r << nType;
1765     switch( nType & 0x0FFF )
1766     {
1767         case SbxBOOL:
1768         case SbxINTEGER:
1769             r << aData.nInteger; break;
1770         case SbxLONG:
1771             r << aData.nLong; break;
1772         case SbxDATE:
1773             // #49935: Als double speichern, sonst Fehler beim Einlesen
1774             ((SbxValue*)this)->aData.eType = (SbxDataType)( ( nType & 0xF000 ) | SbxDOUBLE );
1775             r.WriteByteString( GetCoreString(), RTL_TEXTENCODING_ASCII_US );
1776             ((SbxValue*)this)->aData.eType = (SbxDataType)nType;
1777             break;
1778         case SbxSINGLE:
1779         case SbxDOUBLE:
1780             r.WriteByteString( GetCoreString(), RTL_TEXTENCODING_ASCII_US );
1781             break;
1782         case SbxULONG64:
1783         {
1784             r << aData.nULong64.nHigh << aData.nULong64.nLow;
1785             break;
1786         }
1787         case SbxLONG64:
1788         case SbxCURRENCY:
1789         {
1790             r << aData.nLong64.nHigh << aData.nLong64.nLow;
1791             break;
1792         }
1793         case SbxSTRING:
1794             if( aData.pString )
1795             {
1796                 r.WriteByteString( *aData.pString, RTL_TEXTENCODING_ASCII_US );
1797             }
1798             else
1799             {
1800                 String aEmpty;
1801                 r.WriteByteString( aEmpty, RTL_TEXTENCODING_ASCII_US );
1802             }
1803             break;
1804         case SbxERROR:
1805         case SbxUSHORT:
1806             r << aData.nUShort; break;
1807         case SbxOBJECT:
1808             // sich selbst als Objektptr speichern geht nicht!
1809             if( aData.pObj )
1810             {
1811                 if( PTR_CAST(SbxValue,aData.pObj) != this )
1812                 {
1813                     r << (BYTE) 1;
1814                     return aData.pObj->Store( r );
1815                 }
1816                 else
1817                     r << (BYTE) 2;
1818             }
1819             else
1820                 r << (BYTE) 0;
1821             break;
1822         case SbxCHAR:
1823         {
1824             char c = sal::static_int_cast< char >(aData.nChar);
1825             r << c;
1826             break;
1827         }
1828         case SbxBYTE:
1829             r << aData.nByte; break;
1830         case SbxULONG:
1831             r << aData.nULong; break;
1832         case SbxINT:
1833         {
1834             BYTE n = SAL_TYPES_SIZEOFINT;
1835             r << n << (sal_Int32)aData.nInt;
1836             break;
1837         }
1838         case SbxUINT:
1839         {
1840             BYTE n = SAL_TYPES_SIZEOFINT;
1841             r << n << (sal_uInt32)aData.nUInt;
1842             break;
1843         }
1844         case SbxEMPTY:
1845         case SbxNULL:
1846         case SbxVOID:
1847             break;
1848         case SbxDATAOBJECT:
1849             r << aData.nLong;
1850             break;
1851         // #78919 For backwards compatibility
1852         case SbxWSTRING:
1853         case SbxWCHAR:
1854             break;
1855         default:
1856             DBG_ASSERT( !this, "Speichern eines nicht unterstuetzten Datentyps" );
1857             return FALSE;
1858     }
1859     return TRUE;
1860 }
1861