Replace ASSERT with DHCECK_op in platform/wtf

third_party/WebKit/Source/platform/wtf/dtoa/strtod.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 101 matching lines @@
 
     static void TrimToMaxSignificantDigits(Vector<const char> buffer,
                                            int exponent,
                                            char* significant_buffer,
                                            int* significant_exponent) {
         for (int i = 0; i < kMaxSignificantDecimalDigits - 1; ++i) {
             significant_buffer[i] = buffer[i];
         }
         // The input buffer has been trimmed. Therefore the last digit must be
         // different from '0'.
-        ASSERT(buffer[buffer.length() - 1] != '0');
+        DCHECK_NE(buffer[buffer.length() - 1], '0');
         // Set the last digit to be non-zero. This is sufficient to guarantee
         // correct rounding.
         significant_buffer[kMaxSignificantDecimalDigits - 1] = '1';
         *significant_exponent =
         exponent + (buffer.length() - kMaxSignificantDecimalDigits);
     }
 
     // Reads digits from the buffer and converts them to a uint64.
     // Reads in as many digits as fit into a uint64.
     // When the string starts with "1844674407370955161" no further digit is read.
     // Since 2^64 = 18446744073709551616 it would still be possible read another
     // digit if it was less or equal than 6, but this would complicate the code.
     static uint64_t ReadUint64(Vector<const char> buffer,
                                int* number_of_read_digits) {
         uint64_t result = 0;
         int i = 0;
         while (i < buffer.length() && result <= (kMaxUint64 / 10 - 1)) {
             int digit = buffer[i++] - '0';
-            ASSERT(0 <= digit && digit <= 9);
+            DCHECK_LE(0, digit);
+            DCHECK_LE(digit, 9);
             result = 10 * result + digit;
         }
         *number_of_read_digits = i;
         return result;
     }
 
 
     // Reads a DiyFp from the buffer.
     // The returned DiyFp is not necessarily normalized.
     // If remaining_decimals is zero then the returned DiyFp is accurate.
@@ skipping 35 matching lines @@
             int read_digits;
             // The trimmed input fits into a double.
             // If the 10^exponent (resp. 10^-exponent) fits into a double too then we
             // can compute the result-double simply by multiplying (resp. dividing) the
             // two numbers.
             // This is possible because IEEE guarantees that floating-point operations
             // return the best possible approximation.
             if (exponent < 0 && -exponent < kExactPowersOfTenSize) {
                 // 10^-exponent fits into a double.
                 *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
-                ASSERT(read_digits == trimmed.length());
+                DCHECK_EQ(read_digits, trimmed.length());
                 *result /= exact_powers_of_ten[-exponent];
                 return true;
             }
             if (0 <= exponent && exponent < kExactPowersOfTenSize) {
                 // 10^exponent fits into a double.
                 *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
-                ASSERT(read_digits == trimmed.length());
+                DCHECK_EQ(read_digits, trimmed.length());
                 *result *= exact_powers_of_ten[exponent];
                 return true;
             }
             int remaining_digits =
             kMaxExactDoubleIntegerDecimalDigits - trimmed.length();
             if ((0 <= exponent) &&
                 (exponent - remaining_digits < kExactPowersOfTenSize)) {
                 // The trimmed string was short and we can multiply it with
                 // 10^remaining_digits. As a result the remaining exponent now fits
                 // into a double too.
                 *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
-                ASSERT(read_digits == trimmed.length());
+                DCHECK_EQ(read_digits, trimmed.length());
                 *result *= exact_powers_of_ten[remaining_digits];
                 *result *= exact_powers_of_ten[exponent - remaining_digits];
                 return true;
             }
         }
         return false;
     }
 
 
     // Returns 10^exponent as an exact DiyFp.
     // The given exponent must be in the range [1; kDecimalExponentDistance[.
     static DiyFp AdjustmentPowerOfTen(int exponent) {
-        ASSERT(0 < exponent);
-        ASSERT(exponent < PowersOfTenCache::kDecimalExponentDistance);
+        DCHECK_LT(0, exponent);
+        DCHECK_LT(exponent, PowersOfTenCache::kDecimalExponentDistance);
         // Simply hardcode the remaining powers for the given decimal exponent
         // distance.
-        ASSERT(PowersOfTenCache::kDecimalExponentDistance == 8);
+        DCHECK_EQ(PowersOfTenCache::kDecimalExponentDistance, 8);
         switch (exponent) {
             case 1: return DiyFp(UINT64_2PART_C(0xa0000000, 00000000), -60);
             case 2: return DiyFp(UINT64_2PART_C(0xc8000000, 00000000), -57);
             case 3: return DiyFp(UINT64_2PART_C(0xfa000000, 00000000), -54);
             case 4: return DiyFp(UINT64_2PART_C(0x9c400000, 00000000), -50);
             case 5: return DiyFp(UINT64_2PART_C(0xc3500000, 00000000), -47);
             case 6: return DiyFp(UINT64_2PART_C(0xf4240000, 00000000), -44);
             case 7: return DiyFp(UINT64_2PART_C(0x98968000, 00000000), -40);
             default:
                 UNREACHABLE();
@@ skipping 19 matching lines @@
         const int kDenominatorLog = 3;
         const int kDenominator = 1 << kDenominatorLog;
         // Move the remaining decimals into the exponent.
         exponent += remaining_decimals;
         int64_t error = (remaining_decimals == 0 ? 0 : kDenominator / 2);
 
         int old_e = input.E();
         input.Normalize();
         error <<= old_e - input.E();
 
-        ASSERT(exponent <= PowersOfTenCache::kMaxDecimalExponent);
+        DCHECK_LE(exponent, PowersOfTenCache::kMaxDecimalExponent);
         if (exponent < PowersOfTenCache::kMinDecimalExponent) {
             *result = 0.0;
             return true;
         }
         DiyFp cached_power;
         int cached_decimal_exponent;
         PowersOfTenCache::GetCachedPowerForDecimalExponent(exponent,
                                                            &cached_power,
                                                            &cached_decimal_exponent);
 
         if (cached_decimal_exponent != exponent) {
             int adjustment_exponent = exponent - cached_decimal_exponent;
             DiyFp adjustment_power = AdjustmentPowerOfTen(adjustment_exponent);
             input.Multiply(adjustment_power);
             if (kMaxUint64DecimalDigits - buffer.length() >= adjustment_exponent) {
                 // The product of input with the adjustment power fits into a 64 bit
                 // integer.
-                ASSERT(DiyFp::kSignificandSize == 64);
+                DCHECK_EQ(DiyFp::kSignificandSize, 64);
             } else {
                 // The adjustment power is exact. There is hence only an error of 0.5.
                 error += kDenominator / 2;
             }
         }
 
         input.Multiply(cached_power);
         // The error introduced by a multiplication of a*b equals
         //   error_a + error_b + error_a*error_b/2^64 + 0.5
         // Substituting a with 'input' and b with 'cached_power' we have
@@ skipping 21 matching lines @@
             int shift_amount = (precision_digits_count + kDenominatorLog) -
             DiyFp::kSignificandSize + 1;
             input.set_f(input.F() >> shift_amount);
             input.set_e(input.E() + shift_amount);
             // We add 1 for the lost precision of error, and kDenominator for
             // the lost precision of input.f().
             error = (error >> shift_amount) + 1 + kDenominator;
             precision_digits_count -= shift_amount;
         }
         // We use uint64_ts now. This only works if the DiyFp uses uint64_ts too.
-        ASSERT(DiyFp::kSignificandSize == 64);
-        ASSERT(precision_digits_count < 64);
+        DCHECK_EQ(DiyFp::kSignificandSize, 64);
+        DCHECK_LT(precision_digits_count, 64);
         uint64_t one64 = 1;
         uint64_t precision_bits_mask = (one64 << precision_digits_count) - 1;
         uint64_t precision_bits = input.F() & precision_bits_mask;
         uint64_t half_way = one64 << (precision_digits_count - 1);
         precision_bits *= kDenominator;
         half_way *= kDenominator;
         DiyFp rounded_input(input.F() >> precision_digits_count,
                             input.E() + precision_digits_count);
         if (precision_bits >= half_way + error) {
           rounded_input.set_f(rounded_input.F() + 1);
@@ skipping 23 matching lines @@
     //   buffer.length() <= kMaxDecimalSignificantDigits
     static double BignumStrtod(Vector<const char> buffer,
                                int exponent,
                                double guess) {
         if (guess == Double::Infinity()) {
             return guess;
         }
 
         DiyFp upper_boundary = Double(guess).UpperBoundary();
 
-        ASSERT(buffer.length() + exponent <= kMaxDecimalPower + 1);
-        ASSERT(buffer.length() + exponent > kMinDecimalPower);
-        ASSERT(buffer.length() <= kMaxSignificantDecimalDigits);
+        DCHECK_LE(buffer.length() + exponent, kMaxDecimalPower + 1);
+        DCHECK_GT(buffer.length() + exponent, kMinDecimalPower);
+        DCHECK_LE(buffer.length(), kMaxSignificantDecimalDigits);
         // Make sure that the Bignum will be able to hold all our numbers.
         // Our Bignum implementation has a separate field for exponents. Shifts will
         // consume at most one bigit (< 64 bits).
         // ln(10) == 3.3219...
-        ASSERT(((kMaxDecimalPower + 1) * 333 / 100) < Bignum::kMaxSignificantBits);
+        DCHECK_LT(((kMaxDecimalPower + 1) * 333 / 100), Bignum::kMaxSignificantBits);
         Bignum input;
         Bignum boundary;
         input.AssignDecimalString(buffer);
         boundary.AssignUInt64(upper_boundary.F());
         if (exponent >= 0) {
             input.MultiplyByPowerOfTen(exponent);
         } else {
             boundary.MultiplyByPowerOfTen(-exponent);
         }
         if (upper_boundary.E() > 0) {
@@ skipping 40 matching lines @@
         if (DoubleStrtod(trimmed, exponent, &guess) ||
             DiyFpStrtod(trimmed, exponent, &guess)) {
             return guess;
         }
         return BignumStrtod(trimmed, exponent, guess);
     }
 
 }  // namespace double_conversion
 
 } // namespace WTF