Revert "add sal*Int64 conversions to BigInt"
This reverts commit 5dae4238ea6e21df42f4437a43d152954fc494fd, which appears to
have ambiguitiy problems not only on Windows, but generally with 32-bit builds
like <https://ci.libreoffice.org/job/gerrit_android_x86/1518/>:
> /home/tdf/lode/jenkins/workspace/android_x86/tools/source/generic/bigint.cxx:501:18: error: conversion from 'int' to 'const BigInt' is ambiguous
> *this *= 10;
> ^~
> /home/tdf/lode/jenkins/workspace/android_x86/include/tools/bigint.hxx:58:5: note: candidate constructor
> BigInt(sal_Int32 nValue)
> ^
> /home/tdf/lode/jenkins/workspace/android_x86/include/tools/bigint.hxx:66:5: note: candidate constructor
> BigInt( double nVal );
> ^
> /home/tdf/lode/jenkins/workspace/android_x86/include/tools/bigint.hxx:67:5: note: candidate constructor
> BigInt( sal_uInt32 nVal );
> ^
> /home/tdf/lode/jenkins/workspace/android_x86/include/tools/bigint.hxx:68:5: note: candidate constructor
> BigInt( sal_Int64 nVal );
> ^
> /home/tdf/lode/jenkins/workspace/android_x86/include/tools/bigint.hxx:69:5: note: candidate constructor
> BigInt( sal_uInt64 nVal );
> ^
Change-Id: I674b14c342ece3e170185b7ce2f34ccb8ff91c7a
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/108186
Tested-by: Jenkins
Reviewed-by: Stephan Bergmann <sbergman@redhat.com>
diff --git a/include/tools/bigint.hxx b/include/tools/bigint.hxx
index ecf7ba0..a8d8575 100644
--- a/include/tools/bigint.hxx
+++ b/include/tools/bigint.hxx
@@ -63,23 +63,30 @@ public:
{
}
#if SAL_TYPES_SIZEOFLONG == 4
BigInt(int nValue)
: nVal(nValue)
, nLen(0)
, bIsNeg(false)
, bIsBig(false)
{
}
#endif
BigInt( double nVal );
BigInt( sal_uInt32 nVal );
BigInt( sal_Int64 nVal );
BigInt( sal_uInt64 nVal );
BigInt( const BigInt& rBigInt );
BigInt( const OUString& rString );
// for some conversions, MSVC does not see int as being equivalent to sal_Int*
#ifdef _WIN32
BigInt( int nVal ) : BigInt(static_cast<sal_Int64>(nVal)) {}
#endif
inline operator sal_Int16() const;
inline operator sal_uInt16() const;
inline operator sal_Int32() const;
operator sal_Int16() const;
operator sal_uInt16() const;
operator sal_Int32() const;
operator sal_uInt32() const;
operator sal_Int64() const;
operator sal_uInt64() const;
operator double() const;
#if SAL_TYPES_SIZEOFPOINTER == 8
operator tools::Long() const;
#endif
bool IsNeg() const;
bool IsZero() const;
@@ -94,13 +101,7 @@ public:
BigInt& operator /=( const BigInt& rVal );
BigInt& operator %=( const BigInt& rVal );
// for some conversions, MSVC does not see int as being equivalent to sal_Int*
#ifdef _WIN32
inline BigInt& operator =( int nValue ) { return operator=(static_cast<sal_Int64>(nValue)); }
#endif
inline BigInt& operator =( sal_Int32 nValue );
inline BigInt& operator =( sal_Int64 nValue ) { return *this = BigInt(nValue); }
inline BigInt& operator =( sal_uInt64 nValue ) { return *this = BigInt(nValue); }
BigInt& operator =( sal_Int32 nValue );
friend inline BigInt operator +( const BigInt& rVal1, const BigInt& rVal2 );
friend inline BigInt operator -( const BigInt& rVal1, const BigInt& rVal2 );
@@ -142,6 +143,25 @@ inline BigInt::operator sal_Int32() const
return 0;
}
inline BigInt::operator sal_uInt32() const
{
if ( !bIsBig && nVal >= 0 )
return static_cast<sal_uInt32>(nVal);
assert(false && "out of range");
return 0;
}
#if SAL_TYPES_SIZEOFPOINTER == 8
inline BigInt::operator tools::Long() const
{
// Clamp to int32 since long is int32 on Windows.
if (!bIsBig)
return nVal;
assert(false && "out of range");
return 0;
}
#endif
inline BigInt& BigInt::operator =( sal_Int32 nValue )
{
bIsBig = false;
diff --git a/tools/source/generic/bigint.cxx b/tools/source/generic/bigint.cxx
index 1239868..62350a3 100644
--- a/tools/source/generic/bigint.cxx
+++ b/tools/source/generic/bigint.cxx
@@ -594,83 +594,6 @@ BigInt::BigInt( sal_Int64 nValue )
}
}
BigInt::BigInt( sal_uInt64 nValue )
: nVal(0)
{
bIsNeg = false;
nLen = 0;
if (nValue <= SAL_MAX_INT32)
{
bIsBig = false;
nVal = static_cast<sal_Int32>(nValue);
}
else
{
bIsBig = true;
for (int i = 0; (i != sizeof(sal_uInt64) / 2) && (nValue != 0); ++i)
{
nNum[i] = static_cast<sal_uInt16>(nValue & 0xffffUL);
nValue = nValue >> 16;
++nLen;
}
}
}
BigInt::operator sal_uInt32() const
{
if ( !bIsBig )
{
assert(nVal >= 0 && "out of range");
return static_cast<sal_uInt32>(nVal);
}
else
{
assert(nLen <= 2 && "out of range");
assert(!bIsNeg && "out of range");
int i = nLen-1;
sal_uInt32 nRet = nNum[i];
while ( i )
{
nRet = nRet << 16;
i--;
nRet |= nNum[i];
}
return nRet;
}
}
BigInt::operator sal_Int64() const
{
if ( !bIsBig )
{
return nVal;
}
else
{
assert(nLen <= 4 && "out of range");
assert((nLen < 4 || nNum[4] <= SAL_MAX_INT16) && "out of range");
int i = nLen-1;
sal_Int64 nRet = nNum[i];
while ( i )
{
nRet = nRet << 16;
i--;
nRet |= nNum[i];
}
if ( bIsNeg )
nRet *= -1;
return nRet;
}
}
BigInt::operator double() const
{
if ( !bIsBig )
