basic: String -> OUString

Change-Id: I42479b4bade5111e38d69f04c889c166f340d5ba

1 files changed, 338 insertions, 279 deletions

diff --git a/basic/source/sbx/sbxdate.cxx b/basic/source/sbx/sbxdate.cxx
index 7c78518ffcf8..cc6aedc5cb04 100644
--- a/basic/source/sbx/sbxdate.cxx
+++ b/basic/source/sbx/sbxdate.cxx
@@ -31,143 +31,175 @@
 double ImpGetDate( const SbxValues* p )
 {
     double nRes;
+    SbxValue* pVal;
+
     switch( +p->eType )
     {
-        case SbxNULL:
-            SbxBase::SetError( SbxERR_CONVERSION );
-        case SbxEMPTY:
-            nRes = 0; break;
-        case SbxCHAR:
-            nRes = p->nChar; break;
-        case SbxBYTE:
-            nRes = p->nByte; break;
-        case SbxINTEGER:
-        case SbxBOOL:
-            nRes = p->nInteger; break;
-        case SbxERROR:
-        case SbxUSHORT:
-            nRes = p->nUShort; break;
-        case SbxLONG:
-            nRes = (double) p->nLong; break;
-        case SbxULONG:
-            nRes = (double) p->nULong; break;
-        case SbxSINGLE:
-            nRes = p->nSingle; break;
-        case SbxDATE:
-        case SbxDOUBLE:
-            nRes = p->nDouble; break;
-        case SbxCURRENCY:
-            nRes = ImpCurrencyToDouble( p->nInt64 ); break;
-        case SbxSALINT64:
-            nRes = static_cast< double >(p->nInt64); break;
-        case SbxSALUINT64:
-            nRes = ImpSalUInt64ToDouble( p->uInt64 ); break;
-        case SbxDECIMAL:
-        case SbxBYREF | SbxDECIMAL:
-            if( p->pDecimal )
-                p->pDecimal->getDouble( nRes );
-            else
-                nRes = 0.0;
-            break;
-        case SbxBYREF | SbxSTRING:
-        case SbxSTRING:
-        case SbxLPSTR:
-            if( !p->pOUString )
-                nRes = 0;
-            else
-            {
-                LanguageType eLangType = GetpApp()->GetSettings().GetLanguage();
-
-                SvNumberFormatter* pFormatter;
-                com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >
-                    xFactory = comphelper::getProcessServiceFactory();
-                pFormatter = new SvNumberFormatter( xFactory, eLangType );
+    case SbxNULL:
+        SbxBase::SetError( SbxERR_CONVERSION );
+    case SbxEMPTY:
+        nRes = 0;
+        break;
+    case SbxCHAR:
+        nRes = p->nChar;
+        break;
+    case SbxBYTE:
+        nRes = p->nByte;
+        break;
+    case SbxINTEGER:
+    case SbxBOOL:
+        nRes = p->nInteger;
+        break;
+    case SbxERROR:
+    case SbxUSHORT:
+        nRes = p->nUShort;
+        break;
+    case SbxLONG:
+        nRes = (double) p->nLong;
+        break;
+    case SbxULONG:
+        nRes = (double) p->nULong;
+        break;
+    case SbxSINGLE:
+        nRes = p->nSingle;
+        break;
+    case SbxDATE:
+    case SbxDOUBLE:
+        nRes = p->nDouble;
+        break;
+    case SbxCURRENCY:
+        nRes = ImpCurrencyToDouble( p->nInt64 );
+        break;
+    case SbxSALINT64:
+        nRes = static_cast< double >(p->nInt64);
+        break;
+    case SbxSALUINT64:
+        nRes = ImpSalUInt64ToDouble( p->uInt64 );
+        break;
+    case SbxDECIMAL:
+    case SbxBYREF | SbxDECIMAL:
+        if( p->pDecimal )
+        {
+            p->pDecimal->getDouble( nRes );
+        }
+        else
+        {
+            nRes = 0.0;
+        }
+        break;
+    case SbxBYREF | SbxSTRING:
+    case SbxSTRING:
+    case SbxLPSTR:
+        if( !p->pOUString )
+        {
+            nRes = 0;
+        }
+        else
+        {
+            LanguageType eLangType = GetpApp()->GetSettings().GetLanguage();
 
-                sal_uInt32 nIndex;
-                xub_StrLen nCheckPos = 0;
-                short nType = 127;
+            SvNumberFormatter* pFormatter;
+            com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >
+                xFactory = comphelper::getProcessServiceFactory();
+            pFormatter = new SvNumberFormatter( xFactory, eLangType );
 
-                // Default templates of the formatter have only two-digit
-                // date. Therefore register an own format.
+            sal_uInt32 nIndex;
+            sal_uInt16 nCheckPos = 0;
+            short nType = 127;
 
-                // HACK, because the number formatter in PutandConvertEntry replace the wildcard
-                // for month, day, year not according to the configuration.
-                // Problem: Print Year(Date) under Engl. OS
-                // quod vide basic\source\runtime\runtime.cxx
+            // Default templates of the formatter have only two-digit
+            // date. Therefore register an own format.
 
-                SvtSysLocale aSysLocale;
-                DateFormat eDate = aSysLocale.GetLocaleData().getDateFormat();
-                String aDateStr;
-                switch( eDate )
-                {
-                    case MDY: aDateStr.AssignAscii( "MM.TT.JJJJ" ); break;
-                    case DMY: aDateStr.AssignAscii( "TT.MM.JJJJ" ); break;
-                    case YMD: aDateStr.AssignAscii( "JJJJ.MM.TT" ); break;
-                    default:  aDateStr.AssignAscii( "MM.TT.JJJJ" );
-                }
+            // HACK, because the number formatter in PutandConvertEntry replace the wildcard
+            // for month, day, year not according to the configuration.
+            // Problem: Print Year(Date) under Engl. OS
+            // quod vide basic\source\runtime\runtime.cxx
 
-                String aStr( aDateStr );
-                aStr.AppendAscii( " HH:MM:SS" );
+            SvtSysLocale aSysLocale;
+            DateFormat eDate = aSysLocale.GetLocaleData().getDateFormat();
+            OUString aDateStr;
+            switch( eDate )
+            {
+            case MDY: aDateStr = "MM.TT.JJJJ"; break;
+            case DMY: aDateStr = "TT.MM.JJJJ"; break;
+            case YMD: aDateStr = "JJJJ.MM.TT"; break;
+            default:  aDateStr = "MM.TT.JJJJ";
+            }
 
-                pFormatter->PutandConvertEntry( aStr, nCheckPos,    nType,
-                    nIndex, LANGUAGE_GERMAN, eLangType );
-                sal_Bool bSuccess = pFormatter->IsNumberFormat( *p->pOUString, nIndex, nRes );
-                if ( bSuccess )
-                {
-                    short nType_ = pFormatter->GetType( nIndex );
-                    if(!(nType_ & ( NUMBERFORMAT_DATETIME | NUMBERFORMAT_DATE |
-                                    NUMBERFORMAT_TIME | NUMBERFORMAT_DEFINED )))
-                        bSuccess = sal_False;
-                }
+            OUString aStr( aDateStr );
+            aStr += " HH:MM:SS";
 
-                if ( !bSuccess )
+            pFormatter->PutandConvertEntry( aStr, nCheckPos, nType,
+                                            nIndex, LANGUAGE_GERMAN, eLangType );
+            sal_Bool bSuccess = pFormatter->IsNumberFormat( *p->pOUString, nIndex, nRes );
+            if ( bSuccess )
+            {
+                short nType_ = pFormatter->GetType( nIndex );
+                if(!(nType_ & ( NUMBERFORMAT_DATETIME | NUMBERFORMAT_DATE |
+                                NUMBERFORMAT_TIME | NUMBERFORMAT_DEFINED )))
                 {
-                    SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0;
+                    bSuccess = sal_False;
                 }
-
-                delete pFormatter;
             }
-            break;
-        case SbxOBJECT:
-        {
-            SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
-            if( pVal )
-                nRes = pVal->GetDate();
-            else
+
+            if ( !bSuccess )
             {
-                SbxBase::SetError( SbxERR_NO_OBJECT ); nRes = 0;
+                SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0;
             }
-            break;
-        }
-
-        case SbxBYREF | SbxCHAR:
-            nRes = *p->pChar; break;
-        case SbxBYREF | SbxBYTE:
-            nRes = *p->pByte; break;
-        case SbxBYREF | SbxINTEGER:
-        case SbxBYREF | SbxBOOL:
-            nRes = *p->pInteger; break;
-        case SbxBYREF | SbxLONG:
-            nRes = *p->pLong; break;
-        case SbxBYREF | SbxULONG:
-            nRes = *p->pULong; break;
-        case SbxBYREF | SbxERROR:
-        case SbxBYREF | SbxUSHORT:
-            nRes = *p->pUShort; break;
-        case SbxBYREF | SbxSINGLE:
-            nRes = *p->pSingle; break;
-        case SbxBYREF | SbxDATE:
-        case SbxBYREF | SbxDOUBLE:
-            nRes = *p->pDouble; break;
-        case SbxBYREF | SbxCURRENCY:
-            nRes = ImpCurrencyToDouble( *p->pnInt64 ); break;
-        case SbxBYREF | SbxSALINT64:
-            nRes = static_cast< double >(*p->pnInt64); break;
-        case SbxBYREF | SbxSALUINT64:
-            nRes = ImpSalUInt64ToDouble( *p->puInt64 ); break;
 
-        default:
-            SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0;
+            delete pFormatter;
+        }
+        break;
+    case SbxOBJECT:
+        pVal = PTR_CAST(SbxValue,p->pObj);
+        if( pVal )
+        {
+            nRes = pVal->GetDate();
+        }
+        else
+        {
+            SbxBase::SetError( SbxERR_NO_OBJECT ); nRes = 0;
+        }
+        break;
+    case SbxBYREF | SbxCHAR:
+        nRes = *p->pChar;
+        break;
+    case SbxBYREF | SbxBYTE:
+        nRes = *p->pByte;
+        break;
+    case SbxBYREF | SbxINTEGER:
+    case SbxBYREF | SbxBOOL:
+        nRes = *p->pInteger;
+        break;
+    case SbxBYREF | SbxLONG:
+        nRes = *p->pLong;
+        break;
+    case SbxBYREF | SbxULONG:
+        nRes = *p->pULong;
+        break;
+    case SbxBYREF | SbxERROR:
+    case SbxBYREF | SbxUSHORT:
+        nRes = *p->pUShort;
+        break;
+    case SbxBYREF | SbxSINGLE:
+        nRes = *p->pSingle;
+        break;
+    case SbxBYREF | SbxDATE:
+    case SbxBYREF | SbxDOUBLE:
+        nRes = *p->pDouble;
+        break;
+    case SbxBYREF | SbxCURRENCY:
+        nRes = ImpCurrencyToDouble( *p->pnInt64 );
+        break;
+    case SbxBYREF | SbxSALINT64:
+        nRes = static_cast< double >(*p->pnInt64);
+        break;
+    case SbxBYREF | SbxSALUINT64:
+        nRes = ImpSalUInt64ToDouble( *p->puInt64 );
+        break;
+    default:
+        SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0;
+        break;
     }
     return nRes;
 }
@@ -175,54 +207,67 @@ double ImpGetDate( const SbxValues* p )
 void ImpPutDate( SbxValues* p, double n )
 {
     SbxValues aTmp;
+    SbxDecimal* pDec;
+    SbxValue* pVal;
 
 start:
     switch( +p->eType )
     {
-        case SbxDATE:
-        case SbxDOUBLE:
-            p->nDouble = n; break;
-
+    case SbxDATE:
+    case SbxDOUBLE:
+        p->nDouble = n;
+        break;
         // from here will be tested
-        case SbxCHAR:
-            aTmp.pChar = &p->nChar; goto direct;
-        case SbxBYTE:
-            aTmp.pByte = &p->nByte; goto direct;
-        case SbxINTEGER:
-        case SbxBOOL:
-            aTmp.pInteger = &p->nInteger; goto direct;
-        case SbxLONG:
-            aTmp.pLong = &p->nLong; goto direct;
-        case SbxULONG:
-            aTmp.pULong = &p->nULong; goto direct;
-        case SbxERROR:
-        case SbxUSHORT:
-            aTmp.pUShort = &p->nUShort; goto direct;
-        case SbxSINGLE:
-            aTmp.pSingle = &p->nSingle; goto direct;
-        case SbxCURRENCY:
-        case SbxSALINT64:
-            aTmp.pnInt64 = &p->nInt64; goto direct;
-        case SbxSALUINT64:
-            aTmp.puInt64 = &p->uInt64; goto direct;
-        case SbxDECIMAL:
-        case SbxBYREF | SbxDECIMAL:
-            {
-            SbxDecimal* pDec = ImpCreateDecimal( p );
-            if( !pDec->setDouble( n ) )
-                SbxBase::SetError( SbxERR_OVERFLOW );
-            break;
-            }
-        direct:
-            aTmp.eType = SbxDataType( p->eType | SbxBYREF );
-            p = &aTmp; goto start;
+    case SbxCHAR:
+        aTmp.pChar = &p->nChar;
+        goto direct;
+    case SbxBYTE:
+        aTmp.pByte = &p->nByte;
+        goto direct;
+    case SbxINTEGER:
+    case SbxBOOL:
+        aTmp.pInteger = &p->nInteger;
+        goto direct;
+    case SbxLONG:
+        aTmp.pLong = &p->nLong;
+        goto direct;
+    case SbxULONG:
+        aTmp.pULong = &p->nULong;
+        goto direct;
+    case SbxERROR:
+    case SbxUSHORT:
+        aTmp.pUShort = &p->nUShort;
+        goto direct;
+    case SbxSINGLE:
+        aTmp.pSingle = &p->nSingle;
+        goto direct;
+    case SbxCURRENCY:
+    case SbxSALINT64:
+        aTmp.pnInt64 = &p->nInt64;
+        goto direct;
+    case SbxSALUINT64:
+        aTmp.puInt64 = &p->uInt64;
+        goto direct;
+    case SbxDECIMAL:
+    case SbxBYREF | SbxDECIMAL:
+        pDec = ImpCreateDecimal( p );
+        if( !pDec->setDouble( n ) )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW );
+        }
+        break;
+    direct:
+        aTmp.eType = SbxDataType( p->eType | SbxBYREF );
+        p = &aTmp; goto start;
 
-        case SbxBYREF | SbxSTRING:
-        case SbxSTRING:
-        case SbxLPSTR:
+    case SbxBYREF | SbxSTRING:
+    case SbxSTRING:
+    case SbxLPSTR:
         {
             if( !p->pOUString )
-                p->pOUString = new ::rtl::OUString;
+            {
+                p->pOUString = new OUString;
+            }
             Color* pColor;
 
             LanguageType eLangType = GetpApp()->GetSettings().GetLanguage();
@@ -232,12 +277,12 @@ start:
             pFormatter = new SvNumberFormatter( xFactory, eLangType );
 
             sal_uInt32 nIndex;
-            xub_StrLen nCheckPos = 0;
+            sal_uInt16 nCheckPos = 0;
             short nType;
 
             SvtSysLocale aSysLocale;
             DateFormat eDate = aSysLocale.GetLocaleData().getDateFormat();
-            String aStr;
+            OUString aStr;
             // if the whole-number part is 0, we want no year!
             if( n <= -1.0 || n >= 1.0 )
             {
@@ -246,139 +291,153 @@ start:
                 {
                     switch( eDate )
                     {
-                        case MDY: aStr.AssignAscii( "MM.TT.JJJJ" ); break;
-                        case DMY: aStr.AssignAscii( "TT.MM.JJJJ" ); break;
-                        case YMD: aStr.AssignAscii( "JJJJ.MM.TT" ); break;
-                        default:  aStr.AssignAscii( "MM.TT.JJJJ" );
+                    case MDY: aStr = "MM.TT.JJJJ"; break;
+                    case DMY: aStr = "TT.MM.JJJJ"; break;
+                    case YMD: aStr = "JJJJ.MM.TT"; break;
+                    default:  aStr = "MM.TT.JJJJ";
                     }
                 }
                 else
                 {
                     switch( eDate )
                     {
-                        case MDY: aStr.AssignAscii( "MM.TT.JJJJ HH:MM:SS" ); break;
-                        case DMY: aStr.AssignAscii( "TT.MM.JJJJ HH:MM:SS" ); break;
-                        case YMD: aStr.AssignAscii( "JJJJ.MM.TT HH:MM:SS" ); break;
-                        default:  aStr.AssignAscii( "MM.TT.JJJJ HH:MM:SS" );
+                    case MDY: aStr = "MM.TT.JJJJ HH:MM:SS"; break;
+                    case DMY: aStr = "TT.MM.JJJJ HH:MM:SS"; break;
+                    case YMD: aStr = "JJJJ.MM.TT HH:MM:SS"; break;
+                    default:  aStr = "MM.TT.JJJJ HH:MM:SS";
                     }
                 }
             }
             else
-                aStr.AppendAscii( "HH:MM:SS" );
-
+            {
+                aStr = "HH:MM:SS";
+            }
             pFormatter->PutandConvertEntry( aStr,
-                nCheckPos,
-                nType,
-                nIndex,
-                LANGUAGE_GERMAN,
-                eLangType );
-            String aTmpString;
+                                            nCheckPos,
+                                            nType,
+                                            nIndex,
+                                            LANGUAGE_GERMAN,
+                                            eLangType );
+            OUString aTmpString;
             pFormatter->GetOutputString( n, nIndex, aTmpString, &pColor );
             *p->pOUString = aTmpString;
             delete pFormatter;
             break;
         }
-        case SbxOBJECT:
+    case SbxOBJECT:
+        pVal = PTR_CAST(SbxValue,p->pObj);
+        if( pVal )
         {
-            SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
-            if( pVal )
-                pVal->PutDate( n );
-            else
-                SbxBase::SetError( SbxERR_NO_OBJECT );
-            break;
+            pVal->PutDate( n );
         }
-        case SbxBYREF | SbxCHAR:
-            if( n > SbxMAXCHAR )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXCHAR;
-            }
-            else if( n < SbxMINCHAR )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCHAR;
-            }
-            *p->pChar = (sal_Unicode) n; break;
-        case SbxBYREF | SbxBYTE:
-            if( n > SbxMAXBYTE )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXBYTE;
-            }
-            else if( n < 0 )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
-            }
-            *p->pByte = (sal_uInt8) n; break;
-        case SbxBYREF | SbxINTEGER:
-        case SbxBYREF | SbxBOOL:
-            if( n > SbxMAXINT )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXINT;
-            }
-            else if( n < SbxMININT )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMININT;
-            }
-            *p->pInteger = (sal_Int16) n; break;
-        case SbxBYREF | SbxERROR:
-        case SbxBYREF | SbxUSHORT:
-            if( n > SbxMAXUINT )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXUINT;
-            }
-            else if( n < 0 )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
-            }
-            *p->pUShort = (sal_uInt16) n; break;
-        case SbxBYREF | SbxLONG:
-            if( n > SbxMAXLNG )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXLNG;
-            }
-            else if( n < SbxMINLNG )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINLNG;
-            }
-            *p->pLong = (sal_Int32) n; break;
-        case SbxBYREF | SbxULONG:
-            if( n > SbxMAXULNG )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXULNG;
-            }
-            else if( n < 0 )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
-            }
-            *p->pULong = (sal_uInt32) n; break;
-        case SbxBYREF | SbxSINGLE:
-            if( n > SbxMAXSNG )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXSNG;
-            }
-            else if( n < SbxMINSNG )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINSNG;
-            }
-            *p->pSingle = (float) n; break;
-        case SbxBYREF | SbxSALINT64:
-            *p->pnInt64 = ImpDoubleToSalInt64( n ); break;
-        case SbxBYREF | SbxSALUINT64:
-            *p->puInt64 = ImpDoubleToSalUInt64( n ); break;
-        case SbxBYREF | SbxDATE:
-        case SbxBYREF | SbxDOUBLE:
-            *p->pDouble = (double) n; break;
-        case SbxBYREF | SbxCURRENCY:
-            if( n > SbxMAXCURR )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXCURR;
-            }
-            else if( n < SbxMINCURR )
-            {
-                SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCURR;
-            }
-            *p->pnInt64 = ImpDoubleToCurrency( n ); break;
-
-        default:
-            SbxBase::SetError( SbxERR_CONVERSION );
+        else
+        {
+            SbxBase::SetError( SbxERR_NO_OBJECT );
+        }
+        break;
+    case SbxBYREF | SbxCHAR:
+        if( n > SbxMAXCHAR )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXCHAR;
+        }
+        else if( n < SbxMINCHAR )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCHAR;
+        }
+        *p->pChar = (sal_Unicode) n;
+        break;
+    case SbxBYREF | SbxBYTE:
+        if( n > SbxMAXBYTE )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXBYTE;
+        }
+        else if( n < 0 )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
+        }
+        *p->pByte = (sal_uInt8) n;
+        break;
+    case SbxBYREF | SbxINTEGER:
+    case SbxBYREF | SbxBOOL:
+        if( n > SbxMAXINT )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXINT;
+        }
+        else if( n < SbxMININT )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMININT;
+        }
+        *p->pInteger = (sal_Int16) n;
+        break;
+    case SbxBYREF | SbxERROR:
+    case SbxBYREF | SbxUSHORT:
+        if( n > SbxMAXUINT )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXUINT;
+        }
+        else if( n < 0 )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
+        }
+        *p->pUShort = (sal_uInt16) n;
+        break;
+    case SbxBYREF | SbxLONG:
+        if( n > SbxMAXLNG )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXLNG;
+        }
+        else if( n < SbxMINLNG )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINLNG;
+        }
+        *p->pLong = (sal_Int32) n;
+        break;
+    case SbxBYREF | SbxULONG:
+        if( n > SbxMAXULNG )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXULNG;
+        }
+        else if( n < 0 )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
+        }
+        *p->pULong = (sal_uInt32) n;
+        break;
+    case SbxBYREF | SbxSINGLE:
+        if( n > SbxMAXSNG )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXSNG;
+        }
+        else if( n < SbxMINSNG )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINSNG;
+        }
+        *p->pSingle = (float) n;
+        break;
+    case SbxBYREF | SbxSALINT64:
+        *p->pnInt64 = ImpDoubleToSalInt64( n );
+        break;
+    case SbxBYREF | SbxSALUINT64:
+        *p->puInt64 = ImpDoubleToSalUInt64( n );
+        break;
+    case SbxBYREF | SbxDATE:
+    case SbxBYREF | SbxDOUBLE:
+        *p->pDouble = (double) n;
+        break;
+    case SbxBYREF | SbxCURRENCY:
+        if( n > SbxMAXCURR )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXCURR;
+        }
+        else if( n < SbxMINCURR )
+        {
+            SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCURR;
+        }
+        *p->pnInt64 = ImpDoubleToCurrency( n );
+        break;
+    default:
+        SbxBase::SetError( SbxERR_CONVERSION );
+        break;
     }
 }