Rename ASSERT* to DCHECK*.

src/utils.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 <stdarg.h>
 #include <sys/stat.h>
 
 #include "src/v8.h"
 
 #include "src/base/logging.h"
 #include "src/base/platform/platform.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 
 SimpleStringBuilder::SimpleStringBuilder(int size) {
   buffer_ = Vector<char>::New(size);
   position_ = 0;
 }
 
 
 void SimpleStringBuilder::AddString(const char* s) {
   AddSubstring(s, StrLength(s));
 }
 
 
 void SimpleStringBuilder::AddSubstring(const char* s, int n) {
-  ASSERT(!is_finalized() && position_ + n <= buffer_.length());
-  ASSERT(static_cast<size_t>(n) <= strlen(s));
+  DCHECK(!is_finalized() && position_ + n <= buffer_.length());
+  DCHECK(static_cast<size_t>(n) <= strlen(s));
   MemCopy(&buffer_[position_], s, n * kCharSize);
   position_ += n;
 }
 
 
 void SimpleStringBuilder::AddPadding(char c, int count) {
   for (int i = 0; i < count; i++) {
     AddCharacter(c);
   }
 }
@@ skipping 11 matching lines @@
   }
   position_ += digits;
   for (int i = 1; i <= digits; i++) {
     buffer_[position_ - i] = '0' + static_cast<char>(number % 10);
     number /= 10;
   }
 }
 
 
 char* SimpleStringBuilder::Finalize() {
-  ASSERT(!is_finalized() && position_ <= buffer_.length());
+  DCHECK(!is_finalized() && position_ <= buffer_.length());
   // If there is no space for null termination, overwrite last character.
   if (position_ == buffer_.length()) {
     position_--;
     // Print ellipsis.
     for (int i = 3; i > 0 && position_ > i; --i) buffer_[position_ - i] = '.';
   }
   buffer_[position_] = '\0';
   // Make sure nobody managed to add a 0-character to the
   // buffer while building the string.
-  ASSERT(strlen(buffer_.start()) == static_cast<size_t>(position_));
+  DCHECK(strlen(buffer_.start()) == static_cast<size_t>(position_));
   position_ = -1;
-  ASSERT(is_finalized());
+  DCHECK(is_finalized());
   return buffer_.start();
 }
 
 
 void PrintF(const char* format, ...) {
   va_list arguments;
   va_start(arguments, format);
   base::OS::VPrint(format, arguments);
   va_end(arguments);
 }
@@ skipping 79 matching lines @@
       // Copy the existing input into the new array and set the new
       // array as the result.
       MemCopy(new_result, result, offset * kCharSize);
       DeleteArray(result);
       result = new_result;
     }
     // Copy the newly read line into the result.
     MemCopy(result + offset, line_buf, len * kCharSize);
     offset += len;
   }
-  ASSERT(result != NULL);
+  DCHECK(result != NULL);
   result[offset] = '\0';
   return result;
 }
 
 
 char* ReadCharsFromFile(FILE* file,
                         int* size,
                         int extra_space,
                         bool verbose,
                         const char* filename) {
@@ skipping 130 matching lines @@
 
 void StringBuilder::AddFormatted(const char* format, ...) {
   va_list arguments;
   va_start(arguments, format);
   AddFormattedList(format, arguments);
   va_end(arguments);
 }
 
 
 void StringBuilder::AddFormattedList(const char* format, va_list list) {
-  ASSERT(!is_finalized() && position_ <= buffer_.length());
+  DCHECK(!is_finalized() && position_ <= buffer_.length());
   int n = VSNPrintF(buffer_ + position_, format, list);
   if (n < 0 || n >= (buffer_.length() - position_)) {
     position_ = buffer_.length();
   } else {
     position_ += n;
   }
 }
 
 
 #if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
@@ skipping 71 matching lines @@
   }
   if (u.bits.exp == 0) {
     // Detect +0, and -0 for IEEE double precision floating point.
     if ((u.bits.man_low | u.bits.man_high) == 0) return false;
   }
   return true;
 }
 
 
 } }  // namespace v8::internal