Rename ASSERT* to DCHECK*.

src/log-utils.cc

 // Copyright 2009 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 "src/v8.h"
 
 #include "src/log-utils.h"
 #include "src/string-stream.h"
 
 namespace v8 {
@@ skipping 36 matching lines @@
     } else if (strcmp(log_file_name, kLogToTemporaryFile) == 0) {
       OpenTemporaryFile();
     } else {
       OpenFile(log_file_name);
     }
   }
 }
 
 
 void Log::OpenStdout() {
-  ASSERT(!IsEnabled());
+  DCHECK(!IsEnabled());
   output_handle_ = stdout;
 }
 
 
 void Log::OpenTemporaryFile() {
-  ASSERT(!IsEnabled());
+  DCHECK(!IsEnabled());
   output_handle_ = base::OS::OpenTemporaryFile();
 }
 
 
 void Log::OpenFile(const char* name) {
-  ASSERT(!IsEnabled());
+  DCHECK(!IsEnabled());
   output_handle_ = base::OS::FOpen(name, base::OS::LogFileOpenMode);
 }
 
 
 FILE* Log::Close() {
   FILE* result = NULL;
   if (output_handle_ != NULL) {
     if (strcmp(FLAG_logfile, kLogToTemporaryFile) != 0) {
       fclose(output_handle_);
     } else {
       result = output_handle_;
     }
   }
   output_handle_ = NULL;
 
   DeleteArray(message_buffer_);
   message_buffer_ = NULL;
 
   is_stopped_ = false;
   return result;
 }
 
 
 Log::MessageBuilder::MessageBuilder(Log* log)
   : log_(log),
     lock_guard_(&log_->mutex_),
     pos_(0) {
-  ASSERT(log_->message_buffer_ != NULL);
+  DCHECK(log_->message_buffer_ != NULL);
 }
 
 
 void Log::MessageBuilder::Append(const char* format, ...) {
   Vector<char> buf(log_->message_buffer_ + pos_,
                    Log::kMessageBufferSize - pos_);
   va_list args;
   va_start(args, format);
   AppendVA(format, args);
   va_end(args);
-  ASSERT(pos_ <= Log::kMessageBufferSize);
+  DCHECK(pos_ <= Log::kMessageBufferSize);
 }
 
 
 void Log::MessageBuilder::AppendVA(const char* format, va_list args) {
   Vector<char> buf(log_->message_buffer_ + pos_,
                    Log::kMessageBufferSize - pos_);
   int result = v8::internal::VSNPrintF(buf, format, args);
 
   // Result is -1 if output was truncated.
   if (result >= 0) {
     pos_ += result;
   } else {
     pos_ = Log::kMessageBufferSize;
   }
-  ASSERT(pos_ <= Log::kMessageBufferSize);
+  DCHECK(pos_ <= Log::kMessageBufferSize);
 }
 
 
 void Log::MessageBuilder::Append(const char c) {
   if (pos_ < Log::kMessageBufferSize) {
     log_->message_buffer_[pos_++] = c;
   }
-  ASSERT(pos_ <= Log::kMessageBufferSize);
+  DCHECK(pos_ <= Log::kMessageBufferSize);
 }
 
 
 void Log::MessageBuilder::AppendDoubleQuotedString(const char* string) {
   Append('"');
   for (const char* p = string; *p != '\0'; p++) {
     if (*p == '"') {
       Append('\\');
     }
     Append(*p);
@@ skipping 10 matching lines @@
   }
 }
 
 
 void Log::MessageBuilder::AppendAddress(Address addr) {
   Append("0x%" V8PRIxPTR, addr);
 }
 
 
 void Log::MessageBuilder::AppendSymbolName(Symbol* symbol) {
-  ASSERT(symbol);
+  DCHECK(symbol);
   Append("symbol(");
   if (!symbol->name()->IsUndefined()) {
     Append("\"");
     AppendDetailed(String::cast(symbol->name()), false);
     Append("\" ");
   }
   Append("hash %x)", symbol->Hash());
 }
 
 
@@ skipping 26 matching lines @@
     } else {
       Append("%lc", c);
     }
   }
 }
 
 
 void Log::MessageBuilder::AppendStringPart(const char* str, int len) {
   if (pos_ + len > Log::kMessageBufferSize) {
     len = Log::kMessageBufferSize - pos_;
-    ASSERT(len >= 0);
+    DCHECK(len >= 0);
     if (len == 0) return;
   }
   Vector<char> buf(log_->message_buffer_ + pos_,
                    Log::kMessageBufferSize - pos_);
   StrNCpy(buf, str, len);
   pos_ += len;
-  ASSERT(pos_ <= Log::kMessageBufferSize);
+  DCHECK(pos_ <= Log::kMessageBufferSize);
 }
 
 
 void Log::MessageBuilder::WriteToLogFile() {
-  ASSERT(pos_ <= Log::kMessageBufferSize);
+  DCHECK(pos_ <= Log::kMessageBufferSize);
   // Assert that we do not already have a new line at the end.
-  ASSERT(pos_ == 0 || log_->message_buffer_[pos_ - 1] != '\n');
+  DCHECK(pos_ == 0 || log_->message_buffer_[pos_ - 1] != '\n');
   if (pos_ == Log::kMessageBufferSize) pos_--;
   log_->message_buffer_[pos_++] = '\n';
   const int written = log_->WriteToFile(log_->message_buffer_, pos_);
   if (written != pos_) {
     log_->stop();
     log_->logger_->LogFailure();
   }
 }
 
 
 } }  // namespace v8::internal