Rename ASSERT* to DCHECK*.

src/full-codegen.h

 // 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.
 
 #ifndef V8_FULL_CODEGEN_H_
 #define V8_FULL_CODEGEN_H_
 
 #include "src/v8.h"
 
 #include "src/allocation.h"
@@ skipping 56 matching lines @@
         scope_(info->scope()),
         nesting_stack_(NULL),
         loop_depth_(0),
         globals_(NULL),
         context_(NULL),
         bailout_entries_(info->HasDeoptimizationSupport()
                          ? info->function()->ast_node_count() : 0,
                          info->zone()),
         back_edges_(2, info->zone()),
         ic_total_count_(0) {
-    ASSERT(!info->IsStub());
+    DCHECK(!info->IsStub());
     Initialize();
   }
 
   void Initialize();
 
   static bool MakeCode(CompilationInfo* info);
 
   // Encode state and pc-offset as a BitField<type, start, size>.
   // Only use 30 bits because we encode the result as a smi.
   class StateField : public BitField<State, 0, 1> { };
@@ skipping 42 matching lines @@
 
   class NestedStatement BASE_EMBEDDED {
    public:
     explicit NestedStatement(FullCodeGenerator* codegen) : codegen_(codegen) {
       // Link into codegen's nesting stack.
       previous_ = codegen->nesting_stack_;
       codegen->nesting_stack_ = this;
     }
     virtual ~NestedStatement() {
       // Unlink from codegen's nesting stack.
-      ASSERT_EQ(this, codegen_->nesting_stack_);
+      DCHECK_EQ(this, codegen_->nesting_stack_);
       codegen_->nesting_stack_ = previous_;
     }
 
     virtual Breakable* AsBreakable() { return NULL; }
     virtual Iteration* AsIteration() { return NULL; }
 
     virtual bool IsContinueTarget(Statement* target) { return false; }
     virtual bool IsBreakTarget(Statement* target) { return false; }
 
     // Notify the statement that we are exiting it via break, continue, or
@@ skipping 423 matching lines @@
   void SetSourcePosition(int pos);
 
   // Non-local control flow support.
   void EnterFinallyBlock();
   void ExitFinallyBlock();
 
   // Loop nesting counter.
   int loop_depth() { return loop_depth_; }
   void increment_loop_depth() { loop_depth_++; }
   void decrement_loop_depth() {
-    ASSERT(loop_depth_ > 0);
+    DCHECK(loop_depth_ > 0);
     loop_depth_--;
   }
 
   MacroAssembler* masm() { return masm_; }
 
   class ExpressionContext;
   const ExpressionContext* context() { return context_; }
   void set_new_context(const ExpressionContext* context) { context_ = context; }
 
   Handle<Script> script() { return info_->script(); }
@@ skipping 163 matching lines @@
                 Label* true_label,
                 Label* false_label,
                 Label* fall_through)
         : ExpressionContext(codegen),
           condition_(condition),
           true_label_(true_label),
           false_label_(false_label),
           fall_through_(fall_through) { }
 
     static const TestContext* cast(const ExpressionContext* context) {
-      ASSERT(context->IsTest());
+      DCHECK(context->IsTest());
       return reinterpret_cast<const TestContext*>(context);
     }
 
     Expression* condition() const { return condition_; }
     Label* true_label() const { return true_label_; }
     Label* false_label() const { return false_label_; }
     Label* fall_through() const { return fall_through_; }
 
     virtual void Plug(bool flag) const;
     virtual void Plug(Register reg) const;
@@ skipping 80 matching lines @@
   }
 
  private:
   Zone* zone_;
 };
 
 
 class BackEdgeTable {
  public:
   BackEdgeTable(Code* code, DisallowHeapAllocation* required) {
-    ASSERT(code->kind() == Code::FUNCTION);
+    DCHECK(code->kind() == Code::FUNCTION);
     instruction_start_ = code->instruction_start();
     Address table_address = instruction_start_ + code->back_edge_table_offset();
     length_ = Memory::uint32_at(table_address);
     start_ = table_address + kTableLengthSize;
   }
 
   uint32_t length() { return length_; }
 
   BailoutId ast_id(uint32_t index) {
     return BailoutId(static_cast<int>(
@@ skipping 43 matching lines @@
                                         Code* unoptimized_code,
                                         Address pc_after);
 
 #ifdef DEBUG
   // Verify that all back edges of a certain loop depth are patched.
   static bool Verify(Isolate* isolate, Code* unoptimized_code);
 #endif  // DEBUG
 
  private:
   Address entry_at(uint32_t index) {
-    ASSERT(index < length_);
+    DCHECK(index < length_);
     return start_ + index * kEntrySize;
   }
 
   static const int kTableLengthSize = kIntSize;
   static const int kAstIdOffset = 0 * kIntSize;
   static const int kPcOffsetOffset = 1 * kIntSize;
   static const int kLoopDepthOffset = 2 * kIntSize;
   static const int kEntrySize = 3 * kIntSize;
 
   Address start_;
   Address instruction_start_;
   uint32_t length_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FULL_CODEGEN_H_