Rename ASSERT* to DCHECK*.

src/fixed-dtoa.cc

 // Copyright 2011 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 <cmath>
 
 #include "include/v8stdint.h"
 #include "src/base/logging.h"
 #include "src/utils.h"
 
@@ skipping 17 matching lines @@
     uint32_t part = static_cast<uint32_t>(accumulator & kMask32);
     accumulator >>= 32;
     accumulator = accumulator + (low_bits_ >> 32) * multiplicand;
     low_bits_ = (accumulator << 32) + part;
     accumulator >>= 32;
     accumulator = accumulator + (high_bits_ & kMask32) * multiplicand;
     part = static_cast<uint32_t>(accumulator & kMask32);
     accumulator >>= 32;
     accumulator = accumulator + (high_bits_ >> 32) * multiplicand;
     high_bits_ = (accumulator << 32) + part;
-    ASSERT((accumulator >> 32) == 0);
+    DCHECK((accumulator >> 32) == 0);
   }
 
   void Shift(int shift_amount) {
-    ASSERT(-64 <= shift_amount && shift_amount <= 64);
+    DCHECK(-64 <= shift_amount && shift_amount <= 64);
     if (shift_amount == 0) {
       return;
     } else if (shift_amount == -64) {
       high_bits_ = low_bits_;
       low_bits_ = 0;
     } else if (shift_amount == 64) {
       low_bits_ = high_bits_;
       high_bits_ = 0;
     } else if (shift_amount <= 0) {
       high_bits_ <<= -shift_amount;
@@ skipping 152 matching lines @@
 //   0 <= fractionals * 2^exponent < 1
 //   The buffer holds the result.
 // The function will round its result. During the rounding-process digits not
 // generated by this function might be updated, and the decimal-point variable
 // might be updated. If this function generates the digits 99 and the buffer
 // already contained "199" (thus yielding a buffer of "19999") then a
 // rounding-up will change the contents of the buffer to "20000".
 static void FillFractionals(uint64_t fractionals, int exponent,
                             int fractional_count, Vector<char> buffer,
                             int* length, int* decimal_point) {
-  ASSERT(-128 <= exponent && exponent <= 0);
+  DCHECK(-128 <= exponent && exponent <= 0);
   // 'fractionals' is a fixed-point number, with binary point at bit
   // (-exponent). Inside the function the non-converted remainder of fractionals
   // is a fixed-point number, with binary point at bit 'point'.
   if (-exponent <= 64) {
     // One 64 bit number is sufficient.
-    ASSERT(fractionals >> 56 == 0);
+    DCHECK(fractionals >> 56 == 0);
     int point = -exponent;
     for (int i = 0; i < fractional_count; ++i) {
       if (fractionals == 0) break;
       // Instead of multiplying by 10 we multiply by 5 and adjust the point
       // location. This way the fractionals variable will not overflow.
       // Invariant at the beginning of the loop: fractionals < 2^point.
       // Initially we have: point <= 64 and fractionals < 2^56
       // After each iteration the point is decremented by one.
       // Note that 5^3 = 125 < 128 = 2^7.
       // Therefore three iterations of this loop will not overflow fractionals
       // (even without the subtraction at the end of the loop body). At this
       // time point will satisfy point <= 61 and therefore fractionals < 2^point
       // and any further multiplication of fractionals by 5 will not overflow.
       fractionals *= 5;
       point--;
       int digit = static_cast<int>(fractionals >> point);
       buffer[*length] = '0' + digit;
       (*length)++;
       fractionals -= static_cast<uint64_t>(digit) << point;
     }
     // If the first bit after the point is set we have to round up.
     if (((fractionals >> (point - 1)) & 1) == 1) {
       RoundUp(buffer, length, decimal_point);
     }
   } else {  // We need 128 bits.
-    ASSERT(64 < -exponent && -exponent <= 128);
+    DCHECK(64 < -exponent && -exponent <= 128);
     UInt128 fractionals128 = UInt128(fractionals, 0);
     fractionals128.Shift(-exponent - 64);
     int point = 128;
     for (int i = 0; i < fractional_count; ++i) {
       if (fractionals128.IsZero()) break;
       // As before: instead of multiplying by 10 we multiply by 5 and adjust the
       // point location.
       // This multiplication will not overflow for the same reasons as before.
       fractionals128.Multiply(5);
       point--;
@@ skipping 97 matching lines @@
       FillDigits64(integrals, buffer, length);
     } else {
       FillDigits32(static_cast<uint32_t>(integrals), buffer, length);
     }
     *decimal_point = *length;
     FillFractionals(fractionals, exponent, fractional_count,
                     buffer, length, decimal_point);
   } else if (exponent < -128) {
     // This configuration (with at most 20 digits) means that all digits must be
     // 0.
-    ASSERT(fractional_count <= 20);
+    DCHECK(fractional_count <= 20);
     buffer[0] = '\0';
     *length = 0;
     *decimal_point = -fractional_count;
   } else {
     *decimal_point = 0;
     FillFractionals(significand, exponent, fractional_count,
                     buffer, length, decimal_point);
   }
   TrimZeros(buffer, length, decimal_point);
   buffer[*length] = '\0';
   if ((*length) == 0) {
     // The string is empty and the decimal_point thus has no importance. Mimick
     // Gay's dtoa and and set it to -fractional_count.
     *decimal_point = -fractional_count;
   }
   return true;
 }
 
 } }  // namespace v8::internal