Modify big integer library

third_party/bigint/BigInteger.cc

+// 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.
+
 #include "BigInteger.hh"
 
 void BigInteger::operator =(const BigInteger &x) {
         // Calls like a = a have no effect
         if (this == &x)
                 return;
         // Copy sign
         sign = x.sign;
         // Copy the rest
         mag = x.mag;
 }
 
 BigInteger::BigInteger(const Blk *b, Index blen, Sign s) : mag(b, blen) {
         switch (s) {
         case zero:
                 if (!mag.isZero())
+#ifdef FOXIT_CHROME_BUILD
+            abort();
+#else
                         throw "BigInteger::BigInteger(const Blk *, Index, Sign): Cannot use a sign of zero with a nonzero magnitude";
+#endif
                 sign = zero;
                 break;
         case positive:
         case negative:
                 // If the magnitude is zero, force the sign to zero.
                 sign = mag.isZero() ? zero : s;
                 break;
         default:
                 /* g++ seems to be optimizing out this case on the assumption
                  * that the sign is a valid member of the enumeration.  Oh well. */
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
                 throw "BigInteger::BigInteger(const Blk *, Index, Sign): Invalid sign";
+#endif
         }
 }
 
 BigInteger::BigInteger(const BigUnsigned &x, Sign s) : mag(x) {
         switch (s) {
         case zero:
                 if (!mag.isZero())
+#ifdef FOXIT_CHROME_BUILD
+            abort();
+#else
                         throw "BigInteger::BigInteger(const BigUnsigned &, Sign): Cannot use a sign of zero with a nonzero magnitude";
+#endif
                 sign = zero;
                 break;
         case positive:
         case negative:
                 // If the magnitude is zero, force the sign to zero.
                 sign = mag.isZero() ? zero : s;
                 break;
         default:
                 /* g++ seems to be optimizing out this case on the assumption
                  * that the sign is a valid member of the enumeration.  Oh well. */
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
                 throw "BigInteger::BigInteger(const BigUnsigned &, Sign): Invalid sign";
+#endif
         }
 }
 
 /* CONSTRUCTION FROM PRIMITIVE INTEGERS
  * Same idea as in BigUnsigned.cc, except that negative input results in a
  * negative BigInteger instead of an exception. */
 
 // Done longhand to let us use initialization.
 BigInteger::BigInteger(unsigned long  x) : mag(x) { sign = mag.isZero() ? zero : positive; }
 BigInteger::BigInteger(unsigned int   x) : mag(x) { sign = mag.isZero() ? zero : positive; }
@@ skipping 27 matching lines @@
  * BigInteger::convertToUnsignedPrimitive to avoid requiring BigUnsigned to
  * declare BigInteger. */
 template <class X>
 inline X convertBigUnsignedToPrimitiveAccess(const BigUnsigned &a) {
         return a.convertToPrimitive<X>();
 }
 
 template <class X>
 X BigInteger::convertToUnsignedPrimitive() const {
         if (sign == negative)
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
                 throw "BigInteger::to<Primitive>: "
                         "Cannot convert a negative integer to an unsigned type";
+#endif
         else
                 return convertBigUnsignedToPrimitiveAccess<X>(mag);
 }
 
 /* Similar to BigUnsigned::convertToPrimitive, but split into two cases for
  * nonnegative and negative numbers. */
 template <class X, class UX>
 X BigInteger::convertToSignedPrimitive() const {
         if (sign == zero)
                 return 0;
         else if (mag.getLength() == 1) {
                 // The single block might fit in an X.  Try the conversion.
                 Blk b = mag.getBlock(0);
                 if (sign == positive) {
                         X x = X(b);
                         if (x >= 0 && Blk(x) == b)
                                 return x;
                 } else {
                         X x = -X(b);
                         /* UX(...) needed to avoid rejecting conversion of
                          * -2^15 to a short. */
                         if (x < 0 && Blk(UX(-x)) == b)
                                 return x;
                 }
                 // Otherwise fall through.
         }
+#ifdef FOXIT_CHROME_BUILD
+    abort();
+#else
         throw "BigInteger::to<Primitive>: "
                 "Value is too big to fit in the requested type";
+#endif
 }
 
 unsigned long  BigInteger::toUnsignedLong () const { return convertToUnsignedPrimitive<unsigned long >       (); }
 unsigned int   BigInteger::toUnsignedInt  () const { return convertToUnsignedPrimitive<unsigned int  >       (); }
 unsigned short BigInteger::toUnsignedShort() const { return convertToUnsignedPrimitive<unsigned short>       (); }
 long           BigInteger::toLong         () const { return convertToSignedPrimitive  <long , unsigned long> (); }
 int            BigInteger::toInt          () const { return convertToSignedPrimitive  <int  , unsigned int>  (); }
 short          BigInteger::toShort        () const { return convertToSignedPrimitive  <short, unsigned short>(); }
 
 // COMPARISON
 BigInteger::CmpRes BigInteger::compareTo(const BigInteger &x) const {
         // A greater sign implies a greater number
         if (sign < x.sign)
                 return less;
         else if (sign > x.sign)
                 return greater;
         else switch (sign) {
                 // If the signs are the same...
         case zero:
                 return equal; // Two zeros are equal
         case positive:
                 // Compare the magnitudes
                 return mag.compareTo(x.mag);
         case negative:
                 // Compare the magnitudes, but return the opposite result
                 return CmpRes(-mag.compareTo(x.mag));
         default:
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
                 throw "BigInteger internal error";
+#endif
         }
 }
 
 /* COPY-LESS OPERATIONS
  * These do some messing around to determine the sign of the result,
  * then call one of BigUnsigned's copy-less operations. */
 
 // See remarks about aliased calls in BigUnsigned.cc .
 #define DTRT_ALIASED(cond, op) \
         if (cond) { \
@@ skipping 111 matching lines @@
  *      ===     ===     ===     ===
  *      4       3       1       1
  *      -4      3       -2      2
  *      4       -3      -2      -2
  *      -4      -3      1       -1
  */
 void BigInteger::divideWithRemainder(const BigInteger &b, BigInteger &q) {
         // Defend against aliased calls;
         // same idea as in BigUnsigned::divideWithRemainder .
         if (this == &q)
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
                 throw "BigInteger::divideWithRemainder: Cannot write quotient and remainder into the same variable";
+#endif
         if (this == &b || &q == &b) {
                 BigInteger tmpB(b);
                 divideWithRemainder(tmpB, q);
                 return;
         }
 
         // Division by zero gives quotient 0 and remainder *this
         if (b.sign == zero) {
                 q.mag = 0;
                 q.sign = zero;
@@ skipping 101 matching lines @@
                 mag++;
                 sign = negative;
         }
 }
 
 // Postfix decrement: same as prefix
 void BigInteger::operator --(int) {
         operator --();
 }