summaryrefslogtreecommitdiff
path: root/basic/source
diff options
context:
space:
mode:
authorNoel Power <noel.power@novell.com>2010-12-21 13:08:15 +0000
committerNoel Power <noel.power@novell.com>2010-12-21 13:08:15 +0000
commit7f2458dec64aec8a2462f1e6adeabcf27120c857 (patch)
treecebfc7c26b80327f439413aee55d5083a9a7ca57 /basic/source
parenta63d610d8943aff6b1327ed7fee2f5e1478d6ba8 (diff)
parentacc2b99c92d1a1e63e05b56d48db1b7df6e5c7ac (diff)
Merge remote branch 'origin/feature/currency-64bit'
Diffstat (limited to 'basic/source')
-rw-r--r--basic/source/classes/sbunoobj.cxx26
-rw-r--r--basic/source/runtime/methods1.cxx30
-rw-r--r--basic/source/sbx/makefile.mk1
-rw-r--r--basic/source/sbx/sbxbool.cxx34
-rw-r--r--basic/source/sbx/sbxbyte.cxx41
-rw-r--r--basic/source/sbx/sbxchar.cxx43
-rw-r--r--basic/source/sbx/sbxconv.hxx45
-rw-r--r--basic/source/sbx/sbxcurr.cxx506
-rw-r--r--basic/source/sbx/sbxdate.cxx18
-rw-r--r--basic/source/sbx/sbxdbl.cxx19
-rw-r--r--basic/source/sbx/sbxdec.cxx94
-rw-r--r--basic/source/sbx/sbxint.cxx165
-rw-r--r--basic/source/sbx/sbxlng.cxx60
-rw-r--r--basic/source/sbx/sbxsng.cxx39
-rw-r--r--basic/source/sbx/sbxstr.cxx20
-rw-r--r--basic/source/sbx/sbxuint.cxx43
-rw-r--r--basic/source/sbx/sbxulng.cxx35
-rw-r--r--basic/source/sbx/sbxvals.cxx112
-rw-r--r--basic/source/sbx/sbxvalue.cxx389
19 files changed, 704 insertions, 1016 deletions
diff --git a/basic/source/classes/sbunoobj.cxx b/basic/source/classes/sbunoobj.cxx
index 3a2a0dac6b78..c97945515db3 100644
--- a/basic/source/classes/sbunoobj.cxx
+++ b/basic/source/classes/sbunoobj.cxx
@@ -781,13 +781,7 @@ void unoToSbxValue( SbxVariable* pVar, const Any& aValue )
oleautomation::Currency aCurrency;
if( (aValue >>= aCurrency) )
{
- sal_Int64 nValue64 = aCurrency.Value;
- SbxINT64 aInt64;
- aInt64.nHigh =
- sal::static_int_cast< INT32 >(
- nValue64 >> 32);
- aInt64.nLow = (UINT32)( nValue64 & 0xffffffff );
- pVar->PutCurrency( aInt64 );
+ pVar->PutCurrency( aCurrency.Value );
break;
}
}
@@ -960,8 +954,6 @@ Type getUnoTypeForSbxBaseType( SbxDataType eType )
case SbxBYTE: aRetType = ::getCppuType( (sal_Int8*)0 ); break;
case SbxUSHORT: aRetType = ::getCppuType( (sal_uInt16*)0 ); break;
case SbxULONG: aRetType = ::getCppuType( (sal_uInt32*)0 ); break;
- //case SbxLONG64: break;
- //case SbxULONG64: break;
// map machine-dependent ones on hyper for secureness
case SbxINT: aRetType = ::getCppuType( (sal_Int32*)0 ); break;
case SbxUINT: aRetType = ::getCppuType( (sal_uInt32*)0 ); break;
@@ -1103,7 +1095,7 @@ Type getUnoTypeForSbxValue( SbxValue* pVal )
}
// Otherwise it is a No-Uno-Basic-Object -> default==deliver void
}
- // No objekt, convert basic type
+ // No object, convert basic type
else
{
aRetType = getUnoTypeForSbxBaseType( eBaseType );
@@ -1192,6 +1184,7 @@ Any sbxToUnoValueImpl( SbxVariable* pVar, bool bBlockConversionToSmallestType =
aType = ::getCppuType( (sal_uInt16*)0 );
break;
}
+ // TODO: need to add hyper types ?
default: break;
}
}
@@ -1324,13 +1317,8 @@ Any sbxToUnoValue( SbxVariable* pVar, const Type& rType, Property* pUnoProperty
}
else if( rType == ::getCppuType( (oleautomation::Currency*)0 ) )
{
- SbxINT64 aInt64 = pVar->GetCurrency();
- oleautomation::Currency aCurrency;
- sal_Int64& rnValue64 = aCurrency.Value;
- rnValue64 = aInt64.nHigh;
- rnValue64 <<= 32;
- rnValue64 |= aInt64.nLow;
- aRetVal <<= aCurrency;
+ // assumes per previous code that ole Currency is Int64
+ aRetVal <<= (sal_Int64)( pVar->GetInt64() );
break;
}
else if( rType == ::getCppuType( (oleautomation::Date*)0 ) )
@@ -1363,11 +1351,9 @@ Any sbxToUnoValue( SbxVariable* pVar, const Type& rType, Property* pUnoProperty
case TypeClass_CLASS: break;
case TypeClass_TYPEDEF: break;
case TypeClass_UNION: break;
- case TypeClass_ENUM: break;
case TypeClass_ARRAY: break;
*/
- // Array -> Sequence
case TypeClass_ENUM:
{
aRetVal = int2enum( pVar->GetLong(), rType );
@@ -1888,8 +1874,6 @@ String Dbg_SbxDataType2String( SbxDataType eType )
case SbxBYTE: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxBYTE") ); break;
case SbxUSHORT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxUSHORT") ); break;
case SbxULONG: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxULONG") ); break;
- case SbxLONG64: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxLONG64") ); break;
- case SbxULONG64: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxULONG64") ); break;
case SbxSALINT64: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxINT64") ); break;
case SbxSALUINT64: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxUINT64") ); break;
case SbxINT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxINT") ); break;
diff --git a/basic/source/runtime/methods1.cxx b/basic/source/runtime/methods1.cxx
index b922b556bd2c..4c4cecb08b04 100644
--- a/basic/source/runtime/methods1.cxx
+++ b/basic/source/runtime/methods1.cxx
@@ -158,12 +158,12 @@ RTLFUNC(CByte) // JSM
rPar.Get(0)->PutByte(nByte);
}
-RTLFUNC(CCur) // JSM
+RTLFUNC(CCur)
{
(void)pBasic;
(void)bWrite;
- SbxINT64 nCur;
+ sal_Int64 nCur = 0;
if ( rPar.Count() == 2 )
{
SbxVariable *pSbxVariable = rPar.Get(1);
@@ -175,7 +175,7 @@ RTLFUNC(CCur) // JSM
rPar.Get(0)->PutCurrency( nCur );
}
-RTLFUNC(CDec) // JSM
+RTLFUNC(CDec)
{
(void)pBasic;
(void)bWrite;
@@ -881,13 +881,16 @@ BOOL lcl_WriteSbxVariable( const SbxVariable& rVar, SvStream* pStrm,
case SbxLONG:
case SbxULONG:
- case SbxLONG64:
- case SbxULONG64:
if( bIsVariant )
*pStrm << (USHORT)SbxLONG; // VarType Id
*pStrm << rVar.GetLong();
break;
-
+ case SbxSALINT64:
+ case SbxSALUINT64:
+ if( bIsVariant )
+ *pStrm << (USHORT)SbxSALINT64; // VarType Id
+ *pStrm << (sal_uInt64)rVar.GetInt64();
+ break;
case SbxSINGLE:
if( bIsVariant )
*pStrm << (USHORT)eType; // VarType Id
@@ -983,15 +986,20 @@ BOOL lcl_ReadSbxVariable( SbxVariable& rVar, SvStream* pStrm,
case SbxLONG:
case SbxULONG:
- case SbxLONG64:
- case SbxULONG64:
{
INT32 aInt;
*pStrm >> aInt;
rVar.PutLong( aInt );
}
break;
-
+ case SbxSALINT64:
+ case SbxSALUINT64:
+ {
+ sal_uInt32 aInt;
+ *pStrm >> aInt;
+ rVar.PutInt64( (sal_Int64)aInt );
+ }
+ break;
case SbxSINGLE:
{
float nS;
@@ -1354,8 +1362,8 @@ RTLFUNC(TypeLen)
case SbxDOUBLE:
case SbxCURRENCY:
case SbxDATE:
- case SbxLONG64:
- case SbxULONG64:
+ case SbxSALINT64:
+ case SbxSALUINT64:
nLen = 8;
break;
diff --git a/basic/source/sbx/makefile.mk b/basic/source/sbx/makefile.mk
index cc20080cbe9c..9b76f9698417 100644
--- a/basic/source/sbx/makefile.mk
+++ b/basic/source/sbx/makefile.mk
@@ -58,7 +58,6 @@ SLOFILES= \
$(SLO)$/sbxsng.obj \
$(SLO)$/sbxuint.obj \
$(SLO)$/sbxulng.obj \
- $(SLO)$/sbxvals.obj \
$(SLO)$/sbxvar.obj
diff --git a/basic/source/sbx/sbxbool.cxx b/basic/source/sbx/sbxbool.cxx
index 35e36a94a557..03b435af1ef6 100644
--- a/basic/source/sbx/sbxbool.cxx
+++ b/basic/source/sbx/sbxbool.cxx
@@ -71,14 +71,10 @@ enum SbxBOOL ImpGetBool( const SbxValues* p )
}
break;
case SbxSALINT64:
+ case SbxCURRENCY:
nRes = p->nInt64 ? SbxTRUE : SbxFALSE; break;
case SbxSALUINT64:
nRes = p->uInt64 ? SbxTRUE : SbxFALSE; break;
- case SbxULONG64:
- nRes = !!p->nULong64 ? SbxTRUE : SbxFALSE; break;
- case SbxLONG64:
- case SbxCURRENCY:
- nRes = !!p->nLong64 ? SbxTRUE : SbxFALSE; break;
case SbxBYREF | SbxSTRING:
case SbxSTRING:
case SbxLPSTR:
@@ -139,16 +135,11 @@ enum SbxBOOL ImpGetBool( const SbxValues* p )
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
nRes = ( *p->pDouble != 0 ) ? SbxTRUE : SbxFALSE; break;
+ case SbxBYREF | SbxCURRENCY:
case SbxBYREF | SbxSALINT64:
nRes = ( *p->pnInt64 ) ? SbxTRUE : SbxFALSE; break;
case SbxBYREF | SbxSALUINT64:
nRes = ( *p->puInt64 ) ? SbxTRUE : SbxFALSE; break;
- case SbxBYREF | SbxULONG64:
- nRes = !!*p->pULong64 ? SbxTRUE : SbxFALSE; break;
- case SbxBYREF | SbxLONG64:
- case SbxBYREF | SbxCURRENCY:
- nRes = !!*p->pLong64 ? SbxTRUE : SbxFALSE; break;
-
default:
SbxBase::SetError( SbxERR_CONVERSION ); nRes = SbxFALSE;
}
@@ -180,15 +171,11 @@ void ImpPutBool( SbxValues* p, INT16 n )
case SbxDATE:
case SbxDOUBLE:
p->nDouble = n; break;
+ case SbxCURRENCY:
case SbxSALINT64:
- p->nInt64 = n; break;
+ p->nInt64 = (sal_Int64) n; break;
case SbxSALUINT64:
- p->uInt64 = n; break;
- case SbxULONG64:
- p->nULong64.Set( (UINT32)n ); break;
- case SbxLONG64:
- case SbxCURRENCY:
- p->nLong64.Set( (INT32)n ); break;
+ p->uInt64 = (sal_uInt64) n; break;
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
ImpCreateDecimal( p )->setInt( (INT16)n );
@@ -231,16 +218,11 @@ void ImpPutBool( SbxValues* p, INT16 n )
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
*p->pDouble = n; break;
+ case SbxBYREF | SbxCURRENCY:
case SbxBYREF | SbxSALINT64:
- *p->pnInt64 = n; break;
+ *p->pnInt64 = (sal_Int64) n; break;
case SbxBYREF | SbxSALUINT64:
- *p->puInt64 = n; break;
- case SbxBYREF | SbxULONG64:
- p->pULong64->Set( (UINT32)n ); break;
- case SbxBYREF | SbxLONG64:
- case SbxBYREF | SbxCURRENCY:
- p->pLong64->Set( (INT32)n ); break;
-
+ *p->puInt64 = (sal_uInt64) n; break;
default:
SbxBase::SetError( SbxERR_CONVERSION );
}
diff --git a/basic/source/sbx/sbxbyte.cxx b/basic/source/sbx/sbxbyte.cxx
index 727d1174417d..cbdc32c30d4f 100644
--- a/basic/source/sbx/sbxbyte.cxx
+++ b/basic/source/sbx/sbxbyte.cxx
@@ -95,8 +95,13 @@ start:
else
nRes = (BYTE) p->nULong;
break;
+ case SbxCURRENCY:
case SbxSALINT64:
- if( p->nInt64 > SbxMAXBYTE )
+ {
+ sal_Int64 val = p->nInt64;
+ if ( p->eType == SbxCURRENCY )
+ val = val / CURRENCY_FACTOR;
+ if( val > SbxMAXBYTE )
{
SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXBYTE;
}
@@ -105,8 +110,9 @@ start:
SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0;
}
else
- nRes = (BYTE) p->nInt64;
+ nRes = (BYTE) val;
break;
+ }
case SbxSALUINT64:
if( p->uInt64 > SbxMAXBYTE )
{
@@ -129,20 +135,11 @@ start:
break;
case SbxDATE:
case SbxDOUBLE:
- case SbxLONG64:
- case SbxULONG64:
- case SbxCURRENCY:
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
{
double dVal;
- if( p->eType == SbxCURRENCY )
- dVal = ImpCurrencyToDouble( p->nLong64 );
- else if( p->eType == SbxLONG64 )
- dVal = ImpINT64ToDouble( p->nLong64 );
- else if( p->eType == SbxULONG64 )
- dVal = ImpUINT64ToDouble( p->nULong64 );
- else if( p->eType == SbxDECIMAL )
+ if( p->eType == SbxDECIMAL )
{
dVal = 0.0;
if( p->pDecimal )
@@ -219,11 +216,7 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
aTmp.nDouble = *p->pDouble; goto ref;
- case SbxBYREF | SbxULONG64:
- aTmp.nULong64 = *p->pULong64; goto ref;
- case SbxBYREF | SbxLONG64:
case SbxBYREF | SbxCURRENCY:
- aTmp.nLong64 = *p->pLong64; goto ref;
case SbxBYREF | SbxSALINT64:
aTmp.nInt64 = *p->pnInt64; goto ref;
case SbxBYREF | SbxSALUINT64:
@@ -259,16 +252,12 @@ void ImpPutByte( SbxValues* p, BYTE n )
case SbxDATE:
case SbxDOUBLE:
p->nDouble = n; break;
+ case SbxCURRENCY:
+ p->nInt64 = n * CURRENCY_FACTOR; break;
case SbxSALINT64:
p->nInt64 = n; break;
case SbxSALUINT64:
p->uInt64 = n; break;
- case SbxULONG64:
- p->nULong64 = ImpDoubleToUINT64( (double)n ); break;
- case SbxLONG64:
- p->nLong64 = ImpDoubleToINT64( (double)n ); break;
- case SbxCURRENCY:
- p->nLong64 = ImpDoubleToCurrency( (double)n ); break;
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
ImpCreateDecimal( p )->setByte( n );
@@ -312,16 +301,12 @@ void ImpPutByte( SbxValues* p, BYTE n )
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
*p->pDouble = n; break;
- case SbxBYREF | SbxULONG64:
- *p->pULong64 = ImpDoubleToUINT64( (double)n ); break;
- case SbxBYREF | SbxLONG64:
- *p->pLong64 = ImpDoubleToINT64( (double)n ); break;
+ case SbxBYREF | SbxCURRENCY:
+ p->nInt64 = n * CURRENCY_FACTOR; break;
case SbxBYREF | SbxSALINT64:
*p->pnInt64 = n; break;
case SbxBYREF | SbxSALUINT64:
*p->puInt64 = n; break;
- case SbxBYREF | SbxCURRENCY:
- *p->pLong64 = ImpDoubleToCurrency( (double)n ); break;
default:
SbxBase::SetError( SbxERR_CONVERSION );
diff --git a/basic/source/sbx/sbxchar.cxx b/basic/source/sbx/sbxchar.cxx
index f516df8876f8..f579eafa9047 100644
--- a/basic/source/sbx/sbxchar.cxx
+++ b/basic/source/sbx/sbxchar.cxx
@@ -81,8 +81,15 @@ start:
else
nRes = (xub_Unicode) p->nULong;
break;
+ case SbxCURRENCY:
case SbxSALINT64:
- if( p->nInt64 > SbxMAXCHAR )
+ {
+ sal_Int64 val = p->nInt64;
+
+ if ( p->eType == SbxCURRENCY )
+ val = val / CURRENCY_FACTOR;
+
+ if( val > SbxMAXCHAR )
{
SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXCHAR;
}
@@ -91,8 +98,9 @@ start:
SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMINCHAR;
}
else
- nRes = (xub_Unicode) p->nInt64;
+ nRes = (xub_Unicode) val;
break;
+ }
case SbxSALUINT64:
if( p->uInt64 > SbxMAXCHAR )
{
@@ -115,20 +123,11 @@ start:
break;
case SbxDATE:
case SbxDOUBLE:
- case SbxLONG64:
- case SbxULONG64:
- case SbxCURRENCY:
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
{
double dVal;
- if( p->eType == SbxCURRENCY )
- dVal = ImpCurrencyToDouble( p->nLong64 );
- else if( p->eType == SbxLONG64 )
- dVal = ImpINT64ToDouble( p->nLong64 );
- else if( p->eType == SbxULONG64 )
- dVal = ImpUINT64ToDouble( p->nULong64 );
- else if( p->eType == SbxDECIMAL )
+ if( p->eType == SbxDECIMAL )
{
dVal = 0.0;
if( p->pDecimal )
@@ -202,11 +201,7 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
aTmp.nDouble = *p->pDouble; goto ref;
- case SbxBYREF | SbxULONG64:
- aTmp.nULong64 = *p->pULong64; goto ref;
- case SbxBYREF | SbxLONG64:
case SbxBYREF | SbxCURRENCY:
- aTmp.nLong64 = *p->pLong64; goto ref;
case SbxBYREF | SbxSALINT64:
aTmp.nInt64 = *p->pnInt64; goto ref;
case SbxBYREF | SbxSALUINT64:
@@ -239,16 +234,12 @@ start:
case SbxDATE:
case SbxDOUBLE:
p->nDouble = n; break;
+ case SbxCURRENCY:
+ p->nInt64 = n * CURRENCY_FACTOR; break;
case SbxSALINT64:
p->nInt64 = n; break;
case SbxSALUINT64:
p->uInt64 = n; break;
- case SbxULONG64:
- p->nULong64 = ImpDoubleToUINT64( (double)n ); break;
- case SbxLONG64:
- p->nLong64 = ImpDoubleToINT64( (double)n ); break;
- case SbxCURRENCY:
- p->nLong64 = ImpDoubleToCurrency( (double)n ); break;
case SbxBYREF | SbxDECIMAL:
ImpCreateDecimal( p )->setChar( n );
break;
@@ -301,16 +292,12 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
*p->pDouble = (double) n; break;
+ case SbxBYREF | SbxCURRENCY:
+ p->nInt64 = n * CURRENCY_FACTOR; break;
case SbxBYREF | SbxSALINT64:
*p->pnInt64 = n; break;
case SbxBYREF | SbxSALUINT64:
*p->puInt64 = n; break;
- case SbxBYREF | SbxULONG64:
- *p->pULong64 = ImpDoubleToUINT64( (double)n ); break;
- case SbxBYREF | SbxLONG64:
- *p->pLong64 = ImpDoubleToINT64( (double)n ); break;
- case SbxBYREF | SbxCURRENCY:
- *p->pLong64 = ImpDoubleToCurrency( (double)n ); break;
default:
SbxBase::SetError( SbxERR_CONVERSION );
diff --git a/basic/source/sbx/sbxconv.hxx b/basic/source/sbx/sbxconv.hxx
index 8155a98c1f07..ad455b2872af 100644
--- a/basic/source/sbx/sbxconv.hxx
+++ b/basic/source/sbx/sbxconv.hxx
@@ -47,13 +47,15 @@ extern BOOL ImpConvStringExt( ::rtl::OUString& rSrc, SbxDataType eTargetType );
double ImpRound( double );
INT16 ImpGetInteger( const SbxValues* );
void ImpPutInteger( SbxValues*, INT16 );
+
sal_Int64 ImpGetInt64( const SbxValues* );
void ImpPutInt64( SbxValues*, sal_Int64 );
sal_uInt64 ImpGetUInt64( const SbxValues* );
void ImpPutUInt64( SbxValues*, sal_uInt64 );
-sal_Int64 ImpDoubleToSalInt64( double d );
+sal_Int64 ImpDoubleToSalInt64 ( double d );
sal_uInt64 ImpDoubleToSalUInt64( double d );
+double ImpSalInt64ToDouble ( sal_Int64 n );
double ImpSalUInt64ToDouble( sal_uInt64 n );
// SBXLNG.CXX
@@ -71,37 +73,18 @@ void ImpPutSingle( SbxValues*, float );
double ImpGetDouble( const SbxValues* );
void ImpPutDouble( SbxValues*, double, BOOL bCoreString=FALSE );
-#if FALSE
-// SBX64.CXX
-
-SbxINT64 ImpGetINT64( const SbxValues* );
-void ImpPutINT64( SbxValues*, const SbxINT64& );
-SbxUINT64 ImpGetUINT64( const SbxValues* );
-void ImpPutUINT64( SbxValues*, const SbxUINT64& );
-#endif
-
// SBXCURR.CXX
-SbxUINT64 ImpDoubleToUINT64( double );
-double ImpUINT64ToDouble( const SbxUINT64& );
-SbxINT64 ImpDoubleToINT64( double );
-double ImpINT64ToDouble( const SbxINT64& );
+sal_Int64 ImpGetCurrency( const SbxValues* );
+void ImpPutCurrency( SbxValues*, const sal_Int64 );
-#if TRUE
-INT32 ImpGetCurrLong( const SbxValues* );
-void ImpPutCurrLong( SbxValues*, INT32 );
-INT32 ImpDoubleToCurrLong( double );
-double ImpCurrLongToDouble( INT32 );
-#endif
+inline sal_Int64 ImpDoubleToCurrency( double d )
+ { if (d > 0) return (sal_Int64)( d * CURRENCY_FACTOR + 0.5);
+ else return (sal_Int64)( d * CURRENCY_FACTOR - 0.5);
+ }
-SbxINT64 ImpGetCurrency( const SbxValues* );
-void ImpPutCurrency( SbxValues*, const SbxINT64& );
-inline
-SbxINT64 ImpDoubleToCurrency( double d )
- { return ImpDoubleToINT64( d * CURRENCY_FACTOR ); }
-inline
-double ImpCurrencyToDouble( const SbxINT64 &r )
- { return ImpINT64ToDouble( r ) / CURRENCY_FACTOR; }
+inline double ImpCurrencyToDouble( const sal_Int64 r )
+ { return (double)r / (double)CURRENCY_FACTOR; }
// SBXDEC.CXX
@@ -124,7 +107,7 @@ void ImpPutString( SbxValues*, const ::rtl::OUString* );
// SBXCHAR.CXX
sal_Unicode ImpGetChar( const SbxValues* );
-void ImpPutChar( SbxValues*, sal_Unicode );
+void ImpPutChar( SbxValues*, sal_Unicode );
// SBXBYTE.CXX
BYTE ImpGetByte( const SbxValues* );
@@ -143,9 +126,9 @@ void ImpPutULong( SbxValues*, UINT32 );
// SBXBOOL.CXX
enum SbxBOOL ImpGetBool( const SbxValues* );
-void ImpPutBool( SbxValues*, INT16 );
+void ImpPutBool( SbxValues*, INT16 );
-// ByteArry <--> String
+// ByteArray <--> String
SbxArray* StringToByteArray(const ::rtl::OUString& rStr);
::rtl::OUString ByteArrayToString(SbxArray* pArr);
diff --git a/basic/source/sbx/sbxcurr.cxx b/basic/source/sbx/sbxcurr.cxx
index d94586c50a12..7775dde239f3 100644
--- a/basic/source/sbx/sbxcurr.cxx
+++ b/basic/source/sbx/sbxcurr.cxx
@@ -29,101 +29,290 @@
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_basic.hxx"
-#include <basic/sbx.hxx>
#include <tools/errcode.hxx>
+#include <vcl/svapp.hxx> // for SvtSysLocale
-#define _TLBIGINT_INT64
-#include <tools/bigint.hxx>
-
+#include <basic/sbx.hxx>
#include <basic/sbxvar.hxx>
#include "sbxconv.hxx"
-static ::rtl::OUString ImpCurrencyToString( const SbxINT64& );
-static SbxINT64 ImpStringToCurrency( const ::rtl::OUString& );
-SbxINT64 ImpGetCurrency( const SbxValues* p )
+static rtl::OUString ImpCurrencyToString( const sal_Int64 &rVal )
{
- SbxValues aTmp;
- SbxINT64 nRes;
+ bool isNeg = ( rVal < 0 );
+ sal_Int64 absVal = isNeg ? -rVal : rVal;
+
+ SvtSysLocale aSysLocale;
+ sal_Unicode cDecimalSep = '.';
+#if MAYBEFUTURE
+ sal_Unicode cThousandSep = ',';
+ const LocaleDataWrapper& rData = aSysLocale.GetLocaleData();
+ cDecimalSep = rData.getNumDecimalSep().GetBuffer()[0];
+ cThousandSep = rData.getNumThousandSep().GetBuffer()[0];
+#endif
+
+ rtl::OUString aAbsStr = rtl::OUString::valueOf( absVal );
+ rtl::OUStringBuffer aBuf;
+
+ sal_Int32 initialLen = aAbsStr.getLength();
+
+ bool bLessThanOne = false;
+ if ( initialLen <= 4 ) // if less the 1
+ bLessThanOne = true;
+
+ sal_Int32 nCapacity = 6; // minimum e.g. 0.0000
+
+ if ( !bLessThanOne )
+ {
+ nCapacity = initialLen + 1;
+#if MAYBEFUTURE
+ if ( initialLen > 5 )
+ {
+ sal_Int32 nThouSeperators = ( initialLen - 5 ) / 3;
+ nCapacity += nThouSeperators;
+ }
+#endif
+ }
+
+ if ( isNeg )
+ ++nCapacity;
+
+ aBuf.setLength( nCapacity );
+
+
+ sal_Int32 nDigitCount = 0;
+ sal_Int32 nInsertIndex = nCapacity - 1;
+ sal_Int32 nEndIndex = isNeg ? 1 : 0;
+
+ for ( sal_Int32 charCpyIndex = aAbsStr.getLength() - 1; nInsertIndex >= nEndIndex; ++nDigitCount )
+ {
+ if ( nDigitCount == 4 )
+ aBuf.setCharAt( nInsertIndex--, cDecimalSep );
+#if MAYBEFUTURE
+ if ( nDigitCount > 4 && ! ( ( nDigitCount - 4 ) % 3) )
+ aBuf.setCharAt( nInsertIndex--, cThousandSep );
+#endif
+ if ( nDigitCount < initialLen )
+ aBuf.setCharAt( nInsertIndex--, aAbsStr[ charCpyIndex-- ] );
+ else
+ // Handle leading 0's to right of decimal point
+ // Note: in VBA the stringification is a little more complex
+ // but more natural as only the necessary digits
+ // to the right of the decimal places are displayed
+ // It would be great to conditionally be able to display like that too
+ //
+ // Val OOo (Cur) VBA (Cur)
+ // --- --------- ---------
+ // 0 0.0000 0
+ // 0.1 0.1000 0.1
+
+ aBuf.setCharAt( nInsertIndex--, (sal_Unicode)'0' );
+ }
+ if ( isNeg )
+ aBuf.setCharAt( nInsertIndex, (sal_Unicode)'-' );
+
+ aAbsStr = aBuf.makeStringAndClear();
+ return aAbsStr;
+}
+
+
+static sal_Int64 ImpStringToCurrency( const rtl::OUString &rStr )
+{
+
+ sal_Int32 nFractDigit = 4;
+
+ SvtSysLocale aSysLocale;
+ sal_Unicode cDeciPnt = sal_Unicode('.');
+ sal_Unicode c1000Sep = sal_Unicode(',');
+
+#if MAYBEFUTURE
+ const LocaleDataWrapper& rData = aSysLocale.GetLocaleData();
+ sal_Unicode cLocaleDeciPnt = rData.getNumDecimalSep().GetBuffer()[0];
+ sal_Unicode cLocale1000Sep = rData.getNumThousandSep().GetBuffer()[0];
+
+ // score each set of separators (Locale and Basic) on total number of matches
+ // if one set has more matches use that set
+ // if tied use the set with the only or rightmost decimal separator match
+ // currency is fixed pt system: usually expect the decimal pt, 1000sep may occur
+ sal_Int32 LocaleScore = 0;
+ sal_Int32 LocaleLastDeci = -1;
+ sal_Int32 LOBasicScore = 0;
+ sal_Int32 LOBasicLastDeci = -1;
+
+ for( int idx=0; idx<rStr.getLength(); idx++ )
+ {
+ if ( *(p+idx) == cLocaleDeciPnt )
+ {
+ LocaleScore++;
+ LocaleLastDeci = idx;
+ }
+ if ( *(p+idx) == cLocale1000Sep )
+ LocaleScore++;
+
+ if ( *(p+idx) == cDeciPnt )
+ {
+ LOBasicScore++;
+ LOBasicLastDeci = idx;
+ }
+ if ( *(p+idx) == c1000Sep )
+ LOBasicScore++;
+ }
+ if ( ( LocaleScore > LOBasicScore )
+ ||( LocaleScore = LOBasicScore && LocaleLastDeci > LOBasicLastDeci ) )
+ {
+ cDeciPnt = cLocaleDeciPnt;
+ c1000Sep = cLocale1000Sep;
+ }
+#endif
+
+ // lets use the existing string number conversions
+ // there is a performance impact here ( multiple string copies )
+ // but better I think than a home brewed string parser, if we need a parser
+ // we should share some existing ( possibly from calc is there a currency
+ // conversion there ? #TODO check )
+
+ rtl::OUString sTmp( rStr.trim() );
+ const sal_Unicode* p = sTmp.getStr();
+
+ // normalise string number by removeing thousands & decimal point seperators
+ rtl::OUStringBuffer sNormalisedNumString( sTmp.getLength() + nFractDigit );
+
+ if ( *p == '-' || *p == '+' )
+ sNormalisedNumString.append( *p );
+
+ while ( ( *p >= '0' && *p <= '9' ) )
+ {
+ sNormalisedNumString.append( *p++ );
+ // #TODO in vba mode set runtime error when a space ( or other )
+ // illegal character is found
+ if( *p == c1000Sep )
+ p++;
+ }
+
+ if( *p == cDeciPnt )
+ {
+ p++;
+ while( nFractDigit && *p >= '0' && *p <= '9' )
+ {
+ sNormalisedNumString.append( *p++ );
+ nFractDigit--;
+ }
+ }
+ // can we raise error here ? ( previous behaviour was more forgiving )
+ // so... not sure that could bread existing code, lets see if anyone
+ // complains.
+
+ if ( p != sTmp.getStr() + sTmp.getLength() )
+ SbxBase::SetError( SbxERR_CONVERSION );
+ while( nFractDigit )
+ {
+ sNormalisedNumString.append( '0' );
+ nFractDigit--;
+ }
+
+ sal_Int64 result = sNormalisedNumString.makeStringAndClear().toInt64();
+ return result;
+}
+
+
+sal_Int64 ImpGetCurrency( const SbxValues* p )
+{
+ SbxValues aTmp;
+ sal_Int64 nRes;
start:
switch( +p->eType )
{
+ case SbxERROR:
case SbxNULL:
SbxBase::SetError( SbxERR_CONVERSION );
+ nRes = 0; break;
case SbxEMPTY:
- nRes.SetNull(); break;
- case SbxCHAR:
- nRes = ImpDoubleToCurrency( (double)p->nChar ); break;
+ nRes = 0; break;
+ case SbxCURRENCY:
+ nRes = p->nInt64; break;
case SbxBYTE:
- nRes = ImpDoubleToCurrency( (double)p->nByte ); break;
- case SbxINTEGER:
+ nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(p->nByte);
+ break;
+ case SbxCHAR:
+ nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(p->pChar);
+ break;
case SbxBOOL:
- nRes = ImpDoubleToCurrency( (double)p->nInteger ); break;
- case SbxERROR:
+ case SbxINTEGER:
+ nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(p->nInteger);
+ break;
case SbxUSHORT:
- nRes = ImpDoubleToCurrency( (double)p->nUShort ); break;
- case SbxCURRENCY:
- nRes = p->nLong64; break;
+ nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(p->nUShort);
+ break;
case SbxLONG:
- nRes = ImpDoubleToCurrency( (double)p->nLong );
+ nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(p->nLong);
break;
case SbxULONG:
- nRes = ImpDoubleToCurrency( (double)p->nULong );
+ nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(p->nULong);
break;
+
case SbxSALINT64:
- nRes = ImpDoubleToCurrency( (double)p->nInt64 );
- break;
+ {
+ nRes = p->nInt64 * CURRENCY_FACTOR; break;
+ if ( nRes > SbxMAXSALINT64 )
+ {
+ SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXSALINT64;
+ }
+ }
case SbxSALUINT64:
- nRes = ImpDoubleToCurrency( ImpSalUInt64ToDouble( p->uInt64 ) );
- break;
- case SbxSINGLE:
- if( p->nSingle > SbxMAXCURR )
+ nRes = p->nInt64 * CURRENCY_FACTOR; break;
+ if ( nRes > SbxMAXSALINT64 )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); nRes.SetMax();
+ SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXSALINT64;
}
- else if( p->nSingle < SbxMINCURR )
+ else if ( nRes < SbxMINSALINT64 )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); nRes.SetMin();
+ SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMINSALINT64;
}
- else
- nRes = ImpDoubleToCurrency( (double)p->nSingle );
break;
- case SbxDATE:
- case SbxDOUBLE:
- if( p->nDouble > SbxMAXCURR )
+//TODO: bring back SbxINT64 types here for limits -1 with flag value at SAL_MAX/MIN
+ case SbxSINGLE:
+ if( p->nSingle * CURRENCY_FACTOR + 0.5 > (float)SAL_MAX_INT64
+ || p->nSingle * CURRENCY_FACTOR - 0.5 < (float)SAL_MIN_INT64 )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); nRes.SetMax();
+ nRes = SAL_MAX_INT64;
+ if( p->nSingle * CURRENCY_FACTOR - 0.5 < (float)SAL_MIN_INT64 )
+ nRes = SAL_MIN_INT64;
+ SbxBase::SetError( SbxERR_OVERFLOW );
+ break;
}
- else if( p->nDouble < SbxMINCURR )
+ nRes = ImpDoubleToCurrency( (double)p->nSingle );
+ break;
+
+ case SbxDATE:
+ case SbxDOUBLE:
+ if( p->nDouble * CURRENCY_FACTOR + 0.5 > (double)SAL_MAX_INT64
+ || p->nDouble * CURRENCY_FACTOR - 0.5 < (double)SAL_MIN_INT64 )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); nRes.SetMin();
+ nRes = SAL_MAX_INT64;
+ if( p->nDouble * CURRENCY_FACTOR - 0.5 < (double)SAL_MIN_INT64 )
+ nRes = SAL_MIN_INT64;
+ SbxBase::SetError( SbxERR_OVERFLOW );
+ break;
}
- else
- nRes = ImpDoubleToCurrency( p->nDouble );
+ nRes = ImpDoubleToCurrency( p->nDouble );
break;
+
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
{
double d = 0.0;
if( p->pDecimal )
p->pDecimal->getDouble( d );
- if( d > SbxMAXCURR )
- {
- SbxBase::SetError( SbxERR_OVERFLOW ); nRes.SetMax();
- }
- else if( d < SbxMINCURR )
- {
- SbxBase::SetError( SbxERR_OVERFLOW ); nRes.SetMin();
- }
- else
- nRes = ImpDoubleToCurrency( d );
+ nRes = ImpDoubleToCurrency( d );
break;
}
+
+
case SbxBYREF | SbxSTRING:
case SbxSTRING:
case SbxLPSTR:
if( !p->pOUString )
- nRes.SetNull();
+ nRes=0;
else
nRes = ImpStringToCurrency( *p->pOUString );
break;
@@ -134,23 +323,26 @@ start:
nRes = pVal->GetCurrency();
else
{
- SbxBase::SetError( SbxERR_NO_OBJECT ); nRes.SetNull();
+ SbxBase::SetError( SbxERR_NO_OBJECT );
+ nRes=0;
}
break;
}
case SbxBYREF | SbxCHAR:
- nRes = ImpDoubleToCurrency( (double)*p->pChar ); break;
+ nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(*p->pChar);
+ break;
case SbxBYREF | SbxBYTE:
- nRes = ImpDoubleToCurrency( (double)*p->pByte ); break;
- case SbxBYREF | SbxINTEGER:
+ nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(*p->pByte);
+ break;
case SbxBYREF | SbxBOOL:
- nRes = ImpDoubleToCurrency( (double)*p->pInteger ); break;
+ case SbxBYREF | SbxINTEGER:
+ nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(*p->pInteger);
+ break;
case SbxBYREF | SbxERROR:
case SbxBYREF | SbxUSHORT:
- nRes = ImpDoubleToCurrency( (double)*p->pUShort ); break;
- case SbxBYREF | SbxCURRENCY:
- nRes = *p->pLong64; break;
+ nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(*p->pUShort);
+ break;
// from here on had to be tested
case SbxBYREF | SbxLONG:
@@ -162,23 +354,25 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
aTmp.nDouble = *p->pDouble; goto ref;
+ case SbxBYREF | SbxCURRENCY:
case SbxBYREF | SbxSALINT64:
aTmp.nInt64 = *p->pnInt64; goto ref;
case SbxBYREF | SbxSALUINT64:
aTmp.uInt64 = *p->puInt64; goto ref;
ref:
- aTmp.eType = SbxDataType( p->eType & 0x0FFF );
+ aTmp.eType = SbxDataType( p->eType & ~SbxBYREF );
p = &aTmp; goto start;
default:
- SbxBase::SetError( SbxERR_CONVERSION ); nRes.SetNull();
+ SbxBase::SetError( SbxERR_CONVERSION );
+ nRes=0;
}
return nRes;
}
-void ImpPutCurrency( SbxValues* p, const SbxINT64 &r )
+
+void ImpPutCurrency( SbxValues* p, const sal_Int64 r )
{
- double dVal = ImpCurrencyToDouble( r );
SbxValues aTmp;
start:
switch( +p->eType )
@@ -204,21 +398,23 @@ start:
// from here no longer
case SbxSINGLE:
- p->nSingle = (float)dVal; break;
+ p->nSingle = (float)( r / CURRENCY_FACTOR ); break;
case SbxDATE:
case SbxDOUBLE:
- p->nDouble = dVal; break;
- case SbxSALINT64:
- p->nInt64 = ImpDoubleToSalInt64( dVal ); break;
+ p->nDouble = ImpCurrencyToDouble( r ); break;
case SbxSALUINT64:
- p->uInt64 = ImpDoubleToSalUInt64( dVal ); break;
+ p->uInt64 = r / CURRENCY_FACTOR; break;
+ case SbxSALINT64:
+ p->nInt64 = r / CURRENCY_FACTOR; break;
+
case SbxCURRENCY:
- p->nLong64 = r; break;
+ p->nInt64 = r; break;
+
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
{
SbxDecimal* pDec = ImpCreateDecimal( p );
- if( !pDec->setDouble( dVal ) )
+ if( !pDec->setDouble( ImpCurrencyToDouble( r ) / CURRENCY_FACTOR ) )
SbxBase::SetError( SbxERR_OVERFLOW );
break;
}
@@ -226,7 +422,7 @@ start:
case SbxSTRING:
case SbxLPSTR:
if( !p->pOUString )
- p->pOUString = new ::rtl::OUString;
+ p->pOUString = new rtl::OUString;
*p->pOUString = ImpCurrencyToString( r );
break;
@@ -240,158 +436,100 @@ start:
break;
}
case SbxBYREF | SbxCHAR:
- if( dVal > SbxMAXCHAR )
+ {
+ sal_Int64 val = r / CURRENCY_FACTOR;
+ if( val > SbxMAXCHAR )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); dVal = SbxMAXCHAR;
+ SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMAXCHAR;
}
- else if( dVal < SbxMINCHAR )
+ else if( val < SbxMINCHAR )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); dVal = SbxMINCHAR;
+ SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMINCHAR;
}
- *p->pChar = (xub_Unicode) dVal; break;
+ *p->pChar = (sal_Unicode) val; break;
+ }
case SbxBYREF | SbxBYTE:
- if( dVal > SbxMAXBYTE )
+ {
+ sal_Int64 val = r / CURRENCY_FACTOR;
+ if( val > SbxMAXBYTE )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); dVal = SbxMAXBYTE;
+ SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMAXBYTE;
}
- else if( dVal < 0 )
+ else if( val < 0 )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); dVal = 0;
+ SbxBase::SetError( SbxERR_OVERFLOW ); val = 0;
}
- *p->pByte = (BYTE) dVal; break;
+ *p->pByte = (BYTE) val; break;
+ }
case SbxBYREF | SbxINTEGER:
case SbxBYREF | SbxBOOL:
- if( dVal > SbxMAXINT )
+ {
+ sal_Int64 val = r / CURRENCY_FACTOR;
+ if( r > SbxMAXINT )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); dVal = SbxMAXINT;
+ SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMAXINT;
}
- else if( dVal < SbxMININT )
+ else if( r < SbxMININT )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); dVal = SbxMININT;
+ SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMININT;
}
- *p->pInteger = (INT16) dVal; break;
+ *p->pInteger = (INT16) r; break;
+ }
case SbxBYREF | SbxERROR:
case SbxBYREF | SbxUSHORT:
- if( dVal > SbxMAXUINT )
+ {
+ sal_Int64 val = r / CURRENCY_FACTOR;
+ if( val > SbxMAXUINT )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); dVal = SbxMAXUINT;
+ SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMAXUINT;
}
- else if( dVal < 0 )
+ else if( val < 0 )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); dVal = 0;
+ SbxBase::SetError( SbxERR_OVERFLOW ); val = 0;
}
- *p->pUShort = (UINT16) dVal; break;
+ *p->pUShort = (UINT16) val; break;
+ }
case SbxBYREF | SbxLONG:
- if( dVal > SbxMAXLNG )
+ {
+ sal_Int64 val = r / CURRENCY_FACTOR;
+ if( val > SbxMAXLNG )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); dVal = SbxMAXLNG;
+ SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMAXLNG;
}
- else if( dVal < SbxMINLNG )
+ else if( val < SbxMINLNG )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); dVal = SbxMINLNG;
+ SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMINLNG;
}
- *p->pLong = (INT32) dVal; break;
+ *p->pLong = (INT32) val; break;
+ }
case SbxBYREF | SbxULONG:
- if( dVal > SbxMAXULNG )
+ {
+ sal_Int64 val = r / CURRENCY_FACTOR;
+ if( val > SbxMAXULNG )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); dVal = SbxMAXULNG;
+ SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMAXULNG;
}
- else if( dVal < 0 )
+ else if( val < 0 )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); dVal = 0;
+ SbxBase::SetError( SbxERR_OVERFLOW ); val = 0;
}
- *p->pULong = (UINT32) dVal; break;
+ *p->pULong = (UINT32) val;
+ break;
+ }
+ case SbxBYREF | SbxCURRENCY:
+ *p->pnInt64 = r; break;
case SbxBYREF | SbxSALINT64:
- *p->pnInt64 = ImpDoubleToSalInt64( dVal ); break;
+ *p->pnInt64 = r / CURRENCY_FACTOR; break;
case SbxBYREF | SbxSALUINT64:
- *p->puInt64 = ImpDoubleToSalUInt64( dVal ); break;
+ *p->puInt64 = (sal_uInt64)r / CURRENCY_FACTOR; break;
case SbxBYREF | SbxSINGLE:
- *p->pSingle = (float) dVal; break;
+ p->nSingle = (float)( r / CURRENCY_FACTOR ); break;
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
- *p->pDouble = (double) dVal; break;
- case SbxBYREF | SbxCURRENCY:
- *p->pLong64 = r; break;
-
+ *p->pDouble = ImpCurrencyToDouble( r ); break;
default:
SbxBase::SetError( SbxERR_CONVERSION );
}
}
-// help functions for the conversion
-
-static ::rtl::OUString ImpCurrencyToString( const SbxINT64 &r )
-{
- BigInt a10000 = 10000;
-
- //return GetpApp()->GetAppInternational().GetCurr( BigInt( r ), 4 );
- BigInt aInt( r );
- aInt.Abs();
- BigInt aFrac = aInt;
- aInt /= a10000;
- aFrac %= a10000;
- aFrac += a10000;
-
- ::rtl::OUString aString;
- if( r.nHigh < 0 )
- aString = ::rtl::OUString( (sal_Unicode)'-' );
- aString += aInt.GetString();
- aString += ::rtl::OUString( (sal_Unicode)'.' );
- aString += aFrac.GetString().GetBuffer()+1;
- return aString;
-}
-
-static SbxINT64 ImpStringToCurrency( const ::rtl::OUString &r )
-{
- int nDec = 4;
- String aStr;
- const sal_Unicode* p = r.getStr();
-
- if( *p == '-' )
- aStr += *p++;
-
- while( *p >= '0' && *p <= '9' ) {
- aStr += *p++;
- if( *p == ',' )
- p++;
- }
-
- if( *p == '.' ) {
- p++;
- while( nDec && *p >= '0' && *p <= '9' ) {
- aStr += *p++;
- nDec--;
- }
- }
- while( nDec ) {
- aStr += '0';
- nDec--;
- }
-
- BigInt aBig( aStr );
- SbxINT64 nRes;
- aBig.INT64( &nRes );
- return nRes;
-}
-
-double ImpINT64ToDouble( const SbxINT64 &r )
-{ return (double)r.nHigh*(double)4294967296.0 + (double)r.nLow; }
-
-SbxINT64 ImpDoubleToINT64( double d )
-{
- SbxINT64 nRes;
- nRes.Set( d );
- return nRes;
-}
-
-double ImpUINT64ToDouble( const SbxUINT64 &r )
-{ return (double)r.nHigh*(double)4294967296.0 + (double)r.nLow; }
-
-SbxUINT64 ImpDoubleToUINT64( double d )
-{
- SbxUINT64 nRes;
- nRes.Set( d );
- return nRes;
-}
-
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/basic/source/sbx/sbxdate.cxx b/basic/source/sbx/sbxdate.cxx
index 054373ac9113..ee4c18996846 100644
--- a/basic/source/sbx/sbxdate.cxx
+++ b/basic/source/sbx/sbxdate.cxx
@@ -67,12 +67,8 @@ double ImpGetDate( const SbxValues* p )
case SbxDATE:
case SbxDOUBLE:
nRes = p->nDouble; break;
- case SbxULONG64:
- nRes = ImpUINT64ToDouble( p->nULong64 ); break;
- case SbxLONG64:
- nRes = ImpINT64ToDouble( p->nLong64 ); break;
case SbxCURRENCY:
- nRes = ImpCurrencyToDouble( p->nLong64 ); break;
+ nRes = ImpCurrencyToDouble( p->nInt64 ); break;
case SbxSALINT64:
nRes = static_cast< double >(p->nInt64); break;
case SbxSALUINT64:
@@ -178,12 +174,8 @@ double ImpGetDate( const SbxValues* p )
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
nRes = *p->pDouble; break;
- case SbxBYREF | SbxULONG64:
- nRes = ImpUINT64ToDouble( *p->pULong64 ); break;
- case SbxBYREF | SbxLONG64:
- nRes = ImpINT64ToDouble( *p->pLong64 ); break;
case SbxBYREF | SbxCURRENCY:
- nRes = ImpCurrencyToDouble( *p->pLong64 ); break;
+ nRes = ImpCurrencyToDouble( *p->pnInt64 ); break;
case SbxBYREF | SbxSALINT64:
nRes = static_cast< double >(*p->pnInt64); break;
case SbxBYREF | SbxSALUINT64:
@@ -223,11 +215,7 @@ start:
aTmp.pUShort = &p->nUShort; goto direct;
case SbxSINGLE:
aTmp.pSingle = &p->nSingle; goto direct;
- case SbxULONG64:
- aTmp.pULong64 = &p->nULong64; goto direct;
- case SbxLONG64:
case SbxCURRENCY:
- aTmp.pLong64 = &p->nLong64; goto direct;
case SbxSALINT64:
aTmp.pnInt64 = &p->nInt64; goto direct;
case SbxSALUINT64:
@@ -406,7 +394,7 @@ start:
{
SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCURR;
}
- *p->pLong64 = ImpDoubleToCurrency( n ); break;
+ *p->pnInt64 = ImpDoubleToCurrency( n ); break;
default:
SbxBase::SetError( SbxERR_CONVERSION );
diff --git a/basic/source/sbx/sbxdbl.cxx b/basic/source/sbx/sbxdbl.cxx
index f0fe163a7a50..570da2cf0626 100644
--- a/basic/source/sbx/sbxdbl.cxx
+++ b/basic/source/sbx/sbxdbl.cxx
@@ -62,7 +62,7 @@ double ImpGetDouble( const SbxValues* p )
case SbxDOUBLE:
nRes = p->nDouble; break;
case SbxCURRENCY:
- nRes = ImpCurrencyToDouble( p->nLong64 ); break;
+ nRes = ImpCurrencyToDouble( p->nInt64 ); break;
case SbxSALINT64:
nRes = static_cast< double >(p->nInt64); break;
case SbxSALUINT64:
@@ -129,7 +129,7 @@ double ImpGetDouble( const SbxValues* p )
case SbxBYREF | SbxDOUBLE:
nRes = *p->pDouble; break;
case SbxBYREF | SbxCURRENCY:
- nRes = ImpCurrencyToDouble( *p->pLong64 ); break;
+ nRes = ImpCurrencyToDouble( *p->pnInt64 ); break;
case SbxBYREF | SbxSALINT64:
nRes = static_cast< double >(*p->pnInt64); break;
case SbxBYREF | SbxSALUINT64:
@@ -156,7 +156,6 @@ start:
case SbxBOOL:
aTmp.pInteger = &p->nInteger; goto direct;
case SbxLONG:
- case SbxCURRENCY:
aTmp.pLong = &p->nLong; goto direct;
case SbxULONG:
aTmp.pULong = &p->nULong; goto direct;
@@ -177,6 +176,18 @@ start:
aTmp.eType = SbxDataType( p->eType | SbxBYREF );
p = &aTmp; goto start;
+ case SbxCURRENCY:
+ if( n > SbxMAXCURR )
+ {
+ SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXCURR;
+ }
+ else if( n < SbxMINCURR )
+ {
+ SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCURR;
+ }
+ p->nInt64 = ImpDoubleToCurrency( n );
+ break;
+
// from here on no longer
case SbxSALINT64:
p->nInt64 = ImpDoubleToSalInt64( n ); break;
@@ -298,7 +309,7 @@ start:
{
SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCURR;
}
- *p->pLong64 = ImpDoubleToCurrency( n ); break;
+ *p->pnInt64 = ImpDoubleToCurrency( n ); break;
default:
SbxBase::SetError( SbxERR_CONVERSION );
diff --git a/basic/source/sbx/sbxdec.cxx b/basic/source/sbx/sbxdec.cxx
index 8dcf1d44df61..79ce66d80d1f 100644
--- a/basic/source/sbx/sbxdec.cxx
+++ b/basic/source/sbx/sbxdec.cxx
@@ -36,14 +36,11 @@
#include <com/sun/star/bridge/oleautomation/Decimal.hpp>
-// int GnDecCounter = 0;
-
// Implementation SbxDecimal
SbxDecimal::SbxDecimal( void )
{
setInt( 0 );
mnRefCount = 0;
- // GnDecCounter++;
}
SbxDecimal::SbxDecimal( const SbxDecimal& rDec )
@@ -54,7 +51,6 @@ SbxDecimal::SbxDecimal( const SbxDecimal& rDec )
(void)rDec;
#endif
mnRefCount = 0;
- // GnDecCounter++;
}
SbxDecimal::SbxDecimal
@@ -494,38 +490,32 @@ start:
if( !pnDecRes->setSingle( p->nSingle ) )
SbxBase::SetError( SbxERR_OVERFLOW );
break;
+ case SbxCURRENCY:
+ {
+ if( !pnDecRes->setDouble( ImpCurrencyToDouble( p->nInt64 ) ) )
+ SbxBase::SetError( SbxERR_OVERFLOW );
+ break;
+ }
case SbxSALINT64:
{
- double d = (double)p->nInt64;
- pnDecRes->setDouble( d );
+ if( !pnDecRes->setDouble( (double)p->nInt64 ) )
+ SbxBase::SetError( SbxERR_OVERFLOW );
break;
}
case SbxSALUINT64:
{
- double d = ImpSalUInt64ToDouble( p->uInt64 );
- pnDecRes->setDouble( d );
+ if( !pnDecRes->setDouble( (double)p->uInt64 ) )
+ SbxBase::SetError( SbxERR_OVERFLOW );
break;
}
case SbxDATE:
case SbxDOUBLE:
- case SbxLONG64:
- case SbxULONG64:
- case SbxCURRENCY:
- {
- double dVal;
- if( p->eType == SbxCURRENCY )
- dVal = ImpCurrencyToDouble( p->nLong64 );
- else if( p->eType == SbxLONG64 )
- dVal = ImpINT64ToDouble( p->nLong64 );
- else if( p->eType == SbxULONG64 )
- dVal = ImpUINT64ToDouble( p->nULong64 );
- else
- dVal = p->nDouble;
-
+ {
+ double dVal = p->nDouble;
if( !pnDecRes->setDouble( dVal ) )
SbxBase::SetError( SbxERR_OVERFLOW );
break;
- }
+ }
case SbxLPSTR:
case SbxSTRING:
case SbxBYREF | SbxSTRING:
@@ -564,11 +554,7 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
aTmp.nDouble = *p->pDouble; goto ref;
- case SbxBYREF | SbxULONG64:
- aTmp.nULong64 = *p->pULong64; goto ref;
- case SbxBYREF | SbxLONG64:
case SbxBYREF | SbxCURRENCY:
- aTmp.nLong64 = *p->pLong64; goto ref;
case SbxBYREF | SbxSALINT64:
aTmp.nInt64 = *p->pnInt64; goto ref;
case SbxBYREF | SbxSALUINT64:
@@ -608,17 +594,17 @@ start:
case SbxERROR:
case SbxUSHORT:
aTmp.pUShort = &p->nUShort; goto direct;
- case SbxSALUINT64:
- aTmp.puInt64 = &p->uInt64; goto direct;
case SbxINTEGER:
case SbxBOOL:
aTmp.pInteger = &p->nInteger; goto direct;
case SbxLONG:
aTmp.pLong = &p->nLong; goto direct;
+ case SbxCURRENCY:
case SbxSALINT64:
aTmp.pnInt64 = &p->nInt64; goto direct;
- case SbxCURRENCY:
- aTmp.pLong64 = &p->nLong64; goto direct;
+ case SbxSALUINT64:
+ aTmp.puInt64 = &p->uInt64; goto direct;
+
direct:
aTmp.eType = SbxDataType( p->eType | SbxBYREF );
p = &aTmp; goto start;
@@ -630,8 +616,6 @@ start:
if( pDec != p->pDecimal )
{
releaseDecimalPtr( p->pDecimal );
- // if( p->pDecimal )
- // p->pDecimal->ReleaseRef();
p->pDecimal = pDec;
if( pDec )
pDec->addRef();
@@ -653,20 +637,6 @@ start:
p->nDouble = d;
break;
}
- case SbxULONG64:
- {
- double d;
- pDec->getDouble( d );
- p->nULong64 = ImpDoubleToUINT64( d );
- break;
- }
- case SbxLONG64:
- {
- double d;
- pDec->getDouble( d );
- p->nLong64 = ImpDoubleToINT64( d );
- break;
- }
case SbxLPSTR:
case SbxSTRING:
@@ -731,6 +701,13 @@ start:
*p->pULong = 0;
}
break;
+ case SbxBYREF | SbxCURRENCY:
+ double d;
+ if( !pDec->getDouble( d ) )
+ SbxBase::SetError( SbxERR_OVERFLOW );
+ pDec->getDouble( d );
+ *p->pnInt64 = ImpDoubleToCurrency( d );
+ break;
case SbxBYREF | SbxSALINT64:
{
double d;
@@ -755,8 +732,8 @@ start:
SbxBase::SetError( SbxERR_OVERFLOW );
*p->pSingle = 0;
}
+ *p->pSingle = (float) n;
break;
- // *p->pSingle = (float) n; break;
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
if( !pDec->getDouble( *p->pDouble ) )
@@ -765,27 +742,6 @@ start:
*p->pDouble = 0;
}
break;
- case SbxBYREF | SbxULONG64:
- {
- double d;
- pDec->getDouble( d );
- *p->pULong64 = ImpDoubleToUINT64( d );
- break;
- }
- case SbxBYREF | SbxLONG64:
- {
- double d;
- pDec->getDouble( d );
- *p->pLong64 = ImpDoubleToINT64( d );
- break;
- }
- case SbxBYREF | SbxCURRENCY:
- {
- double d;
- pDec->getDouble( d );
- *p->pLong64 = ImpDoubleToCurrency( d );
- break;
- }
default:
SbxBase::SetError( SbxERR_CONVERSION );
diff --git a/basic/source/sbx/sbxint.cxx b/basic/source/sbx/sbxint.cxx
index e15ece1b6d82..ec25f07a21fe 100644
--- a/basic/source/sbx/sbxint.cxx
+++ b/basic/source/sbx/sbxint.cxx
@@ -96,6 +96,22 @@ start:
else
nRes = (INT16) ImpRound( p->nSingle );
break;
+ case SbxCURRENCY:
+ {
+ sal_Int64 tstVal = (sal_Int64) p->nInt64 / (sal_Int64) CURRENCY_FACTOR;
+
+ if( tstVal > SbxMAXINT )
+ {
+ SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXINT;
+ }
+ else if( tstVal < SbxMININT )
+ {
+ SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMININT;
+ }
+ else
+ nRes = (INT16) (tstVal);
+ break;
+ }
case SbxSALINT64:
if( p->nInt64 > SbxMAXINT )
{
@@ -118,22 +134,12 @@ start:
break;
case SbxDATE:
case SbxDOUBLE:
- case SbxLONG64:
- case SbxULONG64:
- case SbxCURRENCY:
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
+ {
+ double dVal = 0.0;
+ if( p->eType == SbxDECIMAL )
{
- double dVal;
- if( p->eType == SbxCURRENCY )
- dVal = ImpCurrencyToDouble( p->nLong64 );
- else if( p->eType == SbxLONG64 )
- dVal = ImpINT64ToDouble( p->nLong64 );
- else if( p->eType == SbxULONG64 )
- dVal = ImpUINT64ToDouble( p->nULong64 );
- else if( p->eType == SbxDECIMAL )
- {
- dVal = 0.0;
if( p->pDecimal )
p->pDecimal->getDouble( dVal );
}
@@ -151,7 +157,7 @@ start:
else
nRes = (INT16) ImpRound( dVal );
break;
- }
+ }
case SbxLPSTR:
case SbxSTRING:
case SbxBYREF | SbxSTRING:
@@ -208,11 +214,7 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
aTmp.nDouble = *p->pDouble; goto ref;
- case SbxBYREF | SbxULONG64:
- aTmp.nULong64 = *p->pULong64; goto ref;
- case SbxBYREF | SbxLONG64:
case SbxBYREF | SbxCURRENCY:
- aTmp.nLong64 = *p->pLong64; goto ref;
case SbxBYREF | SbxSALINT64:
aTmp.nInt64 = *p->pnInt64; goto ref;
case SbxBYREF | SbxSALUINT64:
@@ -249,7 +251,7 @@ start:
aTmp.eType = SbxDataType( p->eType | SbxBYREF );
p = &aTmp; goto start;
- // frome here no longer
+ // from here no tests needed
case SbxINTEGER:
case SbxBOOL:
p->nInteger = n; break;
@@ -260,14 +262,10 @@ start:
case SbxDATE:
case SbxDOUBLE:
p->nDouble = n; break;
+ case SbxCURRENCY:
+ p->nInt64 = n * CURRENCY_FACTOR; break;
case SbxSALINT64:
p->nInt64 = n; break;
- case SbxULONG64:
- p->nULong64 = ImpDoubleToUINT64( (double)n ); break;
- case SbxLONG64:
- p->nLong64 = ImpDoubleToINT64( (double)n ); break;
- case SbxCURRENCY:
- p->nLong64 = ImpDoubleToCurrency( (double)n ); break;
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
ImpCreateDecimal( p )->setInt( n );
@@ -323,12 +321,15 @@ start:
SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
}
*p->pULong = (UINT32) n; break;
+ case SbxBYREF | SbxCURRENCY:
+ *p->pnInt64 = n * CURRENCY_FACTOR; break;
case SbxBYREF | SbxSALINT64:
*p->pnInt64 = n; break;
case SbxBYREF | SbxSALUINT64:
if( n < 0 )
{
- SbxBase::SetError( SbxERR_OVERFLOW ); *p->puInt64 = 0;
+ SbxBase::SetError( SbxERR_OVERFLOW );
+ *p->puInt64 = 0;
}
else
*p->puInt64 = n;
@@ -338,12 +339,6 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
*p->pDouble = (double) n; break;
- case SbxBYREF | SbxULONG64:
- *p->pULong64 = ImpDoubleToUINT64( (double)n ); break;
- case SbxBYREF | SbxLONG64:
- *p->pLong64 = ImpDoubleToINT64( (double)n ); break;
- case SbxBYREF | SbxCURRENCY:
- *p->pLong64 = ImpDoubleToCurrency( (double)n ); break;
default:
SbxBase::SetError( SbxERR_CONVERSION );
@@ -385,6 +380,7 @@ sal_uInt64 ImpDoubleToSalUInt64( double d )
return nRes;
}
+
double ImpSalUInt64ToDouble( sal_uInt64 n )
{
double d = 0.0;
@@ -416,33 +412,20 @@ start:
nRes = p->nInteger; break;
case SbxERROR:
case SbxUSHORT:
- nRes = p->nUShort; break;
+ nRes = (sal_Int64) p->nUShort; break;
case SbxLONG:
- nRes = p->nLong; break;
+ nRes = (sal_Int64) p->nLong; break;
case SbxULONG:
nRes = (sal_Int64) p->nULong; break;
case SbxSINGLE:
- nRes = ImpDoubleToSalInt64( (double)p->nSingle );
+ nRes = (sal_Int64) p->nSingle;
break;
case SbxDATE:
case SbxDOUBLE:
- case SbxLONG64:
- case SbxULONG64:
- case SbxCURRENCY:
- {
- double dVal;
- if( p->eType == SbxCURRENCY )
- dVal = ImpCurrencyToDouble( p->nLong64 );
- else if( p->eType == SbxLONG64 )
- dVal = ImpINT64ToDouble( p->nLong64 );
- else if( p->eType == SbxULONG64 )
- dVal = ImpUINT64ToDouble( p->nULong64 );
- else
- dVal = p->nDouble;
-
- nRes = ImpDoubleToSalInt64( dVal );
+ nRes = (sal_Int64) p->nDouble;
break;
- }
+ case SbxCURRENCY:
+ nRes = p->nInt64 / CURRENCY_FACTOR; break;
case SbxSALINT64:
nRes = p->nInt64; break;
case SbxSALUINT64:
@@ -472,7 +455,7 @@ start:
if( ImpScan( *p->pOUString, d, t, NULL ) != SbxERR_OK )
nRes = 0;
else
- nRes = ImpDoubleToSalInt64( d );
+ nRes = (sal_Int64) d;
}
}
break;
@@ -499,10 +482,15 @@ start:
nRes = *p->pLong; break;
case SbxBYREF | SbxULONG:
nRes = *p->pULong; break;
+ case SbxBYREF | SbxCURRENCY:
+ nRes = p->nInt64 / CURRENCY_FACTOR; break;
case SbxBYREF | SbxSALINT64:
nRes = *p->pnInt64; break;
// from here the values has to be checked
+ case SbxBYREF | SbxSALUINT64:
+ aTmp.uInt64 = *p->puInt64; goto ref;
+
case SbxBYREF | SbxERROR:
case SbxBYREF | SbxUSHORT:
aTmp.nUShort = *p->pUShort; goto ref;
@@ -511,13 +499,6 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
aTmp.nDouble = *p->pDouble; goto ref;
- case SbxBYREF | SbxULONG64:
- aTmp.nULong64 = *p->pULong64; goto ref;
- case SbxBYREF | SbxLONG64:
- case SbxBYREF | SbxCURRENCY:
- aTmp.nLong64 = *p->pLong64; goto ref;
- case SbxBYREF | SbxSALUINT64:
- aTmp.uInt64 = *p->puInt64; goto ref;
ref:
aTmp.eType = SbxDataType( p->eType & 0x0FFF );
p = &aTmp; goto start;
@@ -543,11 +524,6 @@ start:
case SbxINTEGER:
case SbxBOOL:
aTmp.pInteger = &p->nInteger; goto direct;
- case SbxULONG64:
- aTmp.pULong64 = &p->nULong64; goto direct;
- case SbxLONG64:
- case SbxCURRENCY:
- aTmp.pLong64 = &p->nLong64; goto direct;
case SbxULONG:
aTmp.pULong = &p->nULong; goto direct;
case SbxERROR:
@@ -555,6 +531,9 @@ start:
aTmp.pUShort = &p->nUShort; goto direct;
case SbxLONG:
aTmp.pnInt64 = &p->nInt64; goto direct;
+ case SbxCURRENCY:
+ case SbxSALINT64:
+ aTmp.pnInt64 = &p->nInt64; goto direct;
case SbxSALUINT64:
aTmp.puInt64 = &p->uInt64; goto direct;
@@ -562,9 +541,6 @@ start:
aTmp.eType = SbxDataType( p->eType | SbxBYREF );
p = &aTmp; goto start;
- // Check not neccessary
- case SbxSALINT64:
- p->nInt64 = n; break;
case SbxSINGLE:
p->nSingle = (float) n; break;
case SbxDATE:
@@ -660,16 +636,7 @@ start:
case SbxBYREF | SbxDOUBLE:
*p->pDouble = (double) n; break;
case SbxBYREF | SbxCURRENCY:
- if( n > SbxMAXCURR )
- {
- SbxBase::SetError( SbxERR_OVERFLOW ); n = (sal_Int64) SbxMAXCURR;
- }
- else if( n < SbxMINCURR )
- {
- SbxBase::SetError( SbxERR_OVERFLOW ); n = (sal_Int64) SbxMINCURR;
- }
- *p->pLong64 = ImpDoubleToCurrency( (double)n ); break;
-
+ *p->pnInt64 = n * CURRENCY_FACTOR; break;
case SbxBYREF | SbxSALINT64:
*p->pnInt64 = n; break;
case SbxBYREF | SbxSALUINT64:
@@ -710,27 +677,16 @@ start:
case SbxULONG:
nRes = (sal_uInt64) p->nULong; break;
case SbxSINGLE:
- nRes = ImpDoubleToSalUInt64( (double)p->nSingle );
- break;
+ nRes = (sal_uInt64) p->nSingle; break;
case SbxDATE:
case SbxDOUBLE:
- case SbxLONG64:
- case SbxULONG64:
- case SbxCURRENCY:
{
- double dVal;
- if( p->eType == SbxCURRENCY )
- dVal = ImpCurrencyToDouble( p->nLong64 );
- else if( p->eType == SbxLONG64 )
- dVal = ImpINT64ToDouble( p->nLong64 );
- else if( p->eType == SbxULONG64 )
- dVal = ImpUINT64ToDouble( p->nULong64 );
- else
- dVal = p->nDouble;
-
- nRes = ImpDoubleToSalUInt64( dVal );
+//TODO overflow check
+ nRes = (sal_uInt64) p->nDouble;
break;
}
+ case SbxCURRENCY:
+ nRes = p->nInt64 * CURRENCY_FACTOR; break;
case SbxSALINT64:
if( p->nInt64 < 0 )
{
@@ -738,6 +694,7 @@ start:
}
else
nRes = (sal_uInt64) p->nInt64;
+ break;
case SbxSALUINT64:
nRes = p->uInt64; break;
@@ -805,7 +762,7 @@ start:
case SbxBYREF | SbxSALUINT64:
nRes = *p->puInt64; break;
- // from here the values has to be checked
+ // from here on the value has to be checked
case SbxBYREF | SbxERROR:
case SbxBYREF | SbxUSHORT:
aTmp.nUShort = *p->pUShort; goto ref;
@@ -814,11 +771,7 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
aTmp.nDouble = *p->pDouble; goto ref;
- case SbxBYREF | SbxULONG64:
- aTmp.nULong64 = *p->pULong64; goto ref;
- case SbxBYREF | SbxLONG64:
case SbxBYREF | SbxCURRENCY:
- aTmp.nLong64 = *p->pLong64; goto ref;
case SbxBYREF | SbxSALINT64:
aTmp.nInt64 = *p->pnInt64; goto ref;
ref:
@@ -846,11 +799,6 @@ start:
case SbxINTEGER:
case SbxBOOL:
aTmp.pInteger = &p->nInteger; goto direct;
- case SbxULONG64:
- aTmp.pULong64 = &p->nULong64; goto direct;
- case SbxLONG64:
- case SbxCURRENCY:
- aTmp.pLong64 = &p->nLong64; goto direct;
case SbxULONG:
aTmp.pULong = &p->nULong; goto direct;
case SbxERROR:
@@ -858,6 +806,7 @@ start:
aTmp.pUShort = &p->nUShort; goto direct;
case SbxLONG:
aTmp.pnInt64 = &p->nInt64; goto direct;
+ case SbxCURRENCY:
case SbxSALINT64:
aTmp.pnInt64 = &p->nInt64; goto direct;
case SbxSINGLE:
@@ -939,14 +888,12 @@ start:
*p->pDouble = (float)ImpSalUInt64ToDouble( n ); break;
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
+
*p->pDouble = ImpSalUInt64ToDouble( n ); break;
case SbxBYREF | SbxCURRENCY:
- if( n > SbxMAXSALINT64 || (sal_Int64)n > SbxMAXCURR )
- {
- SbxBase::SetError( SbxERR_OVERFLOW ); n = (sal_Int64) SbxMAXCURR;
- }
- *p->pLong64 = ImpDoubleToCurrency( (double)(sal_Int64) n ); break;
-
+ if ( n > ( SbxMAXSALINT64 / CURRENCY_FACTOR ) )
+ SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXSALINT64;
+ *p->pnInt64 = ( sal_Int64) ( n * CURRENCY_FACTOR ); break;
case SbxBYREF | SbxSALUINT64:
*p->puInt64 = n; break;
case SbxBYREF | SbxSALINT64:
diff --git a/basic/source/sbx/sbxlng.cxx b/basic/source/sbx/sbxlng.cxx
index 47ae83cb7b21..32e994520c13 100644
--- a/basic/source/sbx/sbxlng.cxx
+++ b/basic/source/sbx/sbxlng.cxx
@@ -75,28 +75,28 @@ start:
else
nRes = (INT32) ImpRound( p->nSingle );
break;
- case SbxDATE:
- case SbxDOUBLE:
- case SbxLONG64:
- case SbxULONG64:
case SbxSALINT64:
+ nRes = p->nInt64;
+ break;
case SbxSALUINT64:
+ nRes = p->uInt64;
+ break;
case SbxCURRENCY:
+ {
+ sal_Int64 tstVal = p->nInt64 / CURRENCY_FACTOR;
+ nRes = (INT32) (tstVal);
+ if( tstVal < SbxMINLNG || SbxMAXLNG < tstVal ) SbxBase::SetError( SbxERR_OVERFLOW );
+ if( SbxMAXLNG < tstVal ) nRes = SbxMAXLNG;
+ if( tstVal < SbxMINLNG ) nRes = SbxMINLNG;
+ break;
+ }
+ case SbxDATE:
+ case SbxDOUBLE:
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
{
double dVal;
- if( p->eType == SbxCURRENCY )
- dVal = ImpCurrencyToDouble( p->nLong64 );
- else if( p->eType == SbxLONG64 )
- dVal = ImpINT64ToDouble( p->nLong64 );
- else if( p->eType == SbxULONG64 )
- dVal = ImpUINT64ToDouble( p->nULong64 );
- else if( p->eType == SbxSALINT64 )
- dVal = static_cast< double >(p->nInt64);
- else if( p->eType == SbxSALUINT64 )
- dVal = ImpSalUInt64ToDouble( p->uInt64 );
- else if( p->eType == SbxDECIMAL )
+ if( p->eType == SbxDECIMAL )
{
dVal = 0.0;
if( p->pDecimal )
@@ -173,15 +173,12 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
aTmp.nDouble = *p->pDouble; goto ref;
+ case SbxBYREF | SbxCURRENCY:
case SbxBYREF | SbxSALINT64:
aTmp.nInt64 = *p->pnInt64; goto ref;
case SbxBYREF | SbxSALUINT64:
aTmp.uInt64 = *p->puInt64; goto ref;
- case SbxBYREF | SbxULONG64:
- aTmp.nULong64 = *p->pULong64; goto ref;
- case SbxBYREF | SbxLONG64:
- case SbxBYREF | SbxCURRENCY:
- aTmp.nLong64 = *p->pLong64; goto ref;
+
ref:
aTmp.eType = SbxDataType( p->eType & 0x0FFF );
p = &aTmp; goto start;
@@ -207,11 +204,6 @@ start:
case SbxINTEGER:
case SbxBOOL:
aTmp.pInteger = &p->nInteger; goto direct;
- case SbxULONG64:
- aTmp.pULong64 = &p->nULong64; goto direct;
- case SbxLONG64:
- case SbxCURRENCY:
- aTmp.pLong64 = &p->nLong64; goto direct;
case SbxULONG:
aTmp.pULong = &p->nULong; goto direct;
case SbxSALUINT64:
@@ -231,6 +223,8 @@ start:
case SbxDATE:
case SbxDOUBLE:
p->nDouble = n; break;
+ case SbxCURRENCY:
+ p->nInt64 = n * CURRENCY_FACTOR; break;
case SbxSALINT64:
p->nInt64 = n; break;
case SbxDECIMAL:
@@ -320,21 +314,7 @@ start:
case SbxBYREF | SbxDOUBLE:
*p->pDouble = (double) n; break;
case SbxBYREF | SbxCURRENCY:
- double d;
- if( n > SbxMAXCURR )
- {
- SbxBase::SetError( SbxERR_OVERFLOW ); d = SbxMAXCURR;
- }
- else if( n < SbxMINCURR )
- {
- SbxBase::SetError( SbxERR_OVERFLOW ); d = SbxMINCURR;
- }
- else
- {
- d = n;
- }
- *p->pLong64 = ImpDoubleToCurrency( d ); break;
-
+ *p->pnInt64 = (sal_Int64)n * (sal_Int64)CURRENCY_FACTOR; break;
default:
SbxBase::SetError( SbxERR_CONVERSION );
}
diff --git a/basic/source/sbx/sbxsng.cxx b/basic/source/sbx/sbxsng.cxx
index a6250bf1d570..68bdcfe58609 100644
--- a/basic/source/sbx/sbxsng.cxx
+++ b/basic/source/sbx/sbxsng.cxx
@@ -59,10 +59,6 @@ start:
nRes = (float) p->nULong; break;
case SbxSINGLE:
nRes = p->nSingle; break;
- case SbxSALINT64:
- nRes = (float) p->nInt64; break;
- case SbxSALUINT64:
- nRes = (float) ImpSalUInt64ToDouble( p->uInt64 ); break;
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
if( p->pDecimal )
@@ -72,17 +68,17 @@ start:
break;
case SbxDATE:
case SbxDOUBLE:
- case SbxLONG64:
- case SbxULONG64:
case SbxCURRENCY:
+ case SbxSALINT64:
+ case SbxSALUINT64:
{
double dVal;
if( p->eType == SbxCURRENCY )
- dVal = ImpCurrencyToDouble( p->nLong64 );
- else if( p->eType == SbxLONG64 )
- dVal = ImpINT64ToDouble( p->nLong64 );
- else if( p->eType == SbxULONG64 )
- dVal = ImpUINT64ToDouble( p->nULong64 );
+ dVal = ImpCurrencyToDouble( p->nInt64 );
+ else if( p->eType == SbxSALINT64 )
+ dVal = (float) p->nInt64;
+ else if( p->eType == SbxSALUINT64 )
+ dVal = (float) p->uInt64;
else
dVal = p->nDouble;
@@ -96,6 +92,7 @@ start:
SbxBase::SetError( SbxERR_OVERFLOW );
nRes = static_cast< float >(SbxMINSNG);
}
+ // tests for underflow - storing value too small for precision of single
else if( dVal > 0 && dVal < SbxMAXSNG2 )
{
SbxBase::SetError( SbxERR_OVERFLOW );
@@ -167,15 +164,11 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
aTmp.nDouble = *p->pDouble; goto ref;
- case SbxBYREF | SbxULONG64:
- aTmp.nULong64 = *p->pULong64; goto ref;
- case SbxBYREF | SbxLONG64:
case SbxBYREF | SbxSALINT64:
- nRes = (float) *p->pnInt64; break;
- case SbxBYREF | SbxSALUINT64:
- nRes = (float) ImpSalUInt64ToDouble( *p->puInt64 ); break;
case SbxBYREF | SbxCURRENCY:
- aTmp.nLong64 = *p->pLong64; goto ref;
+ aTmp.nInt64 = *p->pnInt64; goto ref;
+ case SbxBYREF | SbxSALUINT64:
+ aTmp.uInt64 = *p->puInt64; goto ref;
ref:
aTmp.eType = SbxDataType( p->eType & 0x0FFF );
p = &aTmp; goto start;
@@ -206,11 +199,7 @@ start:
case SbxERROR:
case SbxUSHORT:
aTmp.pUShort = &p->nUShort; goto direct;
- case SbxULONG64:
- aTmp.pULong64 = &p->nULong64; goto direct;
- case SbxLONG64:
case SbxCURRENCY:
- aTmp.pLong64 = &p->nLong64; goto direct;
case SbxSALINT64:
aTmp.pnInt64 = &p->nInt64; goto direct;
case SbxSALUINT64:
@@ -334,9 +323,9 @@ start:
case SbxBYREF | SbxDOUBLE:
*p->pDouble = (double) n; break;
case SbxBYREF | SbxSALINT64:
- *p->pnInt64 = ImpDoubleToSalInt64( (double) n ); break;
+ *p->pnInt64 = (sal_Int64)n; break;
case SbxBYREF | SbxSALUINT64:
- *p->puInt64 = ImpDoubleToSalUInt64( (double) n ); break;
+ *p->puInt64 = (sal_uInt64)n; break;
case SbxBYREF | SbxCURRENCY:
double d;
if( n > SbxMAXCURR )
@@ -351,7 +340,7 @@ start:
{
d = n;
}
- *p->pLong64 = ImpDoubleToCurrency( n ); break;
+ *p->pnInt64 = ImpDoubleToCurrency( d ); break;
default:
SbxBase::SetError( SbxERR_CONVERSION );
diff --git a/basic/source/sbx/sbxstr.cxx b/basic/source/sbx/sbxstr.cxx
index d4d144e0f2bc..1b634d57d66c 100644
--- a/basic/source/sbx/sbxstr.cxx
+++ b/basic/source/sbx/sbxstr.cxx
@@ -69,7 +69,7 @@
case SbxDOUBLE:
ImpPutDouble( &aTmp, p->nDouble ); break;
case SbxCURRENCY:
- ImpPutCurrency( &aTmp, p->nLong64 ); break;
+ ImpPutCurrency( &aTmp, p->nInt64 ); break;
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
ImpPutDecimal( &aTmp, p->pDecimal ); break;
@@ -127,7 +127,7 @@
case SbxBYREF | SbxDOUBLE:
ImpPutDouble( &aTmp, *p->pDouble ); break;
case SbxBYREF | SbxCURRENCY:
- ImpPutCurrency( &aTmp, *p->pLong64 ); break;
+ ImpPutCurrency( &aTmp, *p->pnInt64 ); break;
case SbxBYREF | SbxSALINT64:
ImpPutInt64( &aTmp, *p->pnInt64 ); break;
case SbxBYREF | SbxSALUINT64:
@@ -148,9 +148,9 @@
XubString aRes;
aTmp.eType = SbxSTRING;
if( p->eType == SbxDOUBLE )
- ImpPutDouble( &aTmp, p->nDouble, /*bCoreString=*/TRUE );
+ ImpPutDouble( &aTmp, p->nDouble, TRUE ); // true = bCoreString
else
- ImpPutDouble( &aTmp, *p->pDouble, /*bCoreString=*/TRUE );
+ ImpPutDouble( &aTmp, *p->pDouble, TRUE ); // true = bCoreString
return aRes;
}
else
@@ -188,8 +188,8 @@ void ImpPutString( SbxValues* p, const ::rtl::OUString* n )
p->nDouble = ImpGetDate( &aTmp ); break;
case SbxDOUBLE:
p->nDouble = ImpGetDouble( &aTmp ); break;
- case SbxULONG64:
- p->nLong64 = ImpGetCurrency( &aTmp ); break;
+ case SbxCURRENCY:
+ p->nInt64 = ImpGetCurrency( &aTmp ); break;
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
releaseDecimalPtr( p->pDecimal );
@@ -244,13 +244,18 @@ void ImpPutString( SbxValues* p, const ::rtl::OUString* n )
case SbxBYREF | SbxDOUBLE:
*p->pDouble = ImpGetDouble( p ); break;
case SbxBYREF | SbxCURRENCY:
- *p->pLong64 = ImpGetCurrency( p ); break;
+ *p->pnInt64 = ImpGetCurrency( p ); break;
+ case SbxBYREF | SbxSALINT64:
+ *p->pnInt64 = ImpGetInt64( p ); break;
+ case SbxBYREF | SbxSALUINT64:
+ *p->puInt64 = ImpGetUInt64( p ); break;
default:
SbxBase::SetError( SbxERR_CONVERSION );
}
delete pTmp;
}
+
// Convert string to an array of bytes, preserving unicode (2bytes per character)
SbxArray* StringToByteArray(const ::rtl::OUString& rStr)
{
@@ -312,4 +317,5 @@ SbxArray* StringToByteArray(const ::rtl::OUString& rStr)
return aStrBuf.makeStringAndClear();
}
+
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/basic/source/sbx/sbxuint.cxx b/basic/source/sbx/sbxuint.cxx
index e20abbb3c0c0..3115fd850f89 100644
--- a/basic/source/sbx/sbxuint.cxx
+++ b/basic/source/sbx/sbxuint.cxx
@@ -81,6 +81,18 @@ start:
else
nRes = (UINT16) p->nULong;
break;
+ case SbxCURRENCY:
+ if( p->nInt64 / CURRENCY_FACTOR > SbxMAXUINT )
+ {
+ SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXUINT;
+ }
+ else if( p->nInt64 < 0 )
+ {
+ SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0;
+ }
+ else
+ nRes = (UINT16) (p->nInt64 / CURRENCY_FACTOR);
+ break;
case SbxSALINT64:
if( p->nInt64 > SbxMAXUINT )
{
@@ -115,20 +127,11 @@ start:
break;
case SbxDATE:
case SbxDOUBLE:
- case SbxLONG64:
- case SbxULONG64:
- case SbxCURRENCY:
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
{
double dVal;
- if( p->eType == SbxCURRENCY )
- dVal = ImpCurrencyToDouble( p->nLong64 );
- else if( p->eType == SbxLONG64 )
- dVal = ImpINT64ToDouble( p->nLong64 );
- else if( p->eType == SbxULONG64 )
- dVal = ImpUINT64ToDouble( p->nULong64 );
- else if( p->eType == SbxDECIMAL )
+ if( p->eType == SbxDECIMAL )
{
dVal = 0.0;
if( p->pDecimal )
@@ -205,11 +208,7 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
aTmp.nDouble = *p->pDouble; goto ref;
- case SbxBYREF | SbxULONG64:
- aTmp.nULong64 = *p->pULong64; goto ref;
- case SbxBYREF | SbxLONG64:
case SbxBYREF | SbxCURRENCY:
- aTmp.nLong64 = *p->pLong64; goto ref;
case SbxBYREF | SbxSALINT64:
aTmp.nInt64 = *p->pnInt64; goto ref;
case SbxBYREF | SbxSALUINT64:
@@ -243,16 +242,12 @@ start:
case SbxDATE:
case SbxDOUBLE:
p->nDouble = n; break;
+ case SbxCURRENCY:
+ p->nInt64 = n * CURRENCY_FACTOR; break;
case SbxSALINT64:
p->nInt64 = n; break;
case SbxSALUINT64:
p->uInt64 = n; break;
- case SbxULONG64:
- p->nULong64 = ImpDoubleToUINT64( (double)n ); break;
- case SbxLONG64:
- p->nLong64 = ImpDoubleToINT64( (double)n ); break;
- case SbxCURRENCY:
- p->nLong64 = ImpDoubleToCurrency( (double)n ); break;
case SbxDECIMAL:
case SbxBYREF | SbxDECIMAL:
ImpCreateDecimal( p )->setUInt( n );
@@ -314,16 +309,12 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
*p->pDouble = n; break;
+ case SbxBYREF | SbxCURRENCY:
+ *p->pnInt64 = n * CURRENCY_FACTOR; break;
case SbxBYREF | SbxSALINT64:
*p->pnInt64 = n; break;
case SbxBYREF | SbxSALUINT64:
*p->puInt64 = n; break;
- case SbxBYREF | SbxULONG64:
- *p->pULong64 = ImpDoubleToUINT64( (double)n ); break;
- case SbxBYREF | SbxLONG64:
- *p->pLong64 = ImpDoubleToINT64( (double)n ); break;
- case SbxBYREF | SbxCURRENCY:
- *p->pLong64 = ImpDoubleToCurrency( (double)n ); break;
default:
SbxBase::SetError( SbxERR_CONVERSION );
diff --git a/basic/source/sbx/sbxulng.cxx b/basic/source/sbx/sbxulng.cxx
index cfaeee07d4b0..10c1dbd4f8d7 100644
--- a/basic/source/sbx/sbxulng.cxx
+++ b/basic/source/sbx/sbxulng.cxx
@@ -85,8 +85,6 @@ start:
break;
case SbxDATE:
case SbxDOUBLE:
- case SbxLONG64:
- case SbxULONG64:
case SbxSALINT64:
case SbxSALUINT64:
case SbxCURRENCY:
@@ -95,11 +93,7 @@ start:
{
double dVal;
if( p->eType == SbxCURRENCY )
- dVal = ImpCurrencyToDouble( p->nLong64 );
- else if( p->eType == SbxLONG64 )
- dVal = ImpINT64ToDouble( p->nLong64 );
- else if( p->eType == SbxULONG64 )
- dVal = ImpUINT64ToDouble( p->nULong64 );
+ dVal = ImpCurrencyToDouble( p->nInt64 );
else if( p->eType == SbxSALINT64 )
dVal = static_cast< double >(p->nInt64);
else if( p->eType == SbxSALUINT64 )
@@ -181,15 +175,11 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
aTmp.nDouble = *p->pDouble; goto ref;
+ case SbxBYREF | SbxCURRENCY:
case SbxBYREF | SbxSALINT64:
aTmp.nInt64 = *p->pnInt64; goto ref;
case SbxBYREF | SbxSALUINT64:
aTmp.uInt64 = *p->puInt64; goto ref;
- case SbxBYREF | SbxULONG64:
- aTmp.nULong64 = *p->pULong64; goto ref;
- case SbxBYREF | SbxLONG64:
- case SbxBYREF | SbxCURRENCY:
- aTmp.nLong64 = *p->pLong64; goto ref;
ref:
aTmp.eType = SbxDataType( p->eType & 0x0FFF );
p = &aTmp; goto start;
@@ -213,8 +203,9 @@ start:
case SbxDATE:
case SbxDOUBLE:
p->nDouble = n; break;
+ case SbxCURRENCY:
case SbxSALINT64:
- p->nInt64 = n; break;
+ aTmp.pnInt64 = &p->nInt64; goto direct;
case SbxSALUINT64:
p->uInt64 = n; break;
case SbxDECIMAL:
@@ -235,11 +226,6 @@ start:
case SbxERROR:
case SbxUSHORT:
aTmp.pUShort = &p->nUShort; goto direct;
- case SbxULONG64:
- aTmp.pULong64 = &p->nULong64; goto direct;
- case SbxLONG64:
- case SbxCURRENCY:
- aTmp.pLong64 = &p->nLong64; goto direct;
direct:
aTmp.eType = SbxDataType( p->eType | SbxBYREF );
p = &aTmp; goto start;
@@ -299,21 +285,12 @@ start:
case SbxBYREF | SbxDATE:
case SbxBYREF | SbxDOUBLE:
*p->pDouble = n; break;
+ case SbxBYREF | SbxCURRENCY:
+ *p->pnInt64 = n * CURRENCY_FACTOR; break;
case SbxBYREF | SbxSALINT64:
*p->pnInt64 = n; break;
case SbxBYREF | SbxSALUINT64:
*p->puInt64 = n; break;
- case SbxBYREF | SbxCURRENCY:
- double d;
- if( n > SbxMAXCURR )
- {
- SbxBase::SetError( SbxERR_OVERFLOW ); d = SbxMAXCURR;
- }
- else
- {
- d = n;
- }
- *p->pLong64 = ImpDoubleToCurrency( n ); break;
default:
SbxBase::SetError( SbxERR_CONVERSION );
diff --git a/basic/source/sbx/sbxvals.cxx b/basic/source/sbx/sbxvals.cxx
deleted file mode 100644
index c33d922864c5..000000000000
--- a/basic/source/sbx/sbxvals.cxx
+++ /dev/null
@@ -1,112 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright 2000, 2010 Oracle and/or its affiliates.
- *
- * OpenOffice.org - a multi-platform office productivity suite
- *
- * This file is part of OpenOffice.org.
- *
- * OpenOffice.org is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 3
- * only, as published by the Free Software Foundation.
- *
- * OpenOffice.org is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License version 3 for more details
- * (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with OpenOffice.org. If not, see
- * <http://www.openoffice.org/license.html>
- * for a copy of the LGPLv3 License.
- *
- ************************************************************************/
-
-// MARKER(update_precomp.py): autogen include statement, do not remove
-#include "precompiled_basic.hxx"
-
-#define _TLBIGINT_INT64
-#include <tools/bigint.hxx>
-#include <basic/sbx.hxx>
-
-///////////////////////////// BigInt/Currency //////////////////////////////
-
-SbxValues::SbxValues( const BigInt &rBig ) : eType(SbxCURRENCY)
-{
- rBig.INT64( &nLong64 );
-}
-
-//TODO: BigInt is TOOLS_DLLPUBLIC, and its four member functions only declared
-// and defined within basic (#define _TLBIGINT_INT64) are a bad hack that causes
-// "warning C4273: 'function' : inconsistent dll linkage" on MSC; this whole
-// mess should be cleaned up properly (e.g., by completely removing Sbx[U]INT64
-// and using sal_[u]Int64 instead):
-#if defined _MSC_VER
-#pragma warning(disable: 4273)
-#endif
-
-BOOL BigInt::INT64( SbxINT64 *p ) const
-{
- if( bIsBig ) {
- if( nLen > 4 || (nNum[3] & 0x8000) )
- return FALSE;
-
- p->nLow = ((UINT32)nNum[1] << 16) | (UINT32)nNum[0];
- p->nHigh = ((UINT32)nNum[3] << 16) | (UINT32)nNum[2];
- if( bIsNeg )
- p->CHS();
- }
- else
- p->Set( (INT32)nVal );
-
- return TRUE;
-}
-
-BigInt::BigInt( const SbxINT64 &r )
-{
- BigInt a10000 = 0x10000;
-
- *this = r.nHigh;
- if( r.nHigh )
- *this *= a10000;
- *this += (USHORT)(r.nLow >> 16);
- *this *= a10000;
- *this += (USHORT)r.nLow;
-}
-
-BOOL BigInt::UINT64( SbxUINT64 *p ) const
-{
- if( bIsBig ) {
- if( bIsNeg || nLen > 4 )
- return FALSE;
-
- p->nLow = ((UINT32)nNum[1] << 16) | (UINT32)nNum[0];
- p->nHigh = ((UINT32)nNum[3] << 16) | (UINT32)nNum[2];
- }
- else {
- if( nVal < 0 )
- return FALSE;
-
- p->Set( (UINT32)nVal );
- }
-
- return TRUE;
-}
-
-BigInt::BigInt( const SbxUINT64 &r )
-{
- BigInt a10000 = 0x10000;
-
- *this = BigInt(r.nHigh);
- if( r.nHigh )
- *this *= a10000;
- *this += (USHORT)(r.nLow >> 16);
- *this *= a10000;
- *this += (USHORT)r.nLow;
-}
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/basic/source/sbx/sbxvalue.cxx b/basic/source/sbx/sbxvalue.cxx
index d49aa0f495f2..df4fe7b4a753 100644
--- a/basic/source/sbx/sbxvalue.cxx
+++ b/basic/source/sbx/sbxvalue.cxx
@@ -29,154 +29,18 @@
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_basic.hxx"
-#define _TLBIGINT_INT64
-#include <tools/bigint.hxx>
+#include <math.h>
#include <tools/stream.hxx>
#include <basic/sbx.hxx>
#include "sbxconv.hxx"
-#include <math.h>
#include "runtime.hxx"
TYPEINIT1(SbxValue,SbxBase)
-/////////////////////////// SbxINT64 /////////////////////////////////////
-SbxINT64 &SbxINT64::operator -= ( const SbxINT64 &r )
-{
- BigInt b( *this );
- b -= BigInt( r );
- b.INT64( this );
- return *this;
-}
-SbxINT64 &SbxINT64::operator += ( const SbxINT64 &r )
-{
- BigInt b( *this );
- b += BigInt( r );
- b.INT64( this );
- return *this;
-}
-SbxINT64 &SbxINT64::operator *= ( const SbxINT64 &r )
-{
- BigInt b( *this );
- b *= BigInt( r );
- b.INT64( this );
- return *this;
-}
-SbxINT64 &SbxINT64::operator %= ( const SbxINT64 &r )
-{
- BigInt b( *this );
- b %= BigInt( r );
- b.INT64( this );
- return *this;
-}
-SbxINT64 &SbxINT64::operator /= ( const SbxINT64 &r )
-{
- BigInt b( *this );
- b /= BigInt( r );
- b.INT64( this );
- return *this;
-}
-SbxINT64 &SbxINT64::operator &= ( const SbxINT64 &r )
-{
- nHigh &= r.nHigh;
- nLow &= r.nLow;
- return *this;
-}
-SbxINT64 &SbxINT64::operator |= ( const SbxINT64 &r )
-{
- nHigh |= r.nHigh;
- nLow |= r.nLow;
- return *this;
-}
-SbxINT64 &SbxINT64::operator ^= ( const SbxINT64 &r )
-{
- nHigh ^= r.nHigh;
- nLow ^= r.nLow;
- return *this;
-}
-
-SbxINT64 operator - ( const SbxINT64 &l, const SbxINT64 &r )
-{
- SbxINT64 a(l);
- a -= r;
- return a;
-}
-SbxINT64 operator + ( const SbxINT64 &l, const SbxINT64 &r )
-{
- SbxINT64 a(l);
- a += r;
- return a;
-}
-SbxINT64 operator / ( const SbxINT64 &l, const SbxINT64 &r )
-{
- SbxINT64 a(l);
- a /= r;
- return a;
-}
-SbxINT64 operator % ( const SbxINT64 &l, const SbxINT64 &r )
-{
- SbxINT64 a(l);
- a %= r;
- return a;
-}
-SbxINT64 operator * ( const SbxINT64 &l, const SbxINT64 &r )
-{
- SbxINT64 a(l);
- a *= r;
- return a;
-}
-SbxINT64 operator & ( const SbxINT64 &l, const SbxINT64 &r )
-{
- SbxINT64 a;
- a.nHigh = r.nHigh & l.nHigh;
- a.nLow = r.nLow & l.nLow;
- return a;
-}
-SbxINT64 operator | ( const SbxINT64 &l, const SbxINT64 &r )
-{
- SbxINT64 a;
- a.nHigh = r.nHigh | l.nHigh;
- a.nLow = r.nLow | l.nLow;
- return a;
-}
-SbxINT64 operator ^ ( const SbxINT64 &r, const SbxINT64 &l )
-{
- SbxINT64 a;
- a.nHigh = r.nHigh ^ l.nHigh;
- a.nLow = r.nLow ^ l.nLow;
- return a;
-}
-
-SbxINT64 operator - ( const SbxINT64 &r )
-{
- SbxINT64 a( r );
- a.CHS();
- return a;
-}
-SbxINT64 operator ~ ( const SbxINT64 &r )
-{
- SbxINT64 a;
- a.nHigh = ~r.nHigh;
- a.nLow = ~r.nLow;
- return a;
-}
-
-SbxUINT64 &SbxUINT64::operator %= ( const SbxUINT64 &r )
-{
- BigInt b( *this );
- b %= BigInt( r );
- b.UINT64( this );
- return *this;
-}
-SbxUINT64 &SbxUINT64::operator /= ( const SbxUINT64 &r )
-{
- BigInt b( *this );
- b /= BigInt( r );
- b.UINT64( this );
- return *this;
-}
-/////////////////////////// Error processing /////////////////////////////
+///////////////////////////// error handling //////////////////////////////
+// bring back ?? was ever in ?? currently ifdef out ?
#ifdef _USED
// STILL Reverse ENGINEERING!
@@ -204,7 +68,6 @@ int matherr( struct _exception* p )
#endif // _USED
-
///////////////////////////// constructors //////////////////////////////
SbxValue::SbxValue() : SbxBase()
@@ -225,9 +88,9 @@ SbxValue::SbxValue( SbxDataType t, void* p ) : SbxBase()
switch( t & 0x0FFF )
{
case SbxINTEGER: n |= SbxBYREF; aData.pInteger = (INT16*) p; break;
- case SbxULONG64: n |= SbxBYREF; aData.pULong64 = (SbxUINT64*) p; break;
- case SbxLONG64:
- case SbxCURRENCY: n |= SbxBYREF; aData.pLong64 = (SbxINT64*) p; break;
+ case SbxSALUINT64: n |= SbxBYREF; aData.puInt64 = (sal_uInt64*) p; break;
+ case SbxSALINT64:
+ case SbxCURRENCY: n |= SbxBYREF; aData.pnInt64 = (sal_Int64*) p; break;
case SbxLONG: n |= SbxBYREF; aData.pLong = (INT32*) p; break;
case SbxSINGLE: n |= SbxBYREF; aData.pSingle = (float*) p; break;
case SbxDATE:
@@ -237,7 +100,7 @@ SbxValue::SbxValue( SbxDataType t, void* p ) : SbxBase()
case SbxUSHORT:
case SbxBOOL: n |= SbxBYREF; aData.pUShort = (UINT16*) p; break;
case SbxULONG: n |= SbxBYREF; aData.pULong = (UINT32*) p; break;
- case SbxCHAR: n |= SbxBYREF; aData.pChar = (xub_Unicode*) p; break;
+ case SbxCHAR: n |= SbxBYREF; aData.pChar = (sal_Unicode*) p; break;
case SbxBYTE: n |= SbxBYREF; aData.pByte = (BYTE*) p; break;
case SbxINT: n |= SbxBYREF; aData.pInt = (int*) p; break;
case SbxOBJECT:
@@ -534,7 +397,7 @@ BOOL SbxValue::Get( SbxValues& rRes ) const
case SbxSALUINT64: rRes.uInt64 = ImpGetUInt64( &p->aData ); break;
case SbxSINGLE: rRes.nSingle = ImpGetSingle( &p->aData ); break;
case SbxDOUBLE: rRes.nDouble = ImpGetDouble( &p->aData ); break;
- case SbxCURRENCY:rRes.nLong64 = ImpGetCurrency( &p->aData ); break;
+ case SbxCURRENCY:rRes.nInt64 = ImpGetCurrency( &p->aData ); break;
case SbxDECIMAL: rRes.pDecimal = ImpGetDecimal( &p->aData ); break;
case SbxDATE: rRes.nDouble = ImpGetDate( &p->aData ); break;
case SbxBOOL:
@@ -665,25 +528,23 @@ BOOL SbxValue::GetBool() const
#define GET( g, e, t, m ) \
t SbxValue::g() const { SbxValues aRes(e); Get( aRes ); return aRes.m; }
-GET( GetByte, SbxBYTE, BYTE, nByte )
-GET( GetChar, SbxCHAR, xub_Unicode, nChar )
-GET( GetCurrency, SbxCURRENCY, SbxINT64, nLong64 )
-GET( GetDate, SbxDATE, double, nDouble )
-GET( GetData, SbxDATAOBJECT, void*, pData )
-GET( GetDouble, SbxDOUBLE, double, nDouble )
-GET( GetErr, SbxERROR, UINT16, nUShort )
-GET( GetInt, SbxINT, int, nInt )
-GET( GetInteger, SbxINTEGER, INT16, nInteger )
-GET( GetLong, SbxLONG, INT32, nLong )
-GET( GetLong64, SbxLONG64, SbxINT64, nLong64 )
-GET( GetObject, SbxOBJECT, SbxBase*, pObj )
-GET( GetSingle, SbxSINGLE, float, nSingle )
-GET( GetULong, SbxULONG, UINT32, nULong )
-GET( GetULong64, SbxULONG64, SbxUINT64, nULong64 )
-GET( GetUShort, SbxUSHORT, UINT16, nUShort )
-GET( GetInt64, SbxSALINT64, sal_Int64, nInt64 )
-GET( GetUInt64, SbxSALUINT64, sal_uInt64, uInt64 )
-GET( GetDecimal, SbxDECIMAL, SbxDecimal*, pDecimal )
+GET( GetByte, SbxBYTE, BYTE, nByte )
+GET( GetChar, SbxCHAR, xub_Unicode, nChar )
+GET( GetCurrency, SbxCURRENCY, sal_Int64, nInt64 )
+GET( GetDate, SbxDATE, double, nDouble )
+GET( GetData, SbxDATAOBJECT, void*, pData )
+GET( GetDouble, SbxDOUBLE, double, nDouble )
+GET( GetErr, SbxERROR, UINT16, nUShort )
+GET( GetInt, SbxINT, int, nInt )
+GET( GetInteger, SbxINTEGER, INT16, nInteger )
+GET( GetLong, SbxLONG, INT32, nLong )
+GET( GetObject, SbxOBJECT, SbxBase*, pObj )
+GET( GetSingle, SbxSINGLE, float, nSingle )
+GET( GetULong, SbxULONG, UINT32, nULong )
+GET( GetUShort, SbxUSHORT, UINT16, nUShort )
+GET( GetInt64, SbxSALINT64, sal_Int64, nInt64 )
+GET( GetUInt64, SbxSALUINT64, sal_uInt64, uInt64 )
+GET( GetDecimal, SbxDECIMAL, SbxDecimal*, pDecimal )
//////////////////////////// Write data /////////////////////////////
@@ -721,7 +582,7 @@ BOOL SbxValue::Put( const SbxValues& rVal )
case SbxSALUINT64: ImpPutUInt64( &p->aData, rVal.uInt64 ); break;
case SbxSINGLE: ImpPutSingle( &p->aData, rVal.nSingle ); break;
case SbxDOUBLE: ImpPutDouble( &p->aData, rVal.nDouble ); break;
- case SbxCURRENCY: ImpPutCurrency( &p->aData, rVal.nLong64 ); break;
+ case SbxCURRENCY: ImpPutCurrency( &p->aData, rVal.nInt64 ); break;
case SbxDECIMAL: ImpPutDecimal( &p->aData, rVal.pDecimal ); break;
case SbxDATE: ImpPutDate( &p->aData, rVal.nDouble ); break;
case SbxBOOL: ImpPutBool( &p->aData, rVal.nInteger ); break;
@@ -935,8 +796,8 @@ BOOL SbxValue::p( t n ) \
{ SbxValues aRes(e); aRes.m = n; Put( aRes ); return BOOL( !IsError() ); }
PUT( PutByte, SbxBYTE, BYTE, nByte )
-PUT( PutChar, SbxCHAR, xub_Unicode, nChar )
-PUT( PutCurrency, SbxCURRENCY, const SbxINT64&, nLong64 )
+PUT( PutChar, SbxCHAR, sal_Unicode, nChar )
+PUT( PutCurrency, SbxCURRENCY, const sal_Int64&, nInt64 )
PUT( PutDate, SbxDATE, double, nDouble )
PUT( PutData, SbxDATAOBJECT, void*, pData )
PUT( PutDouble, SbxDOUBLE, double, nDouble )
@@ -944,11 +805,9 @@ PUT( PutErr, SbxERROR, UINT16, nUShort )
PUT( PutInt, SbxINT, int, nInt )
PUT( PutInteger, SbxINTEGER, INT16, nInteger )
PUT( PutLong, SbxLONG, INT32, nLong )
-PUT( PutLong64, SbxLONG64, const SbxINT64&, nLong64 )
PUT( PutObject, SbxOBJECT, SbxBase*, pObj )
PUT( PutSingle, SbxSINGLE, float, nSingle )
PUT( PutULong, SbxULONG, UINT32, nULong )
-PUT( PutULong64, SbxULONG64, const SbxUINT64&, nULong64 )
PUT( PutUShort, SbxUSHORT, UINT16, nUShort )
PUT( PutInt64, SbxSALINT64, sal_Int64, nInt64 )
PUT( PutUInt64, SbxSALUINT64, sal_uInt64, uInt64 )
@@ -1183,34 +1042,24 @@ BOOL SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp )
else if( eOpType == SbxSTRING && rOp.IsFixed() )
{ // Numeric: there is no String allowed on the right side
SetError( SbxERR_CONVERSION );
+ // falls all the way out
}
else if( ( eOp >= SbxIDIV && eOp <= SbxNOT ) || eOp == SbxMOD )
{
if( GetType() == eOpType )
{
- if( GetType() == SbxULONG64
- || GetType() == SbxLONG64
- || GetType() == SbxCURRENCY
- || GetType() == SbxULONG )
+ if( GetType() == SbxSALUINT64 || GetType() == SbxSALINT64
+ || GetType() == SbxCURRENCY || GetType() == SbxULONG )
aL.eType = aR.eType = GetType();
-// else if( GetType() == SbxDouble || GetType() == SbxSingle )
-// aL.eType = aR.eType = SbxLONG64;
else if ( bVBAInterop && eOpType == SbxBOOL )
aL.eType = aR.eType = SbxBOOL;
else
aL.eType = aR.eType = SbxLONG;
}
- else if( GetType() == SbxCURRENCY || eOpType == SbxCURRENCY
- || GetType() == SbxULONG64 || eOpType == SbxULONG64
- || GetType() == SbxLONG64 || eOpType == SbxLONG64 )
- aL.eType = aR.eType = SbxLONG64;
-// else if( GetType() == SbxDouble || rOP.GetType() == SbxDouble
-// || GetType() == SbxSingle || rOP.GetType() == SbxSingle )
-// aL.eType = aR.eType = SbxLONG64;
else
aL.eType = aR.eType = SbxLONG;
- if( rOp.Get( aR ) )
+ if( rOp.Get( aR ) ) // re-do Get after type assigns above
{
if( rOp.GetType() == SbxEMPTY )
{
@@ -1221,13 +1070,17 @@ BOOL SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp )
{
case SbxIDIV:
if( aL.eType == SbxCURRENCY )
- aL.eType = SbxLONG64;
- if( aL.eType == SbxLONG64 )
- if( !aR.nLong64 ) SetError( SbxERR_ZERODIV );
- else aL.nLong64 /= aR.nLong64;
- else if( aL.eType == SbxULONG64 )
- if( !aR.nULong64 ) SetError( SbxERR_ZERODIV );
- else aL.nULong64 /= aR.nULong64;
+ if( !aR.nInt64 ) SetError( SbxERR_ZERODIV );
+ else {
+ aL.nInt64 /= aR.nInt64;
+ aL.nInt64 *= CURRENCY_FACTOR;
+ }
+ else if( aL.eType == SbxSALUINT64 )
+ if( !aR.uInt64 ) SetError( SbxERR_ZERODIV );
+ else aL.uInt64 /= aR.uInt64;
+ else if( aL.eType == SbxSALINT64 )
+ if( !aR.nInt64 ) SetError( SbxERR_ZERODIV );
+ else aL.nInt64 /= aR.nInt64;
else if( aL.eType == SbxLONG )
if( !aR.nLong ) SetError( SbxERR_ZERODIV );
else aL.nLong /= aR.nLong;
@@ -1236,14 +1089,12 @@ BOOL SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp )
else aL.nULong /= aR.nULong;
break;
case SbxMOD:
- if( aL.eType == SbxCURRENCY )
- aL.eType = SbxLONG64;
- if( aL.eType == SbxLONG64 )
- if( !aR.nLong64 ) SetError( SbxERR_ZERODIV );
- else aL.nLong64 %= aR.nLong64;
- else if( aL.eType == SbxULONG64 )
- if( !aR.nULong64 ) SetError( SbxERR_ZERODIV );
- else aL.nULong64 %= aR.nULong64;
+ if( aL.eType == SbxCURRENCY || aL.eType == SbxSALINT64 )
+ if( !aR.nInt64 ) SetError( SbxERR_ZERODIV );
+ else aL.nInt64 %= aR.nInt64;
+ else if( aL.eType == SbxSALUINT64 )
+ if( !aR.uInt64 ) SetError( SbxERR_ZERODIV );
+ else aL.uInt64 %= aR.uInt64;
else if( aL.eType == SbxLONG )
if( !aR.nLong ) SetError( SbxERR_ZERODIV );
else aL.nLong %= aR.nLong;
@@ -1253,31 +1104,31 @@ BOOL SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp )
break;
case SbxAND:
if( aL.eType != SbxLONG && aL.eType != SbxULONG )
- aL.nLong64 &= aR.nLong64;
+ aL.nInt64 &= aR.nInt64;
else
aL.nLong &= aR.nLong;
break;
case SbxOR:
if( aL.eType != SbxLONG && aL.eType != SbxULONG )
- aL.nLong64 |= aR.nLong64;
+ aL.nInt64 |= aR.nInt64;
else
aL.nLong |= aR.nLong;
break;
case SbxXOR:
if( aL.eType != SbxLONG && aL.eType != SbxULONG )
- aL.nLong64 ^= aR.nLong64;
+ aL.nInt64 ^= aR.nInt64;
else
aL.nLong ^= aR.nLong;
break;
case SbxEQV:
if( aL.eType != SbxLONG && aL.eType != SbxULONG )
- aL.nLong64 = (aL.nLong64 & aR.nLong64) | (~aL.nLong64 & ~aR.nLong64);
+ aL.nInt64 = (aL.nInt64 & aR.nInt64) | (~aL.nInt64 & ~aR.nInt64);
else
aL.nLong = (aL.nLong & aR.nLong) | (~aL.nLong & ~aR.nLong);
break;
case SbxIMP:
if( aL.eType != SbxLONG && aL.eType != SbxULONG )
- aL.nLong64 = ~aL.nLong64 | aR.nLong64;
+ aL.nInt64 = ~aL.nInt64 | aR.nInt64;
else
aL.nLong = ~aL.nLong | aR.nLong;
break;
@@ -1285,7 +1136,7 @@ BOOL SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp )
if( aL.eType != SbxLONG && aL.eType != SbxULONG )
{
if ( aL.eType != SbxBOOL )
- aL.nLong64 = ~aL.nLong64;
+ aL.nInt64 = ~aL.nInt64;
else
aL.nLong = ~aL.nLong;
}
@@ -1296,8 +1147,8 @@ BOOL SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp )
}
}
}
- else if( ( GetType() == SbxDECIMAL || rOp.GetType() == SbxDECIMAL ) &&
- ( eOp == SbxMUL || eOp == SbxDIV || eOp == SbxPLUS || eOp == SbxMINUS || eOp == SbxNEG ) )
+ else if( ( GetType() == SbxDECIMAL || rOp.GetType() == SbxDECIMAL )
+ && ( eOp == SbxMUL || eOp == SbxDIV || eOp == SbxPLUS || eOp == SbxMINUS || eOp == SbxNEG ) )
{
aL.eType = aR.eType = SbxDECIMAL;
bDecimal = true;
@@ -1348,57 +1199,86 @@ BOOL SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp )
}
else if( GetType() == SbxCURRENCY || rOp.GetType() == SbxCURRENCY )
{
+ double dTest;
aL.eType = SbxCURRENCY;
aR.eType = SbxCURRENCY;
if( rOp.Get( aR ) )
{
- static BigInt n10K( 10000 );
-
if( rOp.GetType() == SbxEMPTY )
goto Lbl_OpIsEmpty;
if( Get( aL ) ) switch( eOp )
{
case SbxMUL:
- {
- // #i20704 Implement directly
- BigInt b1( aL.nLong64 );
- BigInt b2( aR.nLong64 );
- b1 *= b2;
- b1 /= n10K;
- double d = double( b1 ) / 10000.0;
- if( d > SbxMAXCURR || d < SbxMINCURR )
+ // first overflow check: see if product will fit - test real value of product (hence 2 curr factors)
+ dTest = (double)aL.nInt64 * (double)aR.nInt64 / (double)CURRENCY_FACTOR_SQUARE;
+ if( dTest < SbxMINCURR || SbxMAXCURR < dTest)
+ {
+ aL.nInt64 = SAL_MAX_INT64;
+ if( dTest < SbxMINCURR ) aL.nInt64 = SAL_MIN_INT64;
SetError( SbxERR_OVERFLOW );
- else
- b1.INT64( &aL.nLong64 );
+ break;
+ }
+ // second overflow check: see if unscaled product overflows - if so use doubles
+ dTest = (double)aL.nInt64 * (double)aR.nInt64;
+ if( dTest < SAL_MIN_INT64 || SAL_MAX_INT64 < dTest)
+ {
+ aL.nInt64 = (sal_Int64)( dTest / (double)CURRENCY_FACTOR );
+ break;
+ }
+ // precise calc: multiply then scale back (move decimal pt)
+ aL.nInt64 *= aR.nInt64;
+ aL.nInt64 /= CURRENCY_FACTOR;
break;
- }
+
case SbxDIV:
- if( !aR.nLong64 )
+ if( !aR.nInt64 )
{
SetError( SbxERR_ZERODIV );
+ break;
}
- else
+ // first overflow check: see if quotient will fit - calc real value of quotient (curr factors cancel)
+ dTest = (double)aL.nInt64 / (double)aR.nInt64;
+ if( dTest < SbxMINCURR || SbxMAXCURR < dTest)
{
- // #i20704 Implement directly
- BigInt b1( aL.nLong64 );
- BigInt b2( aR.nLong64 );
- b1 *= n10K;
- b1 /= b2;
- double d = double( b1 ) / 10000.0;
- if( d > SbxMAXCURR || d < SbxMINCURR )
- SetError( SbxERR_OVERFLOW );
- else
- b1.INT64( &aL.nLong64 );
+ SetError( SbxERR_OVERFLOW );
+ break;
+ }
+ // second overflow check: see if scaled dividend overflows - if so use doubles
+ dTest = (double)aL.nInt64 * (double)CURRENCY_FACTOR;
+ if( dTest < SAL_MIN_INT64 || SAL_MAX_INT64 < dTest)
+ {
+ aL.nInt64 = (sal_Int64)(dTest / (double)aR.nInt64);
+ break;
}
+ // precise calc: scale (move decimal pt) then divide
+ aL.nInt64 *= CURRENCY_FACTOR;
+ aL.nInt64 /= aR.nInt64;
break;
+
case SbxPLUS:
- aL.nLong64 += aR.nLong64; break;
+ dTest = ( (double)aL.nInt64 + (double)aR.nInt64 ) / (double)CURRENCY_FACTOR;
+ if( dTest < SbxMINCURR || SbxMAXCURR < dTest)
+ {
+ SetError( SbxERR_OVERFLOW );
+ break;
+ }
+ aL.nInt64 += aR.nInt64;
+ break;
+
case SbxMINUS:
- aL.nLong64 -= aR.nLong64; break;
+ dTest = ( (double)aL.nInt64 - (double)aR.nInt64 ) / (double)CURRENCY_FACTOR;
+ if( dTest < SbxMINCURR || SbxMAXCURR < dTest)
+ {
+ SetError( SbxERR_OVERFLOW );
+ break;
+ }
+ aL.nInt64 -= aR.nInt64;
+ break;
case SbxNEG:
- aL.nLong64 = -aL.nLong64; break;
+ aL.nInt64 = -aL.nInt64;
+ break;
default:
SetError( SbxERR_NOTIMP );
}
@@ -1406,7 +1286,7 @@ BOOL SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp )
}
else
Lbl_OpIsDouble:
- { // other operators
+ { // other types and operators including Date, Double and Single
aL.eType = aR.eType = SbxDOUBLE;
if( rOp.Get( aR ) )
{
@@ -1429,6 +1309,9 @@ Lbl_OpIsDouble:
else aL.nDouble /= aR.nDouble; break;
case SbxPLUS:
aL.nDouble += aR.nDouble; break;
+ // #45465 Date needs with "+" a special handling: forces date type
+ if( GetType() == SbxDATE || rOp.GetType() == SbxDATE )
+ aL.eType = SbxDATE;
case SbxMINUS:
aL.nDouble -= aR.nDouble; break;
case SbxNEG:
@@ -1437,9 +1320,6 @@ Lbl_OpIsDouble:
SetError( SbxERR_NOTIMP );
}
- // #45465 Date needs with "+" a special handling
- if( eOp == SbxPLUS && (GetType() == SbxDATE || rOp.GetType() == SbxDATE ) )
- aL.eType = SbxDATE;
}
}
@@ -1622,6 +1502,8 @@ BOOL SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const
BOOL SbxValue::LoadData( SvStream& r, USHORT )
{
+ // #TODO see if these types are really dumped to any stream
+ // more than likely this is functionality used in the binfilter alone
SbxValue::Clear();
UINT16 nType;
r >> nType;
@@ -1662,15 +1544,21 @@ BOOL SbxValue::LoadData( SvStream& r, USHORT )
}
break;
}
- case SbxULONG64:
- {
- r >> aData.nULong64.nHigh >> aData.nULong64.nLow;
+ case SbxSALUINT64:
+ case SbxSALINT64:
+ // Rather ugly use of the union here because we only
+ // have a SvStream& SvStream::operator>>(sal_uInt64&) available to us
+ // There is no SvStream::operator>>(sal_Int64&) due to conflict with
+ // SvStream::operator>>(long&) ( at least on 64 bit linux )
+ r >> aData.uInt64;
break;
- }
- case SbxLONG64:
case SbxCURRENCY:
{
- r >> aData.nLong64.nHigh >> aData.nLong64.nLow;
+ sal_uInt32 tmpHi = 0;
+ sal_uInt32 tmpLo = 0;
+ r >> tmpHi >> tmpLo;
+ aData.nInt64 = ((sal_Int64)tmpHi << 32);
+ aData.nInt64 |= (sal_Int64)tmpLo;
break;
}
case SbxSTRING:
@@ -1779,15 +1667,16 @@ BOOL SbxValue::StoreData( SvStream& r ) const
case SbxDOUBLE:
r.WriteByteString( GetCoreString(), RTL_TEXTENCODING_ASCII_US );
break;
- case SbxULONG64:
- {
- r << aData.nULong64.nHigh << aData.nULong64.nLow;
+ case SbxSALUINT64:
+ case SbxSALINT64:
+ // see comment in SbxValue::StoreData
+ r << aData.uInt64;
break;
- }
- case SbxLONG64:
case SbxCURRENCY:
{
- r << aData.nLong64.nHigh << aData.nLong64.nLow;
+ sal_Int32 tmpHi = ( (aData.nInt64 >> 32) & 0xFFFFFFFF );
+ sal_Int32 tmpLo = ( sal_Int32 )aData.nInt64;
+ r << tmpHi << tmpLo;
break;
}
case SbxSTRING:
generated by cgit (git 2.34.1) at 2025-02-22 20:42:06 +0000