Rename ASSERT* to DCHECK*.

src/conversions-inl.h

 // 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.
 
 #ifndef V8_CONVERSIONS_INL_H_
 #define V8_CONVERSIONS_INL_H_
 
 #include <float.h>         // Required for DBL_MAX and on Win32 for finite()
 #include <limits.h>        // Required for INT_MAX etc.
 #include <stdarg.h>
@@ skipping 74 matching lines @@
     if (exponent > 31) return 0;
     return d.Sign() * static_cast<int32_t>(d.Significand() << exponent);
   }
 }
 
 
 template <class Iterator, class EndMark>
 bool SubStringEquals(Iterator* current,
                      EndMark end,
                      const char* substring) {
-  ASSERT(**current == *substring);
+  DCHECK(**current == *substring);
   for (substring++; *substring != '\0'; substring++) {
     ++*current;
     if (*current == end || **current != *substring) return false;
   }
   ++*current;
   return true;
 }
 
 
 // Returns true if a nonspace character has been found and false if the
@@ skipping 10 matching lines @@
 }
 
 
 // Parsing integers with radix 2, 4, 8, 16, 32. Assumes current != end.
 template <int radix_log_2, class Iterator, class EndMark>
 double InternalStringToIntDouble(UnicodeCache* unicode_cache,
                                  Iterator current,
                                  EndMark end,
                                  bool negative,
                                  bool allow_trailing_junk) {
-  ASSERT(current != end);
+  DCHECK(current != end);
 
   // Skip leading 0s.
   while (*current == '0') {
     ++current;
     if (current == end) return SignedZero(negative);
   }
 
   int64_t number = 0;
   int exponent = 0;
   const int radix = (1 << radix_log_2);
@@ skipping 58 matching lines @@
       // Rounding up may cause overflow.
       if ((number & (static_cast<int64_t>(1) << 53)) != 0) {
         exponent++;
         number >>= 1;
       }
       break;
     }
     ++current;
   } while (current != end);
 
-  ASSERT(number < ((int64_t)1 << 53));
-  ASSERT(static_cast<int64_t>(static_cast<double>(number)) == number);
+  DCHECK(number < ((int64_t)1 << 53));
+  DCHECK(static_cast<int64_t>(static_cast<double>(number)) == number);
 
   if (exponent == 0) {
     if (negative) {
       if (number == 0) return -0.0;
       number = -number;
     }
     return static_cast<double>(number);
   }
 
-  ASSERT(number != 0);
+  DCHECK(number != 0);
   return std::ldexp(static_cast<double>(negative ? -number : number), exponent);
 }
 
 
 template <class Iterator, class EndMark>
 double InternalStringToInt(UnicodeCache* unicode_cache,
                            Iterator current,
                            EndMark end,
                            int radix) {
   const bool allow_trailing_junk = true;
@@ skipping 90 matching lines @@
     const int kMaxSignificantDigits = 309;  // Doubles are less than 1.8e308.
     // The buffer may contain up to kMaxSignificantDigits + 1 digits and a zero
     // end.
     const int kBufferSize = kMaxSignificantDigits + 2;
     char buffer[kBufferSize];
     int buffer_pos = 0;
     while (*current >= '0' && *current <= '9') {
       if (buffer_pos <= kMaxSignificantDigits) {
         // If the number has more than kMaxSignificantDigits it will be parsed
         // as infinity.
-        ASSERT(buffer_pos < kBufferSize);
+        DCHECK(buffer_pos < kBufferSize);
         buffer[buffer_pos++] = static_cast<char>(*current);
       }
       ++current;
       if (current == end) break;
     }
 
     if (!allow_trailing_junk &&
         AdvanceToNonspace(unicode_cache, &current, end)) {
       return JunkStringValue();
     }
 
-    SLOW_ASSERT(buffer_pos < kBufferSize);
+    SLOW_DCHECK(buffer_pos < kBufferSize);
     buffer[buffer_pos] = '\0';
     Vector<const char> buffer_vector(buffer, buffer_pos);
     return negative ? -Strtod(buffer_vector, 0) : Strtod(buffer_vector, 0);
   }
 
   // The following code causes accumulating rounding error for numbers greater
   // than ~2^56. It's explicitly allowed in the spec: "if R is not 2, 4, 8, 10,
   // 16, or 32, then mathInt may be an implementation-dependent approximation to
   // the mathematical integer value" (15.1.2.2).
 
@@ skipping 27 matching lines @@
 
       // Update the value of the part as long as the multiplier fits
       // in 32 bits. When we can't guarantee that the next iteration
       // will not overflow the multiplier, we stop parsing the part
       // by leaving the loop.
       const unsigned int kMaximumMultiplier = 0xffffffffU / 36;
       uint32_t m = multiplier * radix;
       if (m > kMaximumMultiplier) break;
       part = part * radix + d;
       multiplier = m;
-      ASSERT(multiplier > part);
+      DCHECK(multiplier > part);
 
       ++current;
       if (current == end) {
         done = true;
         break;
       }
     }
 
     // Update the value and skip the part in the string.
     v = v * multiplier + part;
@@ skipping 68 matching lines @@
   if (*current == kInfinityString[0]) {
     if (!SubStringEquals(&current, end, kInfinityString)) {
       return JunkStringValue();
     }
 
     if (!allow_trailing_junk &&
         AdvanceToNonspace(unicode_cache, &current, end)) {
       return JunkStringValue();
     }
 
-    ASSERT(buffer_pos == 0);
+    DCHECK(buffer_pos == 0);
     return (sign == NEGATIVE) ? -V8_INFINITY : V8_INFINITY;
   }
 
   bool leading_zero = false;
   if (*current == '0') {
     ++current;
     if (current == end) return SignedZero(sign == NEGATIVE);
 
     leading_zero = true;
 
@@ skipping 42 matching lines @@
       ++current;
       if (current == end) return SignedZero(sign == NEGATIVE);
     }
   }
 
   bool octal = leading_zero && (flags & ALLOW_IMPLICIT_OCTAL) != 0;
 
   // 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(buffer_pos < kBufferSize);
       buffer[buffer_pos++] = static_cast<char>(*current);
       significant_digits++;
       // Will later check if it's an octal in the buffer.
     } else {
       insignificant_digits++;  // Move the digit into the exponential part.
       nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
     }
     octal = octal && *current < '8';
     ++current;
     if (current == end) goto parsing_done;
@@ skipping 24 matching lines @@
         ++current;
         if (current == end) return SignedZero(sign == NEGATIVE);
         exponent--;  // Move this 0 into the exponent.
       }
     }
 
     // There is a fractional part.  We don't emit a '.', but adjust the exponent
     // instead.
     while (*current >= '0' && *current <= '9') {
       if (significant_digits < kMaxSignificantDigits) {
-        ASSERT(buffer_pos < kBufferSize);
+        DCHECK(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 33 matching lines @@
 
     if (current == end || *current < '0' || *current > '9') {
       if (allow_trailing_junk) {
         goto parsing_done;
       } else {
         return JunkStringValue();
       }
     }
 
     const int max_exponent = INT_MAX / 2;
-    ASSERT(-max_exponent / 2 <= exponent && exponent <= max_exponent / 2);
+    DCHECK(-max_exponent / 2 <= exponent && 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;
       }
@@ skipping 17 matching lines @@
                                         buffer + buffer_pos,
                                         sign == NEGATIVE,
                                         allow_trailing_junk);
   }
 
   if (nonzero_digit_dropped) {
     buffer[buffer_pos++] = '1';
     exponent--;
   }
 
-  SLOW_ASSERT(buffer_pos < kBufferSize);
+  SLOW_DCHECK(buffer_pos < kBufferSize);
   buffer[buffer_pos] = '\0';
 
   double converted = Strtod(Vector<const char>(buffer, buffer_pos), exponent);
   return (sign == NEGATIVE) ? -converted : converted;
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_CONVERSIONS_INL_H_