Rename ASSERT* to DCHECK*.

src/strtod.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdarg.h>
 #include <cmath>
 
 #include "src/v8.h"
 
 #include "src/bignum.h"
@@ skipping 81 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(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(0 <= digit && 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 37 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(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(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(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(0 < exponent);
+  DCHECK(exponent < PowersOfTenCache::kDecimalExponentDistance);
   // Simply hardcode the remaining powers for the given decimal exponent
   // distance.
-  ASSERT(PowersOfTenCache::kDecimalExponentDistance == 8);
+  DCHECK(PowersOfTenCache::kDecimalExponentDistance == 8);
   switch (exponent) {
     case 1: return DiyFp(V8_2PART_UINT64_C(0xa0000000, 00000000), -60);
     case 2: return DiyFp(V8_2PART_UINT64_C(0xc8000000, 00000000), -57);
     case 3: return DiyFp(V8_2PART_UINT64_C(0xfa000000, 00000000), -54);
     case 4: return DiyFp(V8_2PART_UINT64_C(0x9c400000, 00000000), -50);
     case 5: return DiyFp(V8_2PART_UINT64_C(0xc3500000, 00000000), -47);
     case 6: return DiyFp(V8_2PART_UINT64_C(0xf4240000, 00000000), -44);
     case 7: return DiyFp(V8_2PART_UINT64_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(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(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(DiyFp::kSignificandSize == 64);
+  DCHECK(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 == V8_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(buffer.length() + exponent <= kMaxDecimalPower + 1);
+  DCHECK(buffer.length() + exponent > kMinDecimalPower);
+  DCHECK(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(((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 34 matching lines @@
 
   double guess;
   if (DoubleStrtod(trimmed, exponent, &guess) ||
       DiyFpStrtod(trimmed, exponent, &guess)) {
     return guess;
   }
   return BignumStrtod(trimmed, exponent, guess);
 }
 
 } }  // namespace v8::internal