LCOV - code coverage report
Current view: top level - basic/source/sbx - sbxdec.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 3 206 1.5 %
Date: 2014-11-03 Functions: 1 35 2.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <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           0 : SbxDecimal::SbxDecimal( void )
      30             : {
      31           0 :     setInt( 0 );
      32           0 :     mnRefCount = 0;
      33           0 : }
      34             : 
      35           0 : SbxDecimal::SbxDecimal( const SbxDecimal& rDec )
      36             : {
      37             : #ifdef WIN32
      38             :     maDec = rDec.maDec;
      39             : #else
      40             :     (void)rDec;
      41             : #endif
      42           0 :     mnRefCount = 0;
      43           0 : }
      44             : 
      45           0 : 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           0 :     mnRefCount = 0;
      58           0 : }
      59             : 
      60           0 : 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           0 : }
      73             : 
      74           0 : SbxDecimal::~SbxDecimal()
      75             : {
      76           0 : }
      77             : 
      78         916 : void releaseDecimalPtr( SbxDecimal*& rpDecimal )
      79             : {
      80         916 :     if( rpDecimal )
      81             :     {
      82           0 :         rpDecimal->mnRefCount--;
      83           0 :         if( rpDecimal->mnRefCount == 0 )
      84             :         {
      85           0 :             delete rpDecimal;
      86           0 :             rpDecimal = NULL;
      87             :         }
      88             :     }
      89         916 : }
      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( void )
     122             : {
     123             :     HRESULT hResult = VarDecNeg( &maDec, &maDec );
     124             :     bool bRet = ( hResult == S_OK );
     125             :     return bRet;
     126             : }
     127             : 
     128             : bool SbxDecimal::isZero( void )
     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           0 : bool SbxDecimal::operator -= ( const SbxDecimal &r )
     286             : {
     287             :     (void)r;
     288           0 :     return false;
     289             : }
     290             : 
     291           0 : bool SbxDecimal::operator += ( const SbxDecimal &r )
     292             : {
     293             :     (void)r;
     294           0 :     return false;
     295             : }
     296             : 
     297           0 : bool SbxDecimal::operator /= ( const SbxDecimal &r )
     298             : {
     299             :     (void)r;
     300           0 :     return false;
     301             : }
     302             : 
     303           0 : bool SbxDecimal::operator *= ( const SbxDecimal &r )
     304             : {
     305             :     (void)r;
     306           0 :     return false;
     307             : }
     308             : 
     309           0 : bool SbxDecimal::neg( void )
     310             : {
     311           0 :     return false;
     312             : }
     313             : 
     314           0 : bool SbxDecimal::isZero( void )
     315             : {
     316           0 :     return false;
     317             : }
     318             : 
     319           0 : SbxDecimal::CmpResult compare( const SbxDecimal &rLeft, const SbxDecimal &rRight )
     320             : {
     321             :     (void)rLeft;
     322             :     (void)rRight;
     323           0 :     return (SbxDecimal::CmpResult)0;
     324             : }
     325             : 
     326           0 : void SbxDecimal::setChar( sal_Unicode val )     { (void)val; }
     327           0 : void SbxDecimal::setByte( sal_uInt8 val )           { (void)val; }
     328           0 : void SbxDecimal::setShort( sal_Int16 val )          { (void)val; }
     329           0 : void SbxDecimal::setLong( sal_Int32 val )           { (void)val; }
     330           0 : void SbxDecimal::setUShort( sal_uInt16 val )        { (void)val; }
     331           0 : void SbxDecimal::setULong( sal_uInt32 val )         { (void)val; }
     332           0 : bool SbxDecimal::setSingle( float val )         { (void)val; return false; }
     333           0 : bool SbxDecimal::setDouble( double val )        { (void)val; return false; }
     334           0 : void SbxDecimal::setInt( int val )              { (void)val; }
     335           0 : void SbxDecimal::setUInt( unsigned int val )    { (void)val; }
     336           0 : bool SbxDecimal::setString( OUString* pOUString )    { (void)pOUString;  return false; }
     337             : 
     338           0 : bool SbxDecimal::getChar( sal_Unicode& rVal )   { (void)rVal; return false; }
     339           0 : bool SbxDecimal::getShort( sal_Int16& rVal )        { (void)rVal; return false; }
     340           0 : bool SbxDecimal::getLong( sal_Int32& rVal )         { (void)rVal; return false; }
     341           0 : bool SbxDecimal::getUShort( sal_uInt16& rVal )      { (void)rVal; return false; }
     342           0 : bool SbxDecimal::getULong( sal_uInt32& rVal )       { (void)rVal; return false; }
     343           0 : bool SbxDecimal::getSingle( float& rVal )       { (void)rVal; return false; }
     344           0 : bool SbxDecimal::getDouble( double& rVal )      { (void)rVal; return false; }
     345             : 
     346             : #endif
     347             : 
     348           0 : 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           0 :     return false;
     390             : #endif
     391             : }
     392             : 
     393           0 : SbxDecimal* ImpCreateDecimal( SbxValues* p )
     394             : {
     395           0 :     if( !p )
     396           0 :         return NULL;
     397             : 
     398           0 :     SbxDecimal*& rpDecimal = p->pDecimal;
     399           0 :     if( rpDecimal == NULL )
     400             :     {
     401           0 :         rpDecimal = new SbxDecimal();
     402           0 :         rpDecimal->addRef();
     403             :     }
     404           0 :     return rpDecimal;
     405             : }
     406             : 
     407           0 : SbxDecimal* ImpGetDecimal( const SbxValues* p )
     408             : {
     409           0 :     SbxValues aTmp;
     410             :     SbxDecimal* pnDecRes;
     411             : 
     412           0 :     SbxDataType eType = p->eType;
     413           0 :     if( eType == SbxDECIMAL && p->pDecimal )
     414             :     {
     415           0 :         pnDecRes = new SbxDecimal( *p->pDecimal );
     416           0 :         pnDecRes->addRef();
     417           0 :         return pnDecRes;
     418             :     }
     419           0 :     pnDecRes = new SbxDecimal();
     420           0 :     pnDecRes->addRef();
     421             : 
     422             : start:
     423           0 :     switch( +eType )
     424             :     {
     425             :         case SbxNULL:
     426           0 :             SbxBase::SetError( SbxERR_CONVERSION );
     427             :         case SbxEMPTY:
     428           0 :             pnDecRes->setShort( 0 ); break;
     429             :         case SbxCHAR:
     430           0 :             pnDecRes->setChar( p->nChar ); break;
     431             :         case SbxBYTE:
     432           0 :             pnDecRes->setByte( p->nByte ); break;
     433             :         case SbxINTEGER:
     434             :         case SbxBOOL:
     435           0 :             pnDecRes->setInt( p->nInteger ); break;
     436             :         case SbxERROR:
     437             :         case SbxUSHORT:
     438           0 :             pnDecRes->setUShort( p->nUShort ); break;
     439             :         case SbxLONG:
     440           0 :             pnDecRes->setLong( p->nLong ); break;
     441             :         case SbxULONG:
     442           0 :             pnDecRes->setULong( p->nULong ); break;
     443             :         case SbxSINGLE:
     444           0 :             if( !pnDecRes->setSingle( p->nSingle ) )
     445           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     446           0 :             break;
     447             :         case SbxCURRENCY:
     448             :             {
     449           0 :                 if( !pnDecRes->setDouble( ImpCurrencyToDouble( p->nInt64 ) ) )
     450           0 :                     SbxBase::SetError( SbxERR_OVERFLOW );
     451           0 :                 break;
     452             :             }
     453             :         case SbxSALINT64:
     454             :             {
     455           0 :                 if( !pnDecRes->setDouble( (double)p->nInt64 ) )
     456           0 :                     SbxBase::SetError( SbxERR_OVERFLOW );
     457           0 :                 break;
     458             :             }
     459             :         case SbxSALUINT64:
     460             :             {
     461           0 :                 if( !pnDecRes->setDouble( (double)p->uInt64 ) )
     462           0 :                     SbxBase::SetError( SbxERR_OVERFLOW );
     463           0 :                 break;
     464             :             }
     465             :         case SbxDATE:
     466             :         case SbxDOUBLE:
     467             :         {
     468           0 :             double dVal = p->nDouble;
     469           0 :             if( !pnDecRes->setDouble( dVal ) )
     470           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     471           0 :             break;
     472             :         }
     473             :         case SbxLPSTR:
     474             :         case SbxSTRING:
     475             :         case SbxBYREF | SbxSTRING:
     476           0 :             if ( p->pOUString )
     477           0 :                 pnDecRes->setString( p->pOUString );
     478           0 :             break;
     479             :         case SbxOBJECT:
     480             :         {
     481           0 :             SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
     482           0 :             if( pVal )
     483           0 :                 pnDecRes->setDecimal( pVal->GetDecimal() );
     484             :             else
     485             :             {
     486           0 :                 SbxBase::SetError( SbxERR_NO_OBJECT );
     487           0 :                 pnDecRes->setShort( 0 );
     488             :             }
     489           0 :             break;
     490             :         }
     491             : 
     492             :         case SbxBYREF | SbxCHAR:
     493           0 :             pnDecRes->setChar( *p->pChar ); break;
     494             :         case SbxBYREF | SbxBYTE:
     495           0 :             pnDecRes->setByte( *p->pByte ); break;
     496             :         case SbxBYREF | SbxINTEGER:
     497             :         case SbxBYREF | SbxBOOL:
     498           0 :             pnDecRes->setInt( *p->pInteger ); break;
     499             :         case SbxBYREF | SbxLONG:
     500           0 :             pnDecRes->setLong( *p->pLong ); break;
     501             :         case SbxBYREF | SbxULONG:
     502           0 :             pnDecRes->setULong( *p->pULong ); break;
     503             :         case SbxBYREF | SbxERROR:
     504             :         case SbxBYREF | SbxUSHORT:
     505           0 :             pnDecRes->setUShort( *p->pUShort ); break;
     506             : 
     507             :         // from here on had to be tested
     508             :         case SbxBYREF | SbxSINGLE:
     509           0 :             aTmp.nSingle = *p->pSingle; goto ref;
     510             :         case SbxBYREF | SbxDATE:
     511             :         case SbxBYREF | SbxDOUBLE:
     512           0 :             aTmp.nDouble = *p->pDouble; goto ref;
     513             :         case SbxBYREF | SbxCURRENCY:
     514             :         case SbxBYREF | SbxSALINT64:
     515           0 :             aTmp.nInt64 = *p->pnInt64; goto ref;
     516             :         case SbxBYREF | SbxSALUINT64:
     517           0 :             aTmp.uInt64 = *p->puInt64; goto ref;
     518             :         ref:
     519           0 :             aTmp.eType = SbxDataType( p->eType & 0x0FFF );
     520           0 :             p = &aTmp; goto start;
     521             : 
     522             :         default:
     523           0 :             SbxBase::SetError( SbxERR_CONVERSION ); pnDecRes->setShort( 0 );
     524             :     }
     525           0 :     return pnDecRes;
     526             : }
     527             : 
     528           0 : void ImpPutDecimal( SbxValues* p, SbxDecimal* pDec )
     529             : {
     530           0 :     if( !pDec )
     531           0 :         return;
     532             : 
     533           0 :     SbxValues aTmp;
     534             : start:
     535           0 :     switch( +p->eType )
     536             :     {
     537             :         // here had to be tested
     538             :         case SbxCHAR:
     539           0 :             aTmp.pChar = &p->nChar; goto direct;
     540             :         case SbxBYTE:
     541           0 :             aTmp.pByte = &p->nByte; goto direct;
     542             :         case SbxULONG:
     543           0 :             aTmp.pULong = &p->nULong; goto direct;
     544             :         case SbxERROR:
     545             :         case SbxUSHORT:
     546           0 :             aTmp.pUShort = &p->nUShort; goto direct;
     547             :         case SbxINTEGER:
     548             :         case SbxBOOL:
     549           0 :             aTmp.pInteger = &p->nInteger; goto direct;
     550             :         case SbxLONG:
     551           0 :             aTmp.pLong = &p->nLong; goto direct;
     552             :         case SbxCURRENCY:
     553             :         case SbxSALINT64:
     554           0 :             aTmp.pnInt64 = &p->nInt64; goto direct;
     555             :         case SbxSALUINT64:
     556           0 :             aTmp.puInt64 = &p->uInt64; goto direct;
     557             : 
     558             :         direct:
     559           0 :             aTmp.eType = SbxDataType( p->eType | SbxBYREF );
     560           0 :             p = &aTmp; goto start;
     561             : 
     562             :         // from here on no longer
     563             :         case SbxDECIMAL:
     564             :         case SbxBYREF | SbxDECIMAL:
     565             :         {
     566           0 :             if( pDec != p->pDecimal )
     567             :             {
     568           0 :                 releaseDecimalPtr( p->pDecimal );
     569           0 :                 p->pDecimal = pDec;
     570           0 :                 if( pDec )
     571           0 :                     pDec->addRef();
     572             :             }
     573           0 :             break;
     574             :         }
     575             :         case SbxSINGLE:
     576             :         {
     577           0 :             float f(0.0);
     578           0 :             pDec->getSingle( f );
     579           0 :             p->nSingle = f;
     580           0 :             break;
     581             :         }
     582             :         case SbxDATE:
     583             :         case SbxDOUBLE:
     584             :         {
     585           0 :             double d(0.0);
     586           0 :             pDec->getDouble( d );
     587           0 :             p->nDouble = d;
     588           0 :             break;
     589             :         }
     590             : 
     591             :         case SbxLPSTR:
     592             :         case SbxSTRING:
     593             :         case SbxBYREF | SbxSTRING:
     594           0 :             if( !p->pOUString )
     595           0 :                 p->pOUString = new OUString;
     596           0 :             pDec->getString( *p->pOUString );
     597           0 :             break;
     598             :         case SbxOBJECT:
     599             :         {
     600           0 :             SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
     601           0 :             if( pVal )
     602           0 :                 pVal->PutDecimal( pDec );
     603             :             else
     604           0 :                 SbxBase::SetError( SbxERR_NO_OBJECT );
     605           0 :             break;
     606             :         }
     607             : 
     608             :         case SbxBYREF | SbxCHAR:
     609           0 :             if( !pDec->getChar( *p->pChar ) )
     610             :             {
     611           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     612           0 :                 *p->pChar = 0;
     613             :             }
     614           0 :             break;
     615             :         case SbxBYREF | SbxBYTE:
     616           0 :             if( !pDec->getChar( *p->pChar ) )
     617             :             {
     618           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     619           0 :                 *p->pByte = 0;
     620             :             }
     621           0 :             break;
     622             :         case SbxBYREF | SbxINTEGER:
     623             :         case SbxBYREF | SbxBOOL:
     624           0 :             if( !pDec->getShort( *p->pInteger ) )
     625             :             {
     626           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     627           0 :                 *p->pInteger = 0;
     628             :             }
     629           0 :             break;
     630             :         case SbxBYREF | SbxERROR:
     631             :         case SbxBYREF | SbxUSHORT:
     632           0 :             if( !pDec->getUShort( *p->pUShort ) )
     633             :             {
     634           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     635           0 :                 *p->pUShort = 0;
     636             :             }
     637           0 :             break;
     638             :         case SbxBYREF | SbxLONG:
     639           0 :             if( !pDec->getLong( *p->pLong ) )
     640             :             {
     641           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     642           0 :                 *p->pLong = 0;
     643             :             }
     644           0 :             break;
     645             :         case SbxBYREF | SbxULONG:
     646           0 :             if( !pDec->getULong( *p->pULong ) )
     647             :             {
     648           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     649           0 :                 *p->pULong = 0;
     650             :             }
     651           0 :             break;
     652             :         case SbxBYREF | SbxCURRENCY:
     653             :             {
     654           0 :             double d(0.0);
     655           0 :             if( !pDec->getDouble( d ) )
     656           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     657           0 :             *p->pnInt64 = ImpDoubleToCurrency( d );
     658             :             }
     659           0 :             break;
     660             :         case SbxBYREF | SbxSALINT64:
     661             :             {
     662           0 :             double d(0.0);
     663           0 :             if( !pDec->getDouble( d ) )
     664           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     665             :             else
     666           0 :                 *p->pnInt64 = ImpDoubleToSalInt64( d );
     667             :             }
     668           0 :             break;
     669             :         case SbxBYREF | SbxSALUINT64:
     670             :             {
     671           0 :             double d(0.0);
     672           0 :             if( !pDec->getDouble( d ) )
     673           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     674             :             else
     675           0 :                 *p->puInt64 = ImpDoubleToSalUInt64( d );
     676             :             }
     677           0 :             break;
     678             :         case SbxBYREF | SbxSINGLE:
     679           0 :             if( !pDec->getSingle( *p->pSingle ) )
     680             :             {
     681           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     682           0 :                 *p->pSingle = 0;
     683             :             }
     684           0 :             break;
     685             :         case SbxBYREF | SbxDATE:
     686             :         case SbxBYREF | SbxDOUBLE:
     687           0 :             if( !pDec->getDouble( *p->pDouble ) )
     688             :             {
     689           0 :                 SbxBase::SetError( SbxERR_OVERFLOW );
     690           0 :                 *p->pDouble = 0;
     691             :             }
     692           0 :             break;
     693             :         default:
     694           0 :             SbxBase::SetError( SbxERR_CONVERSION );
     695             :     }
     696             : }
     697             : 
     698             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10