Replace ASSERT with DHCECK_op in platform/wtf

third_party/WebKit/Source/platform/wtf/dtoa/double-conversion.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 60 matching lines @@
         }
         return false;
     }
 
 
     void DoubleToStringConverter::CreateExponentialRepresentation(
                                                                   const char* decimal_digits,
                                                                   int length,
                                                                   int exponent,
                                                                   StringBuilder* result_builder) const {
-        ASSERT(length != 0);
+        DCHECK_NE(length, 0);
         result_builder->AddCharacter(decimal_digits[0]);
         if (length != 1) {
             result_builder->AddCharacter('.');
             result_builder->AddSubstring(&decimal_digits[1], length-1);
         }
         result_builder->AddCharacter(exponent_character_);
         if (exponent < 0) {
             result_builder->AddCharacter('-');
             exponent = -exponent;
         } else {
             if ((flags_ & EMIT_POSITIVE_EXPONENT_SIGN) != 0) {
                 result_builder->AddCharacter('+');
             }
         }
         if (exponent == 0) {
             result_builder->AddCharacter('0');
             return;
         }
-        ASSERT(exponent < 1e4);
+        DCHECK_LT(exponent, 1e4);
         const int kMaxExponentLength = 5;
         char buffer[kMaxExponentLength + 1];
         int first_char_pos = kMaxExponentLength;
         buffer[first_char_pos] = '\0';
         while (exponent > 0) {
             buffer[--first_char_pos] = '0' + (exponent % 10);
             exponent /= 10;
         }
         result_builder->AddSubstring(&buffer[first_char_pos],
                                      kMaxExponentLength - first_char_pos);
     }
 
 
     void DoubleToStringConverter::CreateDecimalRepresentation(
                                                               const char* decimal_digits,
                                                               int length,
                                                               int decimal_point,
                                                               int digits_after_point,
                                                               StringBuilder* result_builder) const {
         // Create a representation that is padded with zeros if needed.
         if (decimal_point <= 0) {
             // "0.00000decimal_rep".
             result_builder->AddCharacter('0');
             if (digits_after_point > 0) {
                 result_builder->AddCharacter('.');
                 result_builder->AddPadding('0', -decimal_point);
-                ASSERT(length <= digits_after_point - (-decimal_point));
+                DCHECK_LE(length, digits_after_point - (-decimal_point));
                 result_builder->AddSubstring(decimal_digits, length);
                 int remaining_digits = digits_after_point - (-decimal_point) - length;
                 result_builder->AddPadding('0', remaining_digits);
             }
         } else if (decimal_point >= length) {
             // "decimal_rep0000.00000" or "decimal_rep.0000"
             result_builder->AddSubstring(decimal_digits, length);
             result_builder->AddPadding('0', decimal_point - length);
             if (digits_after_point > 0) {
                 result_builder->AddCharacter('.');
                 result_builder->AddPadding('0', digits_after_point);
             }
         } else {
             // "decima.l_rep000"
-            ASSERT(digits_after_point > 0);
+            DCHECK_GT(digits_after_point, 0);
             result_builder->AddSubstring(decimal_digits, decimal_point);
             result_builder->AddCharacter('.');
-            ASSERT(length - decimal_point <= digits_after_point);
+            DCHECK_LE(length - decimal_point, digits_after_point);
             result_builder->AddSubstring(&decimal_digits[decimal_point],
                                          length - decimal_point);
             int remaining_digits = digits_after_point - (length - decimal_point);
             result_builder->AddPadding('0', remaining_digits);
         }
         if (digits_after_point == 0) {
             if ((flags_ & EMIT_TRAILING_DECIMAL_POINT) != 0) {
                 result_builder->AddCharacter('.');
             }
             if ((flags_ & EMIT_TRAILING_ZERO_AFTER_POINT) != 0) {
@@ skipping 34 matching lines @@
             CreateExponentialRepresentation(decimal_rep, decimal_rep_length, exponent,
                                             result_builder);
         }
         return true;
     }
 
 
     bool DoubleToStringConverter::ToFixed(double value,
                                           int requested_digits,
                                           StringBuilder* result_builder) const {
-        ASSERT(kMaxFixedDigitsBeforePoint == 60);
+        DCHECK_EQ(kMaxFixedDigitsBeforePoint, 60);
         const double kFirstNonFixed = 1e60;
 
         if (Double(value).IsSpecial()) {
             return HandleSpecialValues(value, result_builder);
         }
 
         if (requested_digits > kMaxFixedDigitsAfterPoint) return false;
         if (value >= kFirstNonFixed || value <= -kFirstNonFixed) return false;
 
         // Find a sufficiently precise decimal representation of n.
@@ skipping 27 matching lines @@
             return HandleSpecialValues(value, result_builder);
         }
 
         if (requested_digits < -1) return false;
         if (requested_digits > kMaxExponentialDigits) return false;
 
         int decimal_point;
         bool sign;
         // Add space for digit before the decimal point and the '\0' character.
         const int kDecimalRepCapacity = kMaxExponentialDigits + 2;
-        ASSERT(kDecimalRepCapacity > kBase10MaximalLength);
+        DCHECK_GT(kDecimalRepCapacity, kBase10MaximalLength);
         char decimal_rep[kDecimalRepCapacity];
         int decimal_rep_length;
 
         if (requested_digits == -1) {
             DoubleToAscii(value, SHORTEST, 0,
                           decimal_rep, kDecimalRepCapacity,
                           &sign, &decimal_rep_length, &decimal_point);
         } else {
             DoubleToAscii(value, PRECISION, requested_digits + 1,
                           decimal_rep, kDecimalRepCapacity,
                           &sign, &decimal_rep_length, &decimal_point);
-            ASSERT(decimal_rep_length <= requested_digits + 1);
+            DCHECK_LE(decimal_rep_length, requested_digits + 1);
 
             for (int i = decimal_rep_length; i < requested_digits + 1; ++i) {
                 decimal_rep[i] = '0';
             }
             decimal_rep_length = requested_digits + 1;
         }
 
         bool unique_zero = ((flags_ & UNIQUE_ZERO) != 0);
         if (sign && (value != 0.0 || !unique_zero)) {
             result_builder->AddCharacter('-');
@@ skipping 23 matching lines @@
         int decimal_point;
         bool sign;
         // Add one for the terminating null character.
         const int kDecimalRepCapacity = kMaxPrecisionDigits + 1;
         char decimal_rep[kDecimalRepCapacity];
         int decimal_rep_length;
 
         DoubleToAscii(value, PRECISION, precision,
                       decimal_rep, kDecimalRepCapacity,
                       &sign, &decimal_rep_length, &decimal_point);
-        ASSERT(decimal_rep_length <= precision);
+        DCHECK_LE(decimal_rep_length, precision);
 
         bool unique_zero = ((flags_ & UNIQUE_ZERO) != 0);
         if (sign && (value != 0.0 || !unique_zero)) {
             result_builder->AddCharacter('-');
         }
 
         // The exponent if we print the number as x.xxeyyy. That is with the
         // decimal point after the first digit.
         int exponent = decimal_point - 1;
 
@@ skipping 37 matching lines @@
     void DoubleToStringConverter::DoubleToAscii(double v,
                                                 DtoaMode mode,
                                                 int requested_digits,
                                                 char* buffer,
                                                 int buffer_length,
                                                 bool* sign,
                                                 int* length,
                                                 int* point) {
         Vector<char> vector(buffer, buffer_length);
         DCHECK(!Double(v).IsSpecial());
-        ASSERT(mode == SHORTEST || requested_digits >= 0);
+        DCHECK(mode == SHORTEST || requested_digits >= 0);
 
         if (Double(v).Sign() < 0) {
             *sign = true;
             v = -v;
         } else {
             *sign = false;
         }
 
         if (mode == PRECISION && requested_digits == 0) {
             vector[0] = '\0';
@@ skipping 102 matching lines @@
                 if (current == end) {
                     *processed_characters_count = current - input;
                     return SignedZero(sign);
                 }
             }
         }
 
         // Copy significant digits of the integer part (if any) to the buffer.
         while (*current >= '0' && *current <= '9') {
             if (significant_digits < kMaxSignificantDigits) {
-                ASSERT(buffer_pos < kBufferSize);
+                DCHECK_LT(buffer_pos, kBufferSize);
                 buffer[buffer_pos++] = static_cast<char>(*current);
                 significant_digits++;
             } else {
                 insignificant_digits++;  // Move the digit into the exponential part.
                 nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
             }
             ++current;
             if (current == end) goto parsing_done;
         }
 
@@ skipping 16 matching lines @@
                         *processed_characters_count = current - input;
                         return SignedZero(sign);
                     }
                     exponent--;  // Move this 0 into the exponent.
                 }
             }
 
             // There is a fractional part.
             while (*current >= '0' && *current <= '9') {
                 if (significant_digits < kMaxSignificantDigits) {
-                    ASSERT(buffer_pos < kBufferSize);
+                    DCHECK_LT(buffer_pos, kBufferSize);
                     buffer[buffer_pos++] = static_cast<char>(*current);
                     significant_digits++;
                     exponent--;
                 } else {
                     // Ignore insignificant digits in the fractional part.
                     nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
                 }
                 ++current;
                 if (current == end) goto parsing_done;
             }
@@ skipping 25 matching lines @@
             }
 
             if (*current < '0' || *current > '9') {
                 if (sign)
                     --current;
                 --current;
                 goto parsing_done;
             }
 
             const int max_exponent = INT_MAX / 2;
-            ASSERT(-max_exponent / 2 <= exponent && exponent <= max_exponent / 2);
+            DCHECK_LE(-max_exponent / 2, exponent);
+            DCHECK_LE(exponent, max_exponent / 2);
             int num = 0;
             do {
                 // Check overflow.
                 int digit = *current - '0';
                 if (num >= max_exponent / 10
                     && !(num == max_exponent / 10 && digit <= max_exponent % 10)) {
                     num = max_exponent;
                 } else {
                     num = num * 10 + digit;
                 }
                 ++current;
             } while (current != end && *current >= '0' && *current <= '9');
 
             exponent += (sign == '-' ? -num : num);
         }
 
     parsing_done:
         exponent += insignificant_digits;
 
         if (nonzero_digit_dropped) {
             buffer[buffer_pos++] = '1';
             exponent--;
         }
 
-        ASSERT(buffer_pos < kBufferSize);
+        DCHECK_LT(buffer_pos, kBufferSize);
         buffer[buffer_pos] = '\0';
 
         double converted = Strtod(Vector<const char>(buffer, buffer_pos), exponent);
         *processed_characters_count = current - input;
         return sign? -converted: converted;
     }
 
 }  // namespace double_conversion
 
 } // namespace WTF