Made regexp robust against changes to a string's implementation.

test/cctest/test-regexp.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 661 matching lines @@
   ~ContextInitializer() {
     env_->Exit();
     env_.Dispose();
   }
  private:
   v8::Persistent<v8::Context> env_;
   v8::HandleScope scope_;
   v8::internal::StackGuard stack_guard_;
 };
 
-// Helper functions for calling the Execute method.
-template <typename T>
+
 static RegExpMacroAssemblerIA32::Result ExecuteIA32(Code* code,
-                                                    const T** input,
+                                                    String* input,
                                                     int start_offset,
-                                                    int end_offset,
+                                                    const byte* input_start,
+                                                    const byte* input_end,
                                                     int* captures,
                                                     bool at_start) {
   return RegExpMacroAssemblerIA32::Execute(
       code,
-      reinterpret_cast<Address*>(
-          reinterpret_cast<void*>(const_cast<T**>(input))),
+      input,
       start_offset,
-      end_offset,
+      input_start,
+      input_end,
       captures,
       at_start);
 }
-
-template <typename T>
-static RegExpMacroAssemblerIA32::Result ExecuteIA32(Code* code,
-                                                    T** input,
-                                                    int start_offset,
-                                                    int end_offset,
-                                                    int* captures,
-                                                    bool at_start) {
-  return RegExpMacroAssemblerIA32::Execute(
-      code,
-      reinterpret_cast<Address*>(reinterpret_cast<void*>(input)),
-      start_offset,
-      end_offset,
-      captures,
-      at_start);
-}
 
 
 TEST(MacroAssemblerIA32Success) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::ASCII, 4);
 
   m.Succeed();
 
   Handle<String> source = Factory::NewStringFromAscii(CStrVector(""));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   int captures[4] = {42, 37, 87, 117};
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("foofoo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
-  Address start_adr = seq_input->GetCharsAddress();
-  int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  int end_offset = start_offset + seq_input->length();
+  const byte* start_adr =
+      reinterpret_cast<const byte*>(seq_input->GetCharsAddress());
 
   RegExpMacroAssemblerIA32::Result result =
       ExecuteIA32(*code,
-                  seq_input.location(),
-                  start_offset,
-                  end_offset,
+                  *input,
+                  0,
+                  start_adr,
+                  start_adr + seq_input->length(),
                   captures,
                   true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(-1, captures[0]);
   CHECK_EQ(-1, captures[1]);
   CHECK_EQ(-1, captures[2]);
   CHECK_EQ(-1, captures[3]);
 }
 
@@ skipping 17 matching lines @@
   m.Fail();
 
   Handle<String> source = Factory::NewStringFromAscii(CStrVector("^foo"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   int captures[4] = {42, 37, 87, 117};
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("foofoo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
-  int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
       ExecuteIA32(*code,
-                  seq_input.location(),
-                  start_offset,
-                  end_offset,
+                  *input,
+                  0,
+                  start_adr,
+                  start_adr + input->length(),
                   captures,
                   true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, captures[0]);
   CHECK_EQ(3, captures[1]);
   CHECK_EQ(-1, captures[2]);
   CHECK_EQ(-1, captures[3]);
 
   input = Factory::NewStringFromAscii(CStrVector("barbarbar"));
   seq_input = Handle<SeqAsciiString>::cast(input);
   start_adr = seq_input->GetCharsAddress();
-  start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  end_offset = start_offset + seq_input->length();
 
   result = ExecuteIA32(*code,
-                       seq_input.location(),
-                       start_offset,
-                       end_offset,
+                       *input,
+                       0,
+                       start_adr,
+                       start_adr + input->length(),
                        captures,
                        true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::FAILURE, result);
 }
 
 
 TEST(MacroAssemblerIA32SimpleUC16) {
   v8::V8::Initialize();
   ContextInitializer initializer;
@@ skipping 15 matching lines @@
   Handle<String> source = Factory::NewStringFromAscii(CStrVector("^foo"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   int captures[4] = {42, 37, 87, 117};
   const uc16 input_data[6] = {'f', 'o', 'o', 'f', 'o', '\xa0'};
   Handle<String> input =
       Factory::NewStringFromTwoByte(Vector<const uc16>(input_data, 6));
   Handle<SeqTwoByteString> seq_input = Handle<SeqTwoByteString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
-  int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  int end_offset = start_offset + seq_input->length() * sizeof(uc16);
 
   RegExpMacroAssemblerIA32::Result result =
       ExecuteIA32(*code,
-                  seq_input.location(),
-                  start_offset,
-                  end_offset,
+                  *input,
+                  0,
+                  start_adr,
+                  start_adr + input->length(),
                   captures,
                   true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, captures[0]);
   CHECK_EQ(3, captures[1]);
   CHECK_EQ(-1, captures[2]);
   CHECK_EQ(-1, captures[3]);
 
   const uc16 input_data2[9] = {'b', 'a', 'r', 'b', 'a', 'r', 'b', 'a', '\xa0'};
   input = Factory::NewStringFromTwoByte(Vector<const uc16>(input_data2, 9));
   seq_input = Handle<SeqTwoByteString>::cast(input);
   start_adr = seq_input->GetCharsAddress();
-  start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  end_offset = start_offset + seq_input->length() * sizeof(uc16);
 
   result = ExecuteIA32(*code,
-                       seq_input.location(),
-                       start_offset,
-                       end_offset,
+                       *input,
+                       0,
+                       start_adr,
+                       start_adr + input->length() * 2,
                        captures,
                        true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::FAILURE, result);
 }
 
 
 TEST(MacroAssemblerIA32Backtrack) {
   v8::V8::Initialize();
   ContextInitializer initializer;
@@ skipping 11 matching lines @@
   m.Bind(&backtrack);
   m.Fail();
 
   Handle<String> source = Factory::NewStringFromAscii(CStrVector(".........."));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("foofoo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
-  int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
       ExecuteIA32(*code,
-                  seq_input.location(),
-                  start_offset,
-                  end_offset,
+                  *input,
+                  0,
+                  start_adr,
+                  start_adr + input->length(),
                   NULL,
                   true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::FAILURE, result);
 }
 
 
 TEST(MacroAssemblerIA32BackReferenceASCII) {
   v8::V8::Initialize();
   ContextInitializer initializer;
@@ skipping 15 matching lines @@
   m.Bind(&missing_match);
   m.Fail();
 
   Handle<String> source = Factory::NewStringFromAscii(CStrVector("^(..)..\1"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("fooofo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
-  int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  int end_offset = start_offset + seq_input->length();
 
   int output[3];
   RegExpMacroAssemblerIA32::Result result =
       ExecuteIA32(*code,
-                  seq_input.location(),
-                  start_offset,
-                  end_offset,
+                  *input,
+                  0,
+                  start_adr,
+                  start_adr + input->length(),
                   output,
                   true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, output[0]);
   CHECK_EQ(2, output[1]);
   CHECK_EQ(6, output[2]);
 }
 
 
@@ skipping 21 matching lines @@
   Handle<String> source = Factory::NewStringFromAscii(CStrVector("^(..)..\1"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   const uc16 input_data[6] = {'f', 0x2028, 'o', 'o', 'f', 0x2028};
   Handle<String> input =
       Factory::NewStringFromTwoByte(Vector<const uc16>(input_data, 6));
   Handle<SeqTwoByteString> seq_input = Handle<SeqTwoByteString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
 
-  int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  int end_offset = start_offset + seq_input->length() * sizeof(input_data[0]);
-
   int output[3];
   RegExpMacroAssemblerIA32::Result result =
       ExecuteIA32(*code,
-                  seq_input.location(),
-                  start_offset,
-                  end_offset,
+                  *input,
+                  0,
+                  start_adr,
+                  start_adr + input->length() * 2,
                   output,
                   true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, output[0]);
   CHECK_EQ(2, output[1]);
   CHECK_EQ(6, output[2]);
 }
 
 
@@ skipping 25 matching lines @@
   m.CheckNotCharacter('b', &fail);
   m.Succeed();
 
   Handle<String> source = Factory::NewStringFromAscii(CStrVector("(^f|ob)"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("foobar"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
-  int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
       ExecuteIA32(*code,
-                  seq_input.location(),
-                  start_offset,
-                  end_offset,
+                  *input,
+                  0,
+                  start_adr,
+                  start_adr + input->length(),
                   NULL,
                   true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
 
-  start_offset += 3;
   result = ExecuteIA32(*code,
-                       seq_input.location(),
-                       start_offset,
-                       end_offset,
+                       *input,
+                       3,
+                       start_adr + 3,
+                       start_adr + input->length(),
                        NULL,
                        false);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
 }
 
 
 TEST(MacroAssemblerIA32BackRefNoCase) {
   v8::V8::Initialize();
   ContextInitializer initializer;
@@ skipping 24 matching lines @@
 
   Handle<String> source =
       Factory::NewStringFromAscii(CStrVector("^(abc)\1\1(?!\1)...(?!\1)"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   Handle<String> input =
       Factory::NewStringFromAscii(CStrVector("aBcAbCABCxYzab"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
-  int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  int end_offset = start_offset + seq_input->length();
 
   int output[4];
   RegExpMacroAssemblerIA32::Result result =
       ExecuteIA32(*code,
-                  seq_input.location(),
-                  start_offset,
-                  end_offset,
+                  *input,
+                  0,
+                  start_adr,
+                  start_adr + input->length(),
                   output,
                   true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, output[0]);
   CHECK_EQ(12, output[1]);
   CHECK_EQ(0, output[2]);
   CHECK_EQ(3, output[3]);
 }
 
@@ skipping 72 matching lines @@
   Handle<String> source =
       Factory::NewStringFromAscii(CStrVector("<loop test>"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   // String long enough for test (content doesn't matter).
   Handle<String> input =
       Factory::NewStringFromAscii(CStrVector("foofoofoofoofoo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
-  int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  int end_offset = start_offset + seq_input->length();
 
   int output[5];
   RegExpMacroAssemblerIA32::Result result =
       ExecuteIA32(*code,
-                  seq_input.location(),
-                  start_offset,
-                  end_offset,
+                  *input,
+                  0,
+                  start_adr,
+                  start_adr + input->length(),
                   output,
                   true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, output[0]);
   CHECK_EQ(3, output[1]);
   CHECK_EQ(6, output[2]);
   CHECK_EQ(9, output[3]);
   CHECK_EQ(9, output[4]);
 }
@@ skipping 13 matching lines @@
   Handle<String> source =
       Factory::NewStringFromAscii(CStrVector("<stack overflow test>"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   // String long enough for test (content doesn't matter).
   Handle<String> input =
       Factory::NewStringFromAscii(CStrVector("dummy"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
-  int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
       ExecuteIA32(*code,
-                  seq_input.location(),
-                  start_offset,
-                  end_offset,
+                  *input,
+                  0,
+                  start_adr,
+                  start_adr + input->length(),
                   NULL,
                   true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::EXCEPTION, result);
   CHECK(Top::has_pending_exception());
   Top::clear_pending_exception();
 }
 
 
 TEST(MacroAssemblerIA32LotsOfRegisters) {
@@ skipping 18 matching lines @@
   Handle<String> source =
       Factory::NewStringFromAscii(CStrVector("<huge register space test>"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   // String long enough for test (content doesn't matter).
   Handle<String> input =
       Factory::NewStringFromAscii(CStrVector("sample text"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
-  int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
-  int end_offset = start_offset + seq_input->length();
 
   int captures[2];
   RegExpMacroAssemblerIA32::Result result =
       ExecuteIA32(*code,
-                  seq_input.location(),
-                  start_offset,
-                  end_offset,
+                  *input,
+                  0,
+                  start_adr,
+                  start_adr + input->length(),
                   captures,
                   true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, captures[0]);
   CHECK_EQ(42, captures[1]);
 
   Top::clear_pending_exception();
 }
 
@@ skipping 240 matching lines @@
       CHECK(!InClass(i, excluded));
     }
   }
 }
 
 
 TEST(Graph) {
   V8::Initialize(NULL);
   Execute("(?:(?:x(.))?\1)+$", false, true, true);
 }