Modify big integer library

third_party/bigint/BigInteger.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 BIGINTEGER_H
 #define BIGINTEGER_H
 
 #include "BigUnsigned.hh"
 
 /* A BigInteger object represents a signed integer of size limited only by
  * available memory.  BigUnsigneds support most mathematical operators and can
  * be converted to and from most primitive integer types.
  *
  * A BigInteger is just an aggregate of a BigUnsigned and a sign.  (It is no
@@ skipping 139 matching lines @@
         BigInteger ans;
         ans.subtract(*this, x);
         return ans;
 }
 inline BigInteger BigInteger::operator *(const BigInteger &x) const {
         BigInteger ans;
         ans.multiply(*this, x);
         return ans;
 }
 inline BigInteger BigInteger::operator /(const BigInteger &x) const {
-        if (x.isZero()) throw "BigInteger::operator /: division by zero";
+        if (x.isZero())
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
+        throw "BigInteger::operator /: division by zero";
+#endif
         BigInteger q, r;
         r = *this;
         r.divideWithRemainder(x, q);
         return q;
 }
 inline BigInteger BigInteger::operator %(const BigInteger &x) const {
-        if (x.isZero()) throw "BigInteger::operator %: division by zero";
+        if (x.isZero())
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
+        throw "BigInteger::operator %: division by zero";
+#endif
         BigInteger q, r;
         r = *this;
         r.divideWithRemainder(x, q);
         return r;
 }
 inline BigInteger BigInteger::operator -() const {
         BigInteger ans;
         ans.negate(*this);
         return ans;
 }
 
 /*
  * ASSIGNMENT OPERATORS
  * 
  * Now the responsibility for making a temporary copy if necessary
  * belongs to the put-here operations.  See Assignment Operators in
  * BigUnsigned.hh.
  */
 inline void BigInteger::operator +=(const BigInteger &x) {
         add(*this, x);
 }
 inline void BigInteger::operator -=(const BigInteger &x) {
         subtract(*this, x);
 }
 inline void BigInteger::operator *=(const BigInteger &x) {
         multiply(*this, x);
 }
 inline void BigInteger::operator /=(const BigInteger &x) {
-        if (x.isZero()) throw "BigInteger::operator /=: division by zero";
+        if (x.isZero())
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
+        throw "BigInteger::operator /=: division by zero";
+#endif
         /* The following technique is slightly faster than copying *this first
          * when x is large. */
         BigInteger q;
         divideWithRemainder(x, q);
         // *this contains the remainder, but we overwrite it with the quotient.
         *this = q;
 }
 inline void BigInteger::operator %=(const BigInteger &x) {
-        if (x.isZero()) throw "BigInteger::operator %=: division by zero";
+        if (x.isZero())
+#ifdef FOXIT_CHROME_BUILD
+        abort();
+#else
+        throw "BigInteger::operator %=: division by zero";
+#endif
         BigInteger q;
         // Mods *this by x.  Don't care about quotient left in q.
         divideWithRemainder(x, q);
 }
 // This one is trivial
 inline void BigInteger::flipSign() {
         sign = Sign(-sign);
 }
 
 #endif