Rename ASSERT* to DCHECK*.

src/interface.cc

 // Copyright 2012 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/interface.h"
 
 namespace v8 {
 namespace internal {
 
 Interface* Interface::Lookup(Handle<String> name, Zone* zone) {
-  ASSERT(IsModule());
+  DCHECK(IsModule());
   ZoneHashMap* map = Chase()->exports_;
   if (map == NULL) return NULL;
   ZoneAllocationPolicy allocator(zone);
   ZoneHashMap::Entry* p = map->Lookup(name.location(), name->Hash(), false,
                                       allocator);
   if (p == NULL) return NULL;
-  ASSERT(*static_cast<String**>(p->key) == *name);
-  ASSERT(p->value != NULL);
+  DCHECK(*static_cast<String**>(p->key) == *name);
+  DCHECK(p->value != NULL);
   return static_cast<Interface*>(p->value);
 }
 
 
 #ifdef DEBUG
 // Current nesting depth for debug output.
 class Nesting {
  public:
   Nesting()  { current_ += 2; }
   ~Nesting() { current_ -= 2; }
@@ skipping 52 matching lines @@
     this->Print(Nesting::current());
     PrintF("%*s# Added.\n", Nesting::current(), "");
   }
 #endif
 }
 
 
 void Interface::Unify(Interface* that, Zone* zone, bool* ok) {
   if (this->forward_) return this->Chase()->Unify(that, zone, ok);
   if (that->forward_) return this->Unify(that->Chase(), zone, ok);
-  ASSERT(this->forward_ == NULL);
-  ASSERT(that->forward_ == NULL);
+  DCHECK(this->forward_ == NULL);
+  DCHECK(that->forward_ == NULL);
 
   *ok = true;
   if (this == that) return;
   if (this->IsValue()) {
     that->MakeValue(ok);
     if (*ok && this->IsConst()) that->MakeConst(ok);
     return;
   }
   if (that->IsValue()) {
     this->MakeValue(ok);
@@ skipping 25 matching lines @@
     this->Print(Nesting::current());
     PrintF("%*sthat' = ", Nesting::current(), "");
     that->Print(Nesting::current());
     PrintF("%*s# Unified.\n", Nesting::current(), "");
   }
 #endif
 }
 
 
 void Interface::DoUnify(Interface* that, bool* ok, Zone* zone) {
-  ASSERT(this->forward_ == NULL);
-  ASSERT(that->forward_ == NULL);
-  ASSERT(!this->IsValue());
-  ASSERT(!that->IsValue());
-  ASSERT(this->index_ == -1);
-  ASSERT(that->index_ == -1);
-  ASSERT(*ok);
+  DCHECK(this->forward_ == NULL);
+  DCHECK(that->forward_ == NULL);
+  DCHECK(!this->IsValue());
+  DCHECK(!that->IsValue());
+  DCHECK(this->index_ == -1);
+  DCHECK(that->index_ == -1);
+  DCHECK(*ok);
 
 #ifdef DEBUG
     Nesting nested;
 #endif
 
   // Try to merge all members from that into this.
   ZoneHashMap* map = that->exports_;
   if (map != NULL) {
     for (ZoneHashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p)) {
       this->DoAdd(p->key, p->hash, static_cast<Interface*>(p->value), zone, ok);
@@ skipping 49 matching lines @@
         PrintF("%*s%s : ", n0 + 2, "", name->ToAsciiArray());
         interface->Print(n0 + 2);
       }
       PrintF("%*s}\n", n0, "");
     }
   }
 }
 #endif
 
 } }  // namespace v8::internal