[Libreoffice-commits] core.git: include/tools tools/source

[Noel Grandin (via logerrit)]

 include/tools/bigint.hxx        |   54 ++++++++--------------------
 tools/source/generic/bigint.cxx |   77 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 94 insertions(+), 37 deletions(-)

New commits:
commit 5dae4238ea6e21df42f4437a43d152954fc494fd
Author:     Noel Grandin <noel at peralex.com>
AuthorDate: Wed Dec 23 10:57:00 2020 +0200
Commit:     Noel Grandin <noel.grandin at collabora.co.uk>
CommitDate: Thu Dec 24 12:00:35 2020 +0100

    add sal*Int64 conversions to BigInt
    
    we have the capability, so lets use it
    
    Change-Id: Ie5aa7999bb457d274bbcc07ba5c4e6ee2f286df1
    Reviewed-on: https://gerrit.libreoffice.org/c/core/+/108231
    Tested-by: Jenkins
    Reviewed-by: Noel Grandin <noel.grandin at collabora.co.uk>

diff --git a/include/tools/bigint.hxx b/include/tools/bigint.hxx
index a8d8575fb53b..ecf7ba05b96a 100644
--- a/include/tools/bigint.hxx
+++ b/include/tools/bigint.hxx
@@ -63,30 +63,23 @@ 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 );
-
-    operator        sal_Int16() const;
-    operator        sal_uInt16() const;
-    operator        sal_Int32() const;
+// 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_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;
@@ -101,7 +94,13 @@ public:
     BigInt&         operator /=( const BigInt& rVal );
     BigInt&         operator %=( const BigInt& rVal );
 
-    BigInt&         operator  =( sal_Int32 nValue );
+// 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); }
 
     friend inline   BigInt operator +( const BigInt& rVal1, const BigInt& rVal2 );
     friend inline   BigInt operator -( const BigInt& rVal1, const BigInt& rVal2 );
@@ -143,25 +142,6 @@ 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 62350a30c311..1239868b1432 100644
--- a/tools/source/generic/bigint.cxx
+++ b/tools/source/generic/bigint.cxx
@@ -594,6 +594,83 @@ 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 )