Modify big integer library

third_party/bigint/BigUnsigned.hh

+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code by Matt McCutchen, see the LICENSE file
+
 #ifndef BIGUNSIGNED_H
 #define BIGUNSIGNED_H
 
 #include "NumberlikeArray.hh"
 
 /* A BigUnsigned object represents a nonnegative integer of size limited only by
  * available memory.  BigUnsigneds support most mathematical operators and can
  * be converted to and from most primitive integer types.
  *
  * The number is stored as a NumberlikeArray of unsigned longs as if it were
  * written in base 256^sizeof(unsigned long).  The least significant block is
  * first, and the length is such that the most significant block is nonzero. */
 class BigUnsigned : protected NumberlikeArray<unsigned long> {
 
 public:
         // Enumeration for the result of a comparison.
         enum CmpRes { less = -1, equal = 0, greater = 1 };
 
         // BigUnsigneds are built with a Blk type of unsigned long.
         typedef unsigned long Blk;
 
         typedef NumberlikeArray<Blk>::Index Index;
-        NumberlikeArray<Blk>::N;
+        using NumberlikeArray<Blk>::N;
 
 protected:
         // Creates a BigUnsigned with a capacity; for internal use.
         BigUnsigned(int, Index c) : NumberlikeArray<Blk>(0, c) {}
 
         // Decreases len to eliminate any leading zero blocks.
         void zapLeadingZeros() { 
                 while (len > 0 && blk[len - 1] == 0)
                         len--;
         }
@@ skipping 43 matching lines @@
         short          toShort        () const;
 protected:
         // Helpers
         template <class X> X convertToSignedPrimitive() const;
         template <class X> X convertToPrimitive      () const;
 public:
 
         // BIT/BLOCK ACCESSORS
 
         // Expose these from NumberlikeArray directly.
-        NumberlikeArray<Blk>::getCapacity;
-        NumberlikeArray<Blk>::getLength;
+        using NumberlikeArray<Blk>::getCapacity;

[Tom Sepez, 2014/12/03 00:14:19]

Why do we need to do this?

[Bo Xu, 2014/12/03 00:31:22]

Otherwise the C++11 compiler complains:"ISO C+11 does not allow access
declaration; use using declarations instead".

http://stackoverflow.com/questions/24641552/xcode-5-1-1-complaining-iso-c11-d...

+        using NumberlikeArray<Blk>::getLength;
 
         /* Returns the requested block, or 0 if it is beyond the length (as if
          * the number had 0s infinitely to the left). */
         Blk getBlock(Index i) const { return i >= len ? 0 : blk[i]; }
         /* Sets the requested block.  The number grows or shrinks as necessary. */
         void setBlock(Index i, Blk newBlock);
 
         // The number is zero if and only if the canonical length is zero.
         bool isZero() const { return NumberlikeArray<Blk>::isEmpty(); }
 
@@ skipping 154 matching lines @@
         BigUnsigned ans;
         ans.subtract(*this, x);
         return ans;
 }
 inline BigUnsigned BigUnsigned::operator *(const BigUnsigned &x) const {
         BigUnsigned ans;
         ans.multiply(*this, x);
         return ans;
 }
 inline BigUnsigned BigUnsigned::operator /(const BigUnsigned &x) const {
-        if (x.isZero()) throw "BigUnsigned::operator /: division by zero";
+        if (x.isZero())
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
+        throw "BigUnsigned::operator /: division by zero";
+#endif
         BigUnsigned q, r;
         r = *this;
         r.divideWithRemainder(x, q);
         return q;
 }
 inline BigUnsigned BigUnsigned::operator %(const BigUnsigned &x) const {
-        if (x.isZero()) throw "BigUnsigned::operator %: division by zero";
+        if (x.isZero())
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
+        throw "BigUnsigned::operator %: division by zero";
+#endif
         BigUnsigned q, r;
         r = *this;
         r.divideWithRemainder(x, q);
         return r;
 }
 inline BigUnsigned BigUnsigned::operator &(const BigUnsigned &x) const {
         BigUnsigned ans;
         ans.bitAnd(*this, x);
         return ans;
 }
@@ skipping 21 matching lines @@
 inline void BigUnsigned::operator +=(const BigUnsigned &x) {
         add(*this, x);
 }
 inline void BigUnsigned::operator -=(const BigUnsigned &x) {
         subtract(*this, x);
 }
 inline void BigUnsigned::operator *=(const BigUnsigned &x) {
         multiply(*this, x);
 }
 inline void BigUnsigned::operator /=(const BigUnsigned &x) {
-        if (x.isZero()) throw "BigUnsigned::operator /=: division by zero";
+        if (x.isZero())
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
+        throw "BigUnsigned::operator /=: division by zero";
+#endif
         /* The following technique is slightly faster than copying *this first
          * when x is large. */
         BigUnsigned q;
         divideWithRemainder(x, q);
         // *this contains the remainder, but we overwrite it with the quotient.
         *this = q;
 }
 inline void BigUnsigned::operator %=(const BigUnsigned &x) {
-        if (x.isZero()) throw "BigUnsigned::operator %=: division by zero";
+        if (x.isZero())
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
+        throw "BigUnsigned::operator %=: division by zero";
+#endif
         BigUnsigned q;
         // Mods *this by x.  Don't care about quotient left in q.
         divideWithRemainder(x, q);
 }
 inline void BigUnsigned::operator &=(const BigUnsigned &x) {
         bitAnd(*this, x);
 }
 inline void BigUnsigned::operator |=(const BigUnsigned &x) {
         bitOr(*this, x);
 }
@@ skipping 33 matching lines @@
         }
 }
 
 /* Ditto, but first check that x is nonnegative.  I could have put the check in
  * initFromPrimitive and let the compiler optimize it out for unsigned-type
  * instantiations, but I wanted to avoid the warning stupidly issued by g++ for
  * a condition that is constant in *any* instantiation, even if not in all. */
 template <class X>
 void BigUnsigned::initFromSignedPrimitive(X x) {
         if (x < 0)
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
                 throw "BigUnsigned constructor: "
                         "Cannot construct a BigUnsigned from a negative number";
+#endif
         else
                 initFromPrimitive(x);
 }
 
 // CONVERSION TO PRIMITIVE INTEGERS
 
 /* Template with the same idea as initFromPrimitive.  This might be slightly
  * slower than the previous version with the masks, but it's much shorter and
  * clearer, which is the library's stated goal. */
 template <class X>
 X BigUnsigned::convertToPrimitive() const {
         if (len == 0)
                 // The number is zero; return zero.
                 return 0;
         else if (len == 1) {
                 // The single block might fit in an X.  Try the conversion.
                 X x = X(blk[0]);
                 // Make sure the result accurately represents the block.
                 if (Blk(x) == blk[0])
                         // Successful conversion.
                         return x;
                 // Otherwise fall through.
         }
+#ifdef FOXIT_CHROME_BUILD
+    abort();
+#else
         throw "BigUnsigned::to<Primitive>: "
                 "Value is too big to fit in the requested type";
+#endif
 }
 
 /* Wrap the above in an x >= 0 test to make sure we got a nonnegative result,
  * not a negative one that happened to convert back into the correct nonnegative
  * one.  (E.g., catch incorrect conversion of 2^31 to the long -2^31.)  Again,
  * separated to avoid a g++ warning. */
 template <class X>
 X BigUnsigned::convertToSignedPrimitive() const {
         X x = convertToPrimitive<X>();
         if (x >= 0)
                 return x;
         else
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
                 throw "BigUnsigned::to(Primitive): "
                         "Value is too big to fit in the requested type";
+#endif
 }
 
 #endif