basic/source/sbx/sbxdec.cxx

   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 <tools/errcode.hxx>
  21
  22 #include <basic/sbx.hxx>
  23 #include "sbxconv.hxx"
  24
  25 #include <com/sun/star/bridge/oleautomation/Decimal.hpp>
  26 #include <boost/scoped_array.hpp>
  27
  28 // Implementation SbxDecimal
  29 SbxDecimal::SbxDecimal()
  30 {
  31     setInt( 0 );
  32     mnRefCount = 0;
  33 }
  34
  35 SbxDecimal::SbxDecimal( const SbxDecimal& rDec )
  36 {
  37 #ifdef WIN32
  38     maDec = rDec.maDec;
  39 #else
  40     (void)rDec;
  41 #endif
  42     mnRefCount = 0;
  43 }
  44
  45 SbxDecimal::SbxDecimal
  46     ( const com::sun::star::bridge::oleautomation::Decimal& rAutomationDec )
  47 {
  48 #ifdef WIN32
  49     maDec.scale = rAutomationDec.Scale;
  50     maDec.sign  = rAutomationDec.Sign;
  51     maDec.Lo32 = rAutomationDec.LowValue;
  52     maDec.Mid32 = rAutomationDec.MiddleValue;
  53     maDec.Hi32 = rAutomationDec.HighValue;
  54 #else
  55     (void)rAutomationDec;
  56 #endif
  57     mnRefCount = 0;
  58 }
  59
  60 void SbxDecimal::fillAutomationDecimal
  61     ( com::sun::star::bridge::oleautomation::Decimal& rAutomationDec )
  62 {
  63 #ifdef WIN32
  64     rAutomationDec.Scale = maDec.scale;
  65     rAutomationDec.Sign = maDec.sign;
  66     rAutomationDec.LowValue = maDec.Lo32;
  67     rAutomationDec.MiddleValue = maDec.Mid32;
  68     rAutomationDec.HighValue = maDec.Hi32;
  69 #else
  70     (void)rAutomationDec;
  71 #endif
  72 }
  73
  74 SbxDecimal::~SbxDecimal()
  75 {
  76 }
  77
  78 void releaseDecimalPtr( SbxDecimal*& rpDecimal )
  79 {
  80     if( rpDecimal )
  81     {
  82         rpDecimal->mnRefCount--;
  83         if( rpDecimal->mnRefCount == 0 )
  84         {
  85             delete rpDecimal;
  86             rpDecimal = NULL;
  87         }
  88     }
  89 }
  90
  91 #ifdef WIN32
  92
  93 bool SbxDecimal::operator -= ( const SbxDecimal &r )
  94 {
  95     HRESULT hResult = VarDecSub( &maDec, (LPDECIMAL)&r.maDec, &maDec );
  96     bool bRet = ( hResult == S_OK );
  97     return bRet;
  98 }
  99
 100 bool SbxDecimal::operator += ( const SbxDecimal &r )
 101 {
 102     HRESULT hResult = VarDecAdd( &maDec, (LPDECIMAL)&r.maDec, &maDec );
 103     bool bRet = ( hResult == S_OK );
 104     return bRet;
 105 }
 106
 107 bool SbxDecimal::operator /= ( const SbxDecimal &r )
 108 {
 109     HRESULT hResult = VarDecDiv( &maDec, (LPDECIMAL)&r.maDec, &maDec );
 110     bool bRet = ( hResult == S_OK );
 111     return bRet;
 112 }
 113
 114 bool SbxDecimal::operator *= ( const SbxDecimal &r )
 115 {
 116     HRESULT hResult = VarDecMul( &maDec, (LPDECIMAL)&r.maDec, &maDec );
 117     bool bRet = ( hResult == S_OK );
 118     return bRet;
 119 }
 120
 121 bool SbxDecimal::neg()
 122 {
 123     HRESULT hResult = VarDecNeg( &maDec, &maDec );
 124     bool bRet = ( hResult == S_OK );
 125     return bRet;
 126 }
 127
 128 bool SbxDecimal::isZero()
 129 {
 130     SbxDecimal aZeroDec;
 131     aZeroDec.setLong( 0 );
 132     bool bZero = ( EQ == compare( *this, aZeroDec ) );
 133     return bZero;
 134 }
 135
 136 SbxDecimal::CmpResult compare( const SbxDecimal &rLeft, const SbxDecimal &rRight )
 137 {
 138     HRESULT hResult = VarDecCmp( (LPDECIMAL)&rLeft.maDec, (LPDECIMAL)&rRight.maDec );
 139     SbxDecimal::CmpResult eRes = (SbxDecimal::CmpResult)hResult;
 140     return eRes;
 141 }
 142
 143 void SbxDecimal::setChar( sal_Unicode val )
 144 {
 145     VarDecFromUI2( (sal_uInt16)val, &maDec );
 146 }
 147
 148 void SbxDecimal::setByte( sal_uInt8 val )
 149 {
 150     VarDecFromUI1( (sal_uInt8)val, &maDec );
 151 }
 152
 153 void SbxDecimal::setShort( sal_Int16 val )
 154 {
 155     VarDecFromI2( (short)val, &maDec );
 156 }
 157
 158 void SbxDecimal::setLong( sal_Int32 val )
 159 {
 160     VarDecFromI4( (long)val, &maDec );
 161 }
 162
 163 void SbxDecimal::setUShort( sal_uInt16 val )
 164 {
 165     VarDecFromUI2( (sal_uInt16)val, &maDec );
 166 }
 167
 168 void SbxDecimal::setULong( sal_uInt32 val )
 169 {
 170     VarDecFromUI4( static_cast<ULONG>(val), &maDec );
 171 }
 172
 173 bool SbxDecimal::setSingle( float val )
 174 {
 175     bool bRet = ( VarDecFromR4( val, &maDec ) == S_OK );
 176     return bRet;
 177 }
 178
 179 bool SbxDecimal::setDouble( double val )
 180 {
 181     bool bRet = ( VarDecFromR8( val, &maDec ) == S_OK );
 182     return bRet;
 183 }
 184
 185 void SbxDecimal::setInt( int val )
 186 {
 187     setLong( (sal_Int32)val );
 188 }
 189
 190 void SbxDecimal::setUInt( unsigned int val )
 191 {
 192     setULong( (sal_uInt32)val );
 193 }
 194
 195 bool SbxDecimal::setString( OUString* pOUString )
 196 {
 197     assert(pOUString);
 198
 199     static LCID nLANGID = MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US );
 200
 201     // Convert delimiter
 202     sal_Unicode cDecimalSep;
 203     sal_Unicode cThousandSep;
 204     ImpGetIntntlSep( cDecimalSep, cThousandSep );
 205
 206     bool bRet = false;
 207     HRESULT hResult;
 208     if( cDecimalSep != '.' || cThousandSep != ',' )
 209     {
 210         int nLen = pOUString->getLength();
 211         boost::scoped_array<sal_Unicode> pBuffer(new sal_Unicode[nLen +  1]);
 212         pBuffer[nLen] = 0;
 213
 214         const sal_Unicode* pSrc = pOUString->getStr();
 215         int i;
 216         for( i = 0 ; i < nLen ; ++i )
 217             pBuffer[i] = pSrc[i];
 218
 219         sal_Unicode c;
 220         i = 0;
 221         while( (c = pBuffer[i]) != 0 )
 222         {
 223             if( c == cDecimalSep )
 224                 pBuffer[i] = '.';
 225             else if( c == cThousandSep )
 226                 pBuffer[i] = ',';
 227             i++;
 228         }
 229         hResult = VarDecFromStr( (OLECHAR*)pBuffer.get(), nLANGID, 0, &maDec );
 230     }
 231     else
 232     {
 233         hResult = VarDecFromStr( (OLECHAR*)pOUString->getStr(), nLANGID, 0, &maDec );
 234     }
 235     bRet = ( hResult == S_OK );
 236     return bRet;
 237 }
 238
 239
 240 bool SbxDecimal::getChar( sal_Unicode& rVal )
 241 {
 242     bool bRet = ( VarUI2FromDec( &maDec, &rVal ) == S_OK );
 243     return bRet;
 244 }
 245
 246 bool SbxDecimal::getShort( sal_Int16& rVal )
 247 {
 248     bool bRet = ( VarI2FromDec( &maDec, &rVal ) == S_OK );
 249     return bRet;
 250 }
 251
 252 bool SbxDecimal::getLong( sal_Int32& rVal )
 253 {
 254     bool bRet = ( VarI4FromDec( &maDec, &rVal ) == S_OK );
 255     return bRet;
 256 }
 257
 258 bool SbxDecimal::getUShort( sal_uInt16& rVal )
 259 {
 260     bool bRet = ( VarUI2FromDec( &maDec, &rVal ) == S_OK );
 261     return bRet;
 262 }
 263
 264 bool SbxDecimal::getULong( sal_uInt32& rVal )
 265 {
 266     bool bRet = ( VarUI4FromDec( &maDec, &rVal ) == S_OK );
 267     return bRet;
 268 }
 269
 270 bool SbxDecimal::getSingle( float& rVal )
 271 {
 272     bool bRet = ( VarR4FromDec( &maDec, &rVal ) == S_OK );
 273     return bRet;
 274 }
 275
 276 bool SbxDecimal::getDouble( double& rVal )
 277 {
 278     bool bRet = ( VarR8FromDec( &maDec, &rVal ) == S_OK );
 279     return bRet;
 280 }
 281
 282 #else
 283 // !WIN32
 284
 285 bool SbxDecimal::operator -= ( const SbxDecimal &r )
 286 {
 287     (void)r;
 288     return false;
 289 }
 290
 291 bool SbxDecimal::operator += ( const SbxDecimal &r )
 292 {
 293     (void)r;
 294     return false;
 295 }
 296
 297 bool SbxDecimal::operator /= ( const SbxDecimal &r )
 298 {
 299     (void)r;
 300     return false;
 301 }
 302
 303 bool SbxDecimal::operator *= ( const SbxDecimal &r )
 304 {
 305     (void)r;
 306     return false;
 307 }
 308
 309 bool SbxDecimal::neg()
 310 {
 311     return false;
 312 }
 313
 314 bool SbxDecimal::isZero()
 315 {
 316     return false;
 317 }
 318
 319 SbxDecimal::CmpResult compare( const SbxDecimal &rLeft, const SbxDecimal &rRight )
 320 {
 321     (void)rLeft;
 322     (void)rRight;
 323     return (SbxDecimal::CmpResult)0;
 324 }
 325
 326 void SbxDecimal::setChar( sal_Unicode val )     { (void)val; }
 327 void SbxDecimal::setByte( sal_uInt8 val )           { (void)val; }
 328 void SbxDecimal::setShort( sal_Int16 val )          { (void)val; }
 329 void SbxDecimal::setLong( sal_Int32 val )           { (void)val; }
 330 void SbxDecimal::setUShort( sal_uInt16 val )        { (void)val; }
 331 void SbxDecimal::setULong( sal_uInt32 val )         { (void)val; }
 332 bool SbxDecimal::setSingle( float val )         { (void)val; return false; }
 333 bool SbxDecimal::setDouble( double val )        { (void)val; return false; }
 334 void SbxDecimal::setInt( int val )              { (void)val; }
 335 void SbxDecimal::setUInt( unsigned int val )    { (void)val; }
 336 bool SbxDecimal::setString( OUString* pOUString )    { (void)pOUString;  return false; }
 337
 338 bool SbxDecimal::getChar( sal_Unicode& rVal )   { (void)rVal; return false; }
 339 bool SbxDecimal::getShort( sal_Int16& rVal )        { (void)rVal; return false; }
 340 bool SbxDecimal::getLong( sal_Int32& rVal )         { (void)rVal; return false; }
 341 bool SbxDecimal::getUShort( sal_uInt16& rVal )      { (void)rVal; return false; }
 342 bool SbxDecimal::getULong( sal_uInt32& rVal )       { (void)rVal; return false; }
 343 bool SbxDecimal::getSingle( float& rVal )       { (void)rVal; return false; }
 344 bool SbxDecimal::getDouble( double& rVal )      { (void)rVal; return false; }
 345
 346 #endif
 347
 348 bool SbxDecimal::getString( OUString& rString )
 349 {
 350 #ifdef WIN32
 351     static LCID nLANGID = MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US );
 352
 353     bool bRet = false;
 354
 355     OLECHAR sz[100];
 356     BSTR aBStr = SysAllocString( sz );
 357     if( aBStr != NULL )
 358     {
 359         HRESULT hResult = VarBstrFromDec( &maDec, nLANGID, 0, &aBStr );
 360         bRet = ( hResult == S_OK );
 361         if( bRet )
 362         {
 363             // Convert delimiter
 364             sal_Unicode cDecimalSep;
 365             sal_Unicode cThousandSep;
 366             ImpGetIntntlSep( cDecimalSep, cThousandSep );
 367
 368             if( cDecimalSep != '.' || cThousandSep != ',' )
 369             {
 370                 sal_Unicode c;
 371                 int i = 0;
 372                 while( (c = aBStr[i]) != 0 )
 373                 {
 374                     if( c == '.' )
 375                         aBStr[i] = cDecimalSep;
 376                     else if( c == ',' )
 377                         aBStr[i] = cThousandSep;
 378                     i++;
 379                 }
 380             }
 381             rString = reinterpret_cast<const sal_Unicode*>(aBStr);
 382         }
 383
 384         SysFreeString( aBStr );
 385     }
 386     return bRet;
 387 #else
 388     (void)rString;
 389     return false;
 390 #endif
 391 }
 392
 393 SbxDecimal* ImpCreateDecimal( SbxValues* p )
 394 {
 395     if( !p )
 396         return NULL;
 397
 398     SbxDecimal*& rpDecimal = p->pDecimal;
 399     if( rpDecimal == NULL )
 400     {
 401         rpDecimal = new SbxDecimal();
 402         rpDecimal->addRef();
 403     }
 404     return rpDecimal;
 405 }
 406
 407 SbxDecimal* ImpGetDecimal( const SbxValues* p )
 408 {
 409     SbxValues aTmp;
 410     SbxDecimal* pnDecRes;
 411
 412     SbxDataType eType = p->eType;
 413     if( eType == SbxDECIMAL && p->pDecimal )
 414     {
 415         pnDecRes = new SbxDecimal( *p->pDecimal );
 416         pnDecRes->addRef();
 417         return pnDecRes;
 418     }
 419     pnDecRes = new SbxDecimal();
 420     pnDecRes->addRef();
 421
 422 start:
 423     switch( +eType )
 424     {
 425         case SbxNULL:
 426             SbxBase::SetError( SbxERR_CONVERSION );
 427         case SbxEMPTY:
 428             pnDecRes->setShort( 0 ); break;
 429         case SbxCHAR:
 430             pnDecRes->setChar( p->nChar ); break;
 431         case SbxBYTE:
 432             pnDecRes->setByte( p->nByte ); break;
 433         case SbxINTEGER:
 434         case SbxBOOL:
 435             pnDecRes->setInt( p->nInteger ); break;
 436         case SbxERROR:
 437         case SbxUSHORT:
 438             pnDecRes->setUShort( p->nUShort ); break;
 439         case SbxLONG:
 440             pnDecRes->setLong( p->nLong ); break;
 441         case SbxULONG:
 442             pnDecRes->setULong( p->nULong ); break;
 443         case SbxSINGLE:
 444             if( !pnDecRes->setSingle( p->nSingle ) )
 445                 SbxBase::SetError( SbxERR_OVERFLOW );
 446             break;
 447         case SbxCURRENCY:
 448             {
 449                 if( !pnDecRes->setDouble( ImpCurrencyToDouble( p->nInt64 ) ) )
 450                     SbxBase::SetError( SbxERR_OVERFLOW );
 451                 break;
 452             }
 453         case SbxSALINT64:
 454             {
 455                 if( !pnDecRes->setDouble( (double)p->nInt64 ) )
 456                     SbxBase::SetError( SbxERR_OVERFLOW );
 457                 break;
 458             }
 459         case SbxSALUINT64:
 460             {
 461                 if( !pnDecRes->setDouble( (double)p->uInt64 ) )
 462                     SbxBase::SetError( SbxERR_OVERFLOW );
 463                 break;
 464             }
 465         case SbxDATE:
 466         case SbxDOUBLE:
 467         {
 468             double dVal = p->nDouble;
 469             if( !pnDecRes->setDouble( dVal ) )
 470                 SbxBase::SetError( SbxERR_OVERFLOW );
 471             break;
 472         }
 473         case SbxLPSTR:
 474         case SbxSTRING:
 475         case SbxBYREF | SbxSTRING:
 476             if ( p->pOUString )
 477                 pnDecRes->setString( p->pOUString );
 478             break;
 479         case SbxOBJECT:
 480         {
 481             SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
 482             if( pVal )
 483                 pnDecRes->setDecimal( pVal->GetDecimal() );
 484             else
 485             {
 486                 SbxBase::SetError( SbxERR_NO_OBJECT );
 487                 pnDecRes->setShort( 0 );
 488             }
 489             break;
 490         }
 491
 492         case SbxBYREF | SbxCHAR:
 493             pnDecRes->setChar( *p->pChar ); break;
 494         case SbxBYREF | SbxBYTE:
 495             pnDecRes->setByte( *p->pByte ); break;
 496         case SbxBYREF | SbxINTEGER:
 497         case SbxBYREF | SbxBOOL:
 498             pnDecRes->setInt( *p->pInteger ); break;
 499         case SbxBYREF | SbxLONG:
 500             pnDecRes->setLong( *p->pLong ); break;
 501         case SbxBYREF | SbxULONG:
 502             pnDecRes->setULong( *p->pULong ); break;
 503         case SbxBYREF | SbxERROR:
 504         case SbxBYREF | SbxUSHORT:
 505             pnDecRes->setUShort( *p->pUShort ); break;
 506
 507         // from here on had to be tested
 508         case SbxBYREF | SbxSINGLE:
 509             aTmp.nSingle = *p->pSingle; goto ref;
 510         case SbxBYREF | SbxDATE:
 511         case SbxBYREF | SbxDOUBLE:
 512             aTmp.nDouble = *p->pDouble; goto ref;
 513         case SbxBYREF | SbxCURRENCY:
 514         case SbxBYREF | SbxSALINT64:
 515             aTmp.nInt64 = *p->pnInt64; goto ref;
 516         case SbxBYREF | SbxSALUINT64:
 517             aTmp.uInt64 = *p->puInt64; goto ref;
 518         ref:
 519             aTmp.eType = SbxDataType( p->eType & 0x0FFF );
 520             p = &aTmp; goto start;
 521
 522         default:
 523             SbxBase::SetError( SbxERR_CONVERSION ); pnDecRes->setShort( 0 );
 524     }
 525     return pnDecRes;
 526 }
 527
 528 void ImpPutDecimal( SbxValues* p, SbxDecimal* pDec )
 529 {
 530     if( !pDec )
 531         return;
 532
 533     SbxValues aTmp;
 534 start:
 535     switch( +p->eType )
 536     {
 537         // here had to be tested
 538         case SbxCHAR:
 539             aTmp.pChar = &p->nChar; goto direct;
 540         case SbxBYTE:
 541             aTmp.pByte = &p->nByte; goto direct;
 542         case SbxULONG:
 543             aTmp.pULong = &p->nULong; goto direct;
 544         case SbxERROR:
 545         case SbxUSHORT:
 546             aTmp.pUShort = &p->nUShort; goto direct;
 547         case SbxINTEGER:
 548         case SbxBOOL:
 549             aTmp.pInteger = &p->nInteger; goto direct;
 550         case SbxLONG:
 551             aTmp.pLong = &p->nLong; goto direct;
 552         case SbxCURRENCY:
 553         case SbxSALINT64:
 554             aTmp.pnInt64 = &p->nInt64; goto direct;
 555         case SbxSALUINT64:
 556             aTmp.puInt64 = &p->uInt64; goto direct;
 557
 558         direct:
 559             aTmp.eType = SbxDataType( p->eType | SbxBYREF );
 560             p = &aTmp; goto start;
 561
 562         // from here on no longer
 563         case SbxDECIMAL:
 564         case SbxBYREF | SbxDECIMAL:
 565         {
 566             if( pDec != p->pDecimal )
 567             {
 568                 releaseDecimalPtr( p->pDecimal );
 569                 p->pDecimal = pDec;
 570                 if( pDec )
 571                     pDec->addRef();
 572             }
 573             break;
 574         }
 575         case SbxSINGLE:
 576         {
 577             float f(0.0);
 578             pDec->getSingle( f );
 579             p->nSingle = f;
 580             break;
 581         }
 582         case SbxDATE:
 583         case SbxDOUBLE:
 584         {
 585             double d(0.0);
 586             pDec->getDouble( d );
 587             p->nDouble = d;
 588             break;
 589         }
 590
 591         case SbxLPSTR:
 592         case SbxSTRING:
 593         case SbxBYREF | SbxSTRING:
 594             if( !p->pOUString )
 595                 p->pOUString = new OUString;
 596             pDec->getString( *p->pOUString );
 597             break;
 598         case SbxOBJECT:
 599         {
 600             SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
 601             if( pVal )
 602                 pVal->PutDecimal( pDec );
 603             else
 604                 SbxBase::SetError( SbxERR_NO_OBJECT );
 605             break;
 606         }
 607
 608         case SbxBYREF | SbxCHAR:
 609             if( !pDec->getChar( *p->pChar ) )
 610             {
 611                 SbxBase::SetError( SbxERR_OVERFLOW );
 612                 *p->pChar = 0;
 613             }
 614             break;
 615         case SbxBYREF | SbxBYTE:
 616             if( !pDec->getChar( *p->pChar ) )
 617             {
 618                 SbxBase::SetError( SbxERR_OVERFLOW );
 619                 *p->pByte = 0;
 620             }
 621             break;
 622         case SbxBYREF | SbxINTEGER:
 623         case SbxBYREF | SbxBOOL:
 624             if( !pDec->getShort( *p->pInteger ) )
 625             {
 626                 SbxBase::SetError( SbxERR_OVERFLOW );
 627                 *p->pInteger = 0;
 628             }
 629             break;
 630         case SbxBYREF | SbxERROR:
 631         case SbxBYREF | SbxUSHORT:
 632             if( !pDec->getUShort( *p->pUShort ) )
 633             {
 634                 SbxBase::SetError( SbxERR_OVERFLOW );
 635                 *p->pUShort = 0;
 636             }
 637             break;
 638         case SbxBYREF | SbxLONG:
 639             if( !pDec->getLong( *p->pLong ) )
 640             {
 641                 SbxBase::SetError( SbxERR_OVERFLOW );
 642                 *p->pLong = 0;
 643             }
 644             break;
 645         case SbxBYREF | SbxULONG:
 646             if( !pDec->getULong( *p->pULong ) )
 647             {
 648                 SbxBase::SetError( SbxERR_OVERFLOW );
 649                 *p->pULong = 0;
 650             }
 651             break;
 652         case SbxBYREF | SbxCURRENCY:
 653             {
 654             double d(0.0);
 655             if( !pDec->getDouble( d ) )
 656                 SbxBase::SetError( SbxERR_OVERFLOW );
 657             *p->pnInt64 = ImpDoubleToCurrency( d );
 658             }
 659             break;
 660         case SbxBYREF | SbxSALINT64:
 661             {
 662             double d(0.0);
 663             if( !pDec->getDouble( d ) )
 664                 SbxBase::SetError( SbxERR_OVERFLOW );
 665             else
 666                 *p->pnInt64 = ImpDoubleToSalInt64( d );
 667             }
 668             break;
 669         case SbxBYREF | SbxSALUINT64:
 670             {
 671             double d(0.0);
 672             if( !pDec->getDouble( d ) )
 673                 SbxBase::SetError( SbxERR_OVERFLOW );
 674             else
 675                 *p->puInt64 = ImpDoubleToSalUInt64( d );
 676             }
 677             break;
 678         case SbxBYREF | SbxSINGLE:
 679             if( !pDec->getSingle( *p->pSingle ) )
 680             {
 681                 SbxBase::SetError( SbxERR_OVERFLOW );
 682                 *p->pSingle = 0;
 683             }
 684             break;
 685         case SbxBYREF | SbxDATE:
 686         case SbxBYREF | SbxDOUBLE:
 687             if( !pDec->getDouble( *p->pDouble ) )
 688             {
 689                 SbxBase::SetError( SbxERR_OVERFLOW );
 690                 *p->pDouble = 0;
 691             }
 692             break;
 693         default:
 694             SbxBase::SetError( SbxERR_CONVERSION );
 695     }
 696 }
 697
 698 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */