Rename ASSERT* to DCHECK*.

src/conversions.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 <limits.h>
 #include <stdarg.h>
 #include <cmath>
 
 #include "src/v8.h"
 
@@ skipping 179 matching lines @@
   } while (n);
   if (negative) buffer[--i] = '-';
   return buffer.start() + i;
 }
 
 
 char* DoubleToFixedCString(double value, int f) {
   const int kMaxDigitsBeforePoint = 21;
   const double kFirstNonFixed = 1e21;
   const int kMaxDigitsAfterPoint = 20;
-  ASSERT(f >= 0);
-  ASSERT(f <= kMaxDigitsAfterPoint);
+  DCHECK(f >= 0);
+  DCHECK(f <= kMaxDigitsAfterPoint);
 
   bool negative = false;
   double abs_value = value;
   if (value < 0) {
     abs_value = -value;
     negative = true;
   }
 
   // If abs_value has more than kMaxDigitsBeforePoint digits before the point
   // use the non-fixed conversion routine.
@@ skipping 80 matching lines @@
   builder.AddCharacter('e');
   builder.AddCharacter(negative_exponent ? '-' : '+');
   builder.AddDecimalInteger(exponent);
   return builder.Finalize();
 }
 
 
 char* DoubleToExponentialCString(double value, int f) {
   const int kMaxDigitsAfterPoint = 20;
   // f might be -1 to signal that f was undefined in JavaScript.
-  ASSERT(f >= -1 && f <= kMaxDigitsAfterPoint);
+  DCHECK(f >= -1 && f <= kMaxDigitsAfterPoint);
 
   bool negative = false;
   if (value < 0) {
     value = -value;
     negative = true;
   }
 
   // Find a sufficiently precise decimal representation of n.
   int decimal_point;
   int sign;
   // f corresponds to the digits after the point. There is always one digit
   // before the point. The number of requested_digits equals hence f + 1.
   // And we have to add one character for the null-terminator.
   const int kV8DtoaBufferCapacity = kMaxDigitsAfterPoint + 1 + 1;
   // Make sure that the buffer is big enough, even if we fall back to the
   // shortest representation (which happens when f equals -1).
-  ASSERT(kBase10MaximalLength <= kMaxDigitsAfterPoint + 1);
+  DCHECK(kBase10MaximalLength <= kMaxDigitsAfterPoint + 1);
   char decimal_rep[kV8DtoaBufferCapacity];
   int decimal_rep_length;
 
   if (f == -1) {
     DoubleToAscii(value, DTOA_SHORTEST, 0,
                   Vector<char>(decimal_rep, kV8DtoaBufferCapacity),
                   &sign, &decimal_rep_length, &decimal_point);
     f = decimal_rep_length - 1;
   } else {
     DoubleToAscii(value, DTOA_PRECISION, f + 1,
                   Vector<char>(decimal_rep, kV8DtoaBufferCapacity),
                   &sign, &decimal_rep_length, &decimal_point);
   }
-  ASSERT(decimal_rep_length > 0);
-  ASSERT(decimal_rep_length <= f + 1);
+  DCHECK(decimal_rep_length > 0);
+  DCHECK(decimal_rep_length <= f + 1);
 
   int exponent = decimal_point - 1;
   char* result =
       CreateExponentialRepresentation(decimal_rep, exponent, negative, f+1);
 
   return result;
 }
 
 
 char* DoubleToPrecisionCString(double value, int p) {
   const int kMinimalDigits = 1;
   const int kMaximalDigits = 21;
-  ASSERT(p >= kMinimalDigits && p <= kMaximalDigits);
+  DCHECK(p >= kMinimalDigits && p <= kMaximalDigits);
   USE(kMinimalDigits);
 
   bool negative = false;
   if (value < 0) {
     value = -value;
     negative = true;
   }
 
   // Find a sufficiently precise decimal representation of n.
   int decimal_point;
   int sign;
   // Add one for the terminating null character.
   const int kV8DtoaBufferCapacity = kMaximalDigits + 1;
   char decimal_rep[kV8DtoaBufferCapacity];
   int decimal_rep_length;
 
   DoubleToAscii(value, DTOA_PRECISION, p,
                 Vector<char>(decimal_rep, kV8DtoaBufferCapacity),
                 &sign, &decimal_rep_length, &decimal_point);
-  ASSERT(decimal_rep_length <= p);
+  DCHECK(decimal_rep_length <= p);
 
   int exponent = decimal_point - 1;
 
   char* result = NULL;
 
   if (exponent < -6 || exponent >= p) {
     result =
         CreateExponentialRepresentation(decimal_rep, exponent, negative, p);
   } else {
     // Use fixed notation.
@@ skipping 27 matching lines @@
       }
     }
     result = builder.Finalize();
   }
 
   return result;
 }
 
 
 char* DoubleToRadixCString(double value, int radix) {
-  ASSERT(radix >= 2 && radix <= 36);
+  DCHECK(radix >= 2 && radix <= 36);
 
   // Character array used for conversion.
   static const char chars[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 
   // Buffer for the integer part of the result. 1024 chars is enough
   // for max integer value in radix 2.  We need room for a sign too.
   static const int kBufferSize = 1100;
   char integer_buffer[kBufferSize];
   integer_buffer[kBufferSize - 1] = '\0';
 
@@ skipping 13 matching lines @@
   // Convert the integer part starting from the back.  Always generate
   // at least one digit.
   int integer_pos = kBufferSize - 2;
   do {
     double remainder = std::fmod(integer_part, radix);
     integer_buffer[integer_pos--] = chars[static_cast<int>(remainder)];
     integer_part -= remainder;
     integer_part /= radix;
   } while (integer_part >= 1.0);
   // Sanity check.
-  ASSERT(integer_pos > 0);
+  DCHECK(integer_pos > 0);
   // Add sign if needed.
   if (is_negative) integer_buffer[integer_pos--] = '-';
 
   // Convert the decimal part.  Repeatedly multiply by the radix to
   // generate the next char.  Never generate more than kBufferSize - 1
   // chars.
   //
   // TODO(1093998): We will often generate a full decimal_buffer of
   // chars because hitting zero will often not happen.  The right
   // solution would be to continue until the string representation can
@@ skipping 34 matching lines @@
     return StringToDouble(
         unicode_cache, flat.ToOneByteVector(), flags, empty_string_val);
   } else {
     return StringToDouble(
         unicode_cache, flat.ToUC16Vector(), flags, empty_string_val);
   }
 }
 
 
 } }  // namespace v8::internal