Rename ASSERT* to DCHECK*.

src/regexp-macro-assembler-irregexp.cc

 // Copyright 2008-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/ast.h"
 #include "src/bytecodes-irregexp.h"
 #include "src/regexp-macro-assembler.h"
 #include "src/regexp-macro-assembler-irregexp.h"
@@ skipping 22 matching lines @@
 
 
 RegExpMacroAssemblerIrregexp::IrregexpImplementation
 RegExpMacroAssemblerIrregexp::Implementation() {
   return kBytecodeImplementation;
 }
 
 
 void RegExpMacroAssemblerIrregexp::Bind(Label* l) {
   advance_current_end_ = kInvalidPC;
-  ASSERT(!l->is_bound());
+  DCHECK(!l->is_bound());
   if (l->is_linked()) {
     int pos = l->pos();
     while (pos != 0) {
       int fixup = pos;
       pos = *reinterpret_cast<int32_t*>(buffer_.start() + fixup);
       *reinterpret_cast<uint32_t*>(buffer_.start() + fixup) = pc_;
     }
   }
   l->bind_to(pc_);
 }
 
 
 void RegExpMacroAssemblerIrregexp::EmitOrLink(Label* l) {
   if (l == NULL) l = &backtrack_;
   if (l->is_bound()) {
     Emit32(l->pos());
   } else {
     int pos = 0;
     if (l->is_linked()) {
       pos = l->pos();
     }
     l->link_to(pc_);
     Emit32(pos);
   }
 }
 
 
 void RegExpMacroAssemblerIrregexp::PopRegister(int register_index) {
-  ASSERT(register_index >= 0);
-  ASSERT(register_index <= kMaxRegister);
+  DCHECK(register_index >= 0);
+  DCHECK(register_index <= kMaxRegister);
   Emit(BC_POP_REGISTER, register_index);
 }
 
 
 void RegExpMacroAssemblerIrregexp::PushRegister(
     int register_index,
     StackCheckFlag check_stack_limit) {
-  ASSERT(register_index >= 0);
-  ASSERT(register_index <= kMaxRegister);
+  DCHECK(register_index >= 0);
+  DCHECK(register_index <= kMaxRegister);
   Emit(BC_PUSH_REGISTER, register_index);
 }
 
 
 void RegExpMacroAssemblerIrregexp::WriteCurrentPositionToRegister(
     int register_index, int cp_offset) {
-  ASSERT(register_index >= 0);
-  ASSERT(register_index <= kMaxRegister);
+  DCHECK(register_index >= 0);
+  DCHECK(register_index <= kMaxRegister);
   Emit(BC_SET_REGISTER_TO_CP, register_index);
   Emit32(cp_offset);  // Current position offset.
 }
 
 
 void RegExpMacroAssemblerIrregexp::ClearRegisters(int reg_from, int reg_to) {
-  ASSERT(reg_from <= reg_to);
+  DCHECK(reg_from <= reg_to);
   for (int reg = reg_from; reg <= reg_to; reg++) {
     SetRegister(reg, -1);
   }
 }
 
 
 void RegExpMacroAssemblerIrregexp::ReadCurrentPositionFromRegister(
     int register_index) {
-  ASSERT(register_index >= 0);
-  ASSERT(register_index <= kMaxRegister);
+  DCHECK(register_index >= 0);
+  DCHECK(register_index <= kMaxRegister);
   Emit(BC_SET_CP_TO_REGISTER, register_index);
 }
 
 
 void RegExpMacroAssemblerIrregexp::WriteStackPointerToRegister(
     int register_index) {
-  ASSERT(register_index >= 0);
-  ASSERT(register_index <= kMaxRegister);
+  DCHECK(register_index >= 0);
+  DCHECK(register_index <= kMaxRegister);
   Emit(BC_SET_REGISTER_TO_SP, register_index);
 }
 
 
 void RegExpMacroAssemblerIrregexp::ReadStackPointerFromRegister(
     int register_index) {
-  ASSERT(register_index >= 0);
-  ASSERT(register_index <= kMaxRegister);
+  DCHECK(register_index >= 0);
+  DCHECK(register_index <= kMaxRegister);
   Emit(BC_SET_SP_TO_REGISTER, register_index);
 }
 
 
 void RegExpMacroAssemblerIrregexp::SetCurrentPositionFromEnd(int by) {
-  ASSERT(is_uint24(by));
+  DCHECK(is_uint24(by));
   Emit(BC_SET_CURRENT_POSITION_FROM_END, by);
 }
 
 
 void RegExpMacroAssemblerIrregexp::SetRegister(int register_index, int to) {
-  ASSERT(register_index >= 0);
-  ASSERT(register_index <= kMaxRegister);
+  DCHECK(register_index >= 0);
+  DCHECK(register_index <= kMaxRegister);
   Emit(BC_SET_REGISTER, register_index);
   Emit32(to);
 }
 
 
 void RegExpMacroAssemblerIrregexp::AdvanceRegister(int register_index, int by) {
-  ASSERT(register_index >= 0);
-  ASSERT(register_index <= kMaxRegister);
+  DCHECK(register_index >= 0);
+  DCHECK(register_index <= kMaxRegister);
   Emit(BC_ADVANCE_REGISTER, register_index);
   Emit32(by);
 }
 
 
 void RegExpMacroAssemblerIrregexp::PopCurrentPosition() {
   Emit(BC_POP_CP, 0);
 }
 
 
@@ skipping 33 matching lines @@
   return false;  // Restart matching for global regexp not supported.
 }
 
 
 void RegExpMacroAssemblerIrregexp::Fail() {
   Emit(BC_FAIL, 0);
 }
 
 
 void RegExpMacroAssemblerIrregexp::AdvanceCurrentPosition(int by) {
-  ASSERT(by >= kMinCPOffset);
-  ASSERT(by <= kMaxCPOffset);
+  DCHECK(by >= kMinCPOffset);
+  DCHECK(by <= kMaxCPOffset);
   advance_current_start_ = pc_;
   advance_current_offset_ = by;
   Emit(BC_ADVANCE_CP, by);
   advance_current_end_ = pc_;
 }
 
 
 void RegExpMacroAssemblerIrregexp::CheckGreedyLoop(
       Label* on_tos_equals_current_position) {
   Emit(BC_CHECK_GREEDY, 0);
   EmitOrLink(on_tos_equals_current_position);
 }
 
 
 void RegExpMacroAssemblerIrregexp::LoadCurrentCharacter(int cp_offset,
                                                         Label* on_failure,
                                                         bool check_bounds,
                                                         int characters) {
-  ASSERT(cp_offset >= kMinCPOffset);
-  ASSERT(cp_offset <= kMaxCPOffset);
+  DCHECK(cp_offset >= kMinCPOffset);
+  DCHECK(cp_offset <= kMaxCPOffset);
   int bytecode;
   if (check_bounds) {
     if (characters == 4) {
       bytecode = BC_LOAD_4_CURRENT_CHARS;
     } else if (characters == 2) {
       bytecode = BC_LOAD_2_CURRENT_CHARS;
     } else {
-      ASSERT(characters == 1);
+      DCHECK(characters == 1);
       bytecode = BC_LOAD_CURRENT_CHAR;
     }
   } else {
     if (characters == 4) {
       bytecode = BC_LOAD_4_CURRENT_CHARS_UNCHECKED;
     } else if (characters == 2) {
       bytecode = BC_LOAD_2_CURRENT_CHARS_UNCHECKED;
     } else {
-      ASSERT(characters == 1);
+      DCHECK(characters == 1);
       bytecode = BC_LOAD_CURRENT_CHAR_UNCHECKED;
     }
   }
   Emit(bytecode, cp_offset);
   if (check_bounds) EmitOrLink(on_failure);
 }
 
 
 void RegExpMacroAssemblerIrregexp::CheckCharacterLT(uc16 limit,
                                                     Label* on_less) {
@@ skipping 117 matching lines @@
     for (int j = 0; j < kBitsPerByte; j++) {
       if (table->get(i + j) != 0) byte |= 1 << j;
     }
     Emit8(byte);
   }
 }
 
 
 void RegExpMacroAssemblerIrregexp::CheckNotBackReference(int start_reg,
                                                          Label* on_not_equal) {
-  ASSERT(start_reg >= 0);
-  ASSERT(start_reg <= kMaxRegister);
+  DCHECK(start_reg >= 0);
+  DCHECK(start_reg <= kMaxRegister);
   Emit(BC_CHECK_NOT_BACK_REF, start_reg);
   EmitOrLink(on_not_equal);
 }
 
 
 void RegExpMacroAssemblerIrregexp::CheckNotBackReferenceIgnoreCase(
     int start_reg,
     Label* on_not_equal) {
-  ASSERT(start_reg >= 0);
-  ASSERT(start_reg <= kMaxRegister);
+  DCHECK(start_reg >= 0);
+  DCHECK(start_reg <= kMaxRegister);
   Emit(BC_CHECK_NOT_BACK_REF_NO_CASE, start_reg);
   EmitOrLink(on_not_equal);
 }
 
 
 void RegExpMacroAssemblerIrregexp::IfRegisterLT(int register_index,
                                                 int comparand,
                                                 Label* on_less_than) {
-  ASSERT(register_index >= 0);
-  ASSERT(register_index <= kMaxRegister);
+  DCHECK(register_index >= 0);
+  DCHECK(register_index <= kMaxRegister);
   Emit(BC_CHECK_REGISTER_LT, register_index);
   Emit32(comparand);
   EmitOrLink(on_less_than);
 }
 
 
 void RegExpMacroAssemblerIrregexp::IfRegisterGE(int register_index,
                                                 int comparand,
                                                 Label* on_greater_or_equal) {
-  ASSERT(register_index >= 0);
-  ASSERT(register_index <= kMaxRegister);
+  DCHECK(register_index >= 0);
+  DCHECK(register_index <= kMaxRegister);
   Emit(BC_CHECK_REGISTER_GE, register_index);
   Emit32(comparand);
   EmitOrLink(on_greater_or_equal);
 }
 
 
 void RegExpMacroAssemblerIrregexp::IfRegisterEqPos(int register_index,
                                                    Label* on_eq) {
-  ASSERT(register_index >= 0);
-  ASSERT(register_index <= kMaxRegister);
+  DCHECK(register_index >= 0);
+  DCHECK(register_index <= kMaxRegister);
   Emit(BC_CHECK_REGISTER_EQ_POS, register_index);
   EmitOrLink(on_eq);
 }
 
 
 Handle<HeapObject> RegExpMacroAssemblerIrregexp::GetCode(
     Handle<String> source) {
   Bind(&backtrack_);
   Emit(BC_POP_BT, 0);
   Handle<ByteArray> array = isolate_->factory()->NewByteArray(length());
@@ skipping 19 matching lines @@
   own_buffer_ = true;
   MemCopy(buffer_.start(), old_buffer.start(), old_buffer.length());
   if (old_buffer_was_our_own) {
     old_buffer.Dispose();
   }
 }
 
 #endif  // V8_INTERPRETED_REGEXP
 
 } }  // namespace v8::internal