Replace ASSERT with DHCECK_op in platform/wtf

third_party/WebKit/Source/platform/wtf/dtoa/bignum-dtoa.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 18 matching lines @@
 
 #include "bignum.h"
 #include "double.h"
 #include <math.h>
 
 namespace WTF {
 
 namespace double_conversion {
 
     static int NormalizedExponent(uint64_t significand, int exponent) {
-        ASSERT(significand != 0);
+        DCHECK_NE(significand, 0u);
         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);
+        DCHECK_GT(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
@@ skipping 10 matching lines @@
         }
 
         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_GE(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_LE(digit, 9u);  // digit is a uint16_t and therefore always positive.
             // digit = numerator / denominator (integer division).
             // numerator = numerator % denominator.
             buffer[(*length)++] = static_cast<char>(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_NE(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_NE(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
                 // satisfied.
-                ASSERT(buffer[(*length) -1] != '9');
+                DCHECK_NE(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_GE(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_LE(digit, 9u);  // digit is a uint16_t and therefore always positive.
             // digit = numerator / denominator (integer division).
             // numerator = numerator % denominator.
             buffer[i] = static_cast<char>(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_EQ(*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_GE(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_EQ(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 113 matching lines @@
             } else {
                 delta_minus->Times10();
                 delta_plus->Times10();
             }
         }
     }
 
 }  // namespace double_conversion
 
 } // namespace WTF