Faster string.replace with regexp pattern.

src/regexp-macro-assembler-ia32.cc

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 960 matching lines @@
 }
 
 
 void RegExpMacroAssemblerIA32::WriteStackPointerToRegister(int reg) {
   __ mov(eax, backtrack_stackpointer());
   __ sub(eax, Operand(ebp, kStackHighEnd));
   __ mov(register_location(reg), eax);
 }
 
 
+
+RegExpMacroAssemblerIA32::Result RegExpMacroAssemblerIA32::Match(
+    Handle<Code> regexp_code,
+    Handle<String> subject,
+    int* offsets_vector,
+    int offsets_vector_length,
+    int previous_index) {
+  StringShape shape(*subject);
+
+  // Character offsets into string.
+  int start_offset = previous_index;
+  int end_offset = subject->length(shape);
+
+  if (shape.IsCons()) {
+    subject =
+      Handle<String>(String::cast(ConsString::cast(*subject)->first()));
+  } else if (shape.IsSliced()) {
+    SlicedString* slice = SlicedString::cast(*subject);
+    start_offset += slice->start();
+    end_offset += slice->start();
+    subject = Handle<String>(String::cast(slice->buffer()));
+  }
+
+  // String is now either Sequential or External
+  StringShape flatshape(*subject);
+  bool is_ascii = flatshape.IsAsciiRepresentation();
+  int char_size_shift = is_ascii ? 0 : 1;
+
+  RegExpMacroAssemblerIA32::Result res;
+
+  if (flatshape.IsExternal()) {
+    const byte* address;
+    if (is_ascii) {
+      ExternalAsciiString* ext = ExternalAsciiString::cast(*subject);
+      address = reinterpret_cast<const byte*>(ext->resource()->data());
+    } else {
+      ExternalTwoByteString* ext = ExternalTwoByteString::cast(*subject);
+      address = reinterpret_cast<const byte*>(ext->resource()->data());
+    }
+
+    res = Execute(*regexp_code,
+                  const_cast<Address*>(&address),
+                  start_offset << char_size_shift,
+                  end_offset << char_size_shift,
+                  offsets_vector,
+                  previous_index == 0);
+  } else {  // Sequential string
+    ASSERT(StringShape(*subject).IsSequential());
+    Address char_address =
+        is_ascii ? SeqAsciiString::cast(*subject)->GetCharsAddress()
+                 : SeqTwoByteString::cast(*subject)->GetCharsAddress();
+    int byte_offset = char_address - reinterpret_cast<Address>(*subject);
+    res = Execute(*regexp_code,
+                  reinterpret_cast<Address*>(subject.location()),
+                  byte_offset + (start_offset << char_size_shift),
+                  byte_offset + (end_offset << char_size_shift),
+                  offsets_vector,
+                  previous_index == 0);
+  }
+
+  if (res == RegExpMacroAssemblerIA32::SUCCESS) {
+    // Capture values are relative to start_offset only.
+    for (int i = 0; i < offsets_vector_length; i++) {
+      if (offsets_vector[i] >= 0) {
+        offsets_vector[i] += previous_index;
+      }
+    }
+  }
+
+  return res;
+}
+
+
 // Private methods:
 
 
 static unibrow::Mapping<unibrow::Ecma262Canonicalize> canonicalize;
 
 RegExpMacroAssemblerIA32::Result RegExpMacroAssemblerIA32::Execute(
     Code* code,
     Address* input,
     int start_offset,
     int end_offset,
@@ skipping 261 matching lines @@
 
 
 void RegExpMacroAssemblerIA32::LoadConstantBufferAddress(Register reg,
                                                          ArraySlice* buffer) {
   __ mov(reg, buffer->array());
   __ add(Operand(reg), Immediate(buffer->base_offset()));
 }
 
 #undef __
 }}  // namespace v8::internal