Modify big integer library

third_party/bigint/BigUnsigned.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 "BigUnsigned.hh"
 
 // Memory management definitions have moved to the bottom of NumberlikeArray.hh.
 
 // The templates used by these constructors and converters are at the bottom of
 // BigUnsigned.hh.
 
 BigUnsigned::BigUnsigned(unsigned long  x) { initFromPrimitive      (x); }
 BigUnsigned::BigUnsigned(unsigned int   x) { initFromPrimitive      (x); }
 BigUnsigned::BigUnsigned(unsigned short x) { initFromPrimitive      (x); }
@@ skipping 171 matching lines @@
 }
 
 void BigUnsigned::subtract(const BigUnsigned &a, const BigUnsigned &b) {
         DTRT_ALIASED(this == &a || this == &b, subtract(a, b));
         if (b.len == 0) {
                 // If b is zero, copy a.
                 operator =(a);
                 return;
         } else if (a.len < b.len)
                 // If a is shorter than b, the result is negative.
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
                 throw "BigUnsigned::subtract: "
                         "Negative result in unsigned calculation";
+#endif
         // Some variables...
         bool borrowIn, borrowOut;
         Blk temp;
         Index i;
         // Set preliminary length and make room
         len = a.len;
         allocate(len);
         // For each block index that is present in both inputs...
         for (i = 0, borrowIn = false; i < b.len; i++) {
                 temp = a.blk[i] - b.blk[i];
@@ skipping 12 matching lines @@
         // one does not reverse rollover.
         for (; i < a.len && borrowIn; i++) {
                 borrowIn = (a.blk[i] == 0);
                 blk[i] = a.blk[i] - 1;
         }
         /* If there's still a borrow, the result is negative.
          * Throw an exception, but zero out this object so as to leave it in a
          * predictable state. */
         if (borrowIn) {
                 len = 0;
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
                 throw "BigUnsigned::subtract: Negative result in unsigned calculation";
+#endif
         } else
                 // Copy over the rest of the blocks
                 for (; i < a.len; i++)
                         blk[i] = a.blk[i];
         // Zap leading zeros
         zapLeadingZeros();
 }
 
 /*
  * About the multiplication and division algorithms:
@@ skipping 142 matching lines @@
  * "modWithQuotient" might be a better name for this function, but I would
  * rather not change the name now.
  */
 void BigUnsigned::divideWithRemainder(const BigUnsigned &b, BigUnsigned &q) {
         /* Defending against aliased calls is more complex than usual because we
          * are writing to both *this and q.
          * 
          * It would be silly to try to write quotient and remainder to the
          * same variable.  Rule that out right away. */
         if (this == &q)
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
                 throw "BigUnsigned::divideWithRemainder: Cannot write quotient and remainder into the same variable";
+#endif
         /* Now *this and q are separate, so the only concern is that b might be
          * aliased to one of them.  If so, use a temporary copy of b. */
         if (this == &b || &q == &b) {
                 BigUnsigned tmpB(b);
                 divideWithRemainder(tmpB, q);
                 return;
         }
 
         /*
          * Knuth's definition of mod (which this function uses) is somewhat
@@ skipping 189 matching lines @@
         for (; i < a2->len; i++)
                 blk[i] = a2->blk[i];
         len = a2->len;
         zapLeadingZeros();
 }
 
 void BigUnsigned::bitShiftLeft(const BigUnsigned &a, int b) {
         DTRT_ALIASED(this == &a, bitShiftLeft(a, b));
         if (b < 0) {
                 if (b << 1 == 0)
+#ifdef FOXIT_CHROME_BUILD
+            abort();
+#else
                         throw "BigUnsigned::bitShiftLeft: "
                                 "Pathological shift amount not implemented";
+#endif
                 else {
                         bitShiftRight(a, -b);
                         return;
                 }
         }
         Index shiftBlocks = b / N;
         unsigned int shiftBits = b % N;
         // + 1: room for high bits nudged left into another block
         len = a.len + shiftBlocks + 1;
         allocate(len);
         Index i, j;
         for (i = 0; i < shiftBlocks; i++)
                 blk[i] = 0;
         for (j = 0, i = shiftBlocks; j <= a.len; j++, i++)
                 blk[i] = getShiftedBlock(a, j, shiftBits);
         // Zap possible leading zero
         if (blk[len - 1] == 0)
                 len--;
 }
 
 void BigUnsigned::bitShiftRight(const BigUnsigned &a, int b) {
         DTRT_ALIASED(this == &a, bitShiftRight(a, b));
         if (b < 0) {
                 if (b << 1 == 0)
+#ifdef FOXIT_CHROME_BUILD
+            abort();
+#else
                         throw "BigUnsigned::bitShiftRight: "
                                 "Pathological shift amount not implemented";
+#endif
                 else {
                         bitShiftLeft(a, -b);
                         return;
                 }
         }
         // This calculation is wacky, but expressing the shift as a left bit shift
         // within each block lets us use getShiftedBlock.
         Index rightShiftBlocks = (b + N - 1) / N;
         unsigned int leftShiftBits = N * rightShiftBlocks - b;
         // Now (N * rightShiftBlocks - leftShiftBits) == b
@@ skipping 35 matching lines @@
 }
 
 // Postfix increment: same as prefix
 void BigUnsigned::operator ++(int) {
         operator ++();
 }
 
 // Prefix decrement
 void BigUnsigned::operator --() {
         if (len == 0)
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
                 throw "BigUnsigned::operator --(): Cannot decrement an unsigned zero";
+#endif
         Index i;
         bool borrow = true;
         for (i = 0; borrow; i++) {
                 borrow = (blk[i] == 0);
                 blk[i]--;
         }
         // Zap possible leading zero (there can only be one)
         if (blk[len - 1] == 0)
                 len--;
 }
 
 // Postfix decrement: same as prefix
 void BigUnsigned::operator --(int) {
         operator --();
 }