Rename ASSERT* to DCHECK*.

src/bignum-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"
 
 #include "src/bignum-dtoa.h"
 
 #include "src/bignum.h"
 #include "src/double.h"
 
 namespace v8 {
 namespace internal {
 
 static int NormalizedExponent(uint64_t significand, int exponent) {
-  ASSERT(significand != 0);
+  DCHECK(significand != 0);
   while ((significand & Double::kHiddenBit) == 0) {
     significand = significand << 1;
     exponent = exponent - 1;
   }
   return exponent;
 }
 
 
 // Forward declarations:
 // Returns an estimation of k such that 10^(k-1) <= v < 10^k.
@@ skipping 30 matching lines @@
 // Once 'count' digits have been produced rounds the result depending on the
 // remainder (remainders of exactly .5 round upwards). Might update the
 // decimal_point when rounding up (for example for 0.9999).
 static void GenerateCountedDigits(int count, int* decimal_point,
                                   Bignum* numerator, Bignum* denominator,
                                   Vector<char>(buffer), int* length);
 
 
 void BignumDtoa(double v, BignumDtoaMode mode, int requested_digits,
                 Vector<char> buffer, int* length, int* decimal_point) {
-  ASSERT(v > 0);
-  ASSERT(!Double(v).IsSpecial());
+  DCHECK(v > 0);
+  DCHECK(!Double(v).IsSpecial());
   uint64_t significand = Double(v).Significand();
   bool is_even = (significand & 1) == 0;
   int exponent = Double(v).Exponent();
   int normalized_exponent = NormalizedExponent(significand, exponent);
   // estimated_power might be too low by 1.
   int estimated_power = EstimatePower(normalized_exponent);
 
   // Shortcut for Fixed.
   // The requested digits correspond to the digits after the point. If the
   // number is much too small, then there is no need in trying to get any
   // digits.
   if (mode == BIGNUM_DTOA_FIXED && -estimated_power - 1 > requested_digits) {
     buffer[0] = '\0';
     *length = 0;
     // Set decimal-point to -requested_digits. This is what Gay does.
     // Note that it should not have any effect anyways since the string is
     // empty.
     *decimal_point = -requested_digits;
     return;
   }
 
   Bignum numerator;
   Bignum denominator;
   Bignum delta_minus;
   Bignum delta_plus;
   // Make sure the bignum can grow large enough. The smallest double equals
   // 4e-324. In this case the denominator needs fewer than 324*4 binary digits.
   // The maximum double is 1.7976931348623157e308 which needs fewer than
   // 308*4 binary digits.
-  ASSERT(Bignum::kMaxSignificantBits >= 324*4);
+  DCHECK(Bignum::kMaxSignificantBits >= 324*4);
   bool need_boundary_deltas = (mode == BIGNUM_DTOA_SHORTEST);
   InitialScaledStartValues(v, estimated_power, need_boundary_deltas,
                            &numerator, &denominator,
                            &delta_minus, &delta_plus);
   // We now have v = (numerator / denominator) * 10^estimated_power.
   FixupMultiply10(estimated_power, is_even, decimal_point,
                   &numerator, &denominator,
                   &delta_minus, &delta_plus);
   // We now have v = (numerator / denominator) * 10^(decimal_point-1), and
   //  1 <= (numerator + delta_plus) / denominator < 10
@@ skipping 39 matching lines @@
                                    Vector<char> buffer, int* length) {
   // Small optimization: if delta_minus and delta_plus are the same just reuse
   // one of the two bignums.
   if (Bignum::Equal(*delta_minus, *delta_plus)) {
     delta_plus = delta_minus;
   }
   *length = 0;
   while (true) {
     uint16_t digit;
     digit = numerator->DivideModuloIntBignum(*denominator);
-    ASSERT(digit <= 9);  // digit is a uint16_t and therefore always positive.
+    DCHECK(digit <= 9);  // digit is a uint16_t and therefore always positive.
     // digit = numerator / denominator (integer division).
     // numerator = numerator % denominator.
     buffer[(*length)++] = digit + '0';
 
     // Can we stop already?
     // If the remainder of the division is less than the distance to the lower
     // boundary we can stop. In this case we simply round down (discarding the
     // remainder).
     // Similarly we test if we can round up (using the upper boundary).
     bool in_delta_room_minus;
@@ skipping 25 matching lines @@
       // If yes, then the next digit would be < 5 and we can round down.
       int compare = Bignum::PlusCompare(*numerator, *numerator, *denominator);
       if (compare < 0) {
         // Remaining digits are less than .5. -> Round down (== do nothing).
       } else if (compare > 0) {
         // Remaining digits are more than .5 of denominator. -> Round up.
         // Note that the last digit could not be a '9' as otherwise the whole
         // loop would have stopped earlier.
         // We still have an assert here in case the preconditions were not
         // satisfied.
-        ASSERT(buffer[(*length) - 1] != '9');
+        DCHECK(buffer[(*length) - 1] != '9');
         buffer[(*length) - 1]++;
       } else {
         // Halfway case.
         // TODO(floitsch): need a way to solve half-way cases.
         //   For now let's round towards even (since this is what Gay seems to
         //   do).
 
         if ((buffer[(*length) - 1] - '0') % 2 == 0) {
           // Round down => Do nothing.
         } else {
-          ASSERT(buffer[(*length) - 1] != '9');
+          DCHECK(buffer[(*length) - 1] != '9');
           buffer[(*length) - 1]++;
         }
       }
       return;
     } else if (in_delta_room_minus) {
       // Round down (== do nothing).
       return;
     } else {  // in_delta_room_plus
       // Round up.
       // Note again that the last digit could not be '9' since this would have
       // stopped the loop earlier.
-      // We still have an ASSERT here, in case the preconditions were not
+      // We still have an DCHECK here, in case the preconditions were not
       // satisfied.
-      ASSERT(buffer[(*length) -1] != '9');
+      DCHECK(buffer[(*length) -1] != '9');
       buffer[(*length) - 1]++;
       return;
     }
   }
 }
 
 
 // Let v = numerator / denominator < 10.
 // Then we generate 'count' digits of d = x.xxxxx... (without the decimal point)
 // from left to right. Once 'count' digits have been produced we decide wether
 // to round up or down. Remainders of exactly .5 round upwards. Numbers such
 // as 9.999999 propagate a carry all the way, and change the
 // exponent (decimal_point), when rounding upwards.
 static void GenerateCountedDigits(int count, int* decimal_point,
                                   Bignum* numerator, Bignum* denominator,
                                   Vector<char>(buffer), int* length) {
-  ASSERT(count >= 0);
+  DCHECK(count >= 0);
   for (int i = 0; i < count - 1; ++i) {
     uint16_t digit;
     digit = numerator->DivideModuloIntBignum(*denominator);
-    ASSERT(digit <= 9);  // digit is a uint16_t and therefore always positive.
+    DCHECK(digit <= 9);  // digit is a uint16_t and therefore always positive.
     // digit = numerator / denominator (integer division).
     // numerator = numerator % denominator.
     buffer[i] = digit + '0';
     // Prepare for next iteration.
     numerator->Times10();
   }
   // Generate the last digit.
   uint16_t digit;
   digit = numerator->DivideModuloIntBignum(*denominator);
   if (Bignum::PlusCompare(*numerator, *numerator, *denominator) >= 0) {
@@ skipping 32 matching lines @@
     // Ex: 0.001 with requested_digits == 1.
     // Set decimal-point to -requested_digits. This is what Gay does.
     // Note that it should not have any effect anyways since the string is
     // empty.
     *decimal_point = -requested_digits;
     *length = 0;
     return;
   } else if (-(*decimal_point) == requested_digits) {
     // We only need to verify if the number rounds down or up.
     // Ex: 0.04 and 0.06 with requested_digits == 1.
-    ASSERT(*decimal_point == -requested_digits);
+    DCHECK(*decimal_point == -requested_digits);
     // Initially the fraction lies in range (1, 10]. Multiply the denominator
     // by 10 so that we can compare more easily.
     denominator->Times10();
     if (Bignum::PlusCompare(*numerator, *numerator, *denominator) >= 0) {
       // If the fraction is >= 0.5 then we have to include the rounded
       // digit.
       buffer[0] = '1';
       *length = 1;
       (*decimal_point)++;
     } else {
@@ skipping 58 matching lines @@
   return static_cast<int>(estimate);
 }
 
 
 // See comments for InitialScaledStartValues.
 static void InitialScaledStartValuesPositiveExponent(
     double v, int estimated_power, bool need_boundary_deltas,
     Bignum* numerator, Bignum* denominator,
     Bignum* delta_minus, Bignum* delta_plus) {
   // A positive exponent implies a positive power.
-  ASSERT(estimated_power >= 0);
+  DCHECK(estimated_power >= 0);
   // Since the estimated_power is positive we simply multiply the denominator
   // by 10^estimated_power.
 
   // numerator = v.
   numerator->AssignUInt64(Double(v).Significand());
   numerator->ShiftLeft(Double(v).Exponent());
   // denominator = 10^estimated_power.
   denominator->AssignPowerUInt16(10, estimated_power);
 
   if (need_boundary_deltas) {
@@ skipping 98 matching lines @@
     // delta_plus = delta_minus = 10^estimated_power
     delta_plus->AssignBignum(*power_ten);
     delta_minus->AssignBignum(*power_ten);
   }
 
   // numerator = significand * 2 * 10^-estimated_power
   //  since v = significand * 2^exponent this is equivalent to
   // numerator = v * 10^-estimated_power * 2 * 2^-exponent.
   // Remember: numerator has been abused as power_ten. So no need to assign it
   //  to itself.
-  ASSERT(numerator == power_ten);
+  DCHECK(numerator == power_ten);
   numerator->MultiplyByUInt64(significand);
 
   // denominator = 2 * 2^-exponent with exponent < 0.
   denominator->AssignUInt16(1);
   denominator->ShiftLeft(-exponent);
 
   if (need_boundary_deltas) {
     // Introduce a common denominator so that the deltas to the boundaries are
     // integers.
     numerator->ShiftLeft(1);
@@ skipping 111 matching lines @@
       delta_minus->Times10();
       delta_plus->AssignBignum(*delta_minus);
     } else {
       delta_minus->Times10();
       delta_plus->Times10();
     }
   }
 }
 
 } }  // namespace v8::internal