Added special case for atomic regular expressions.

src/runtime.cc

 // Copyright 2006-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 233 matching lines @@
 
 static Object* Runtime_RegExpCompile(Arguments args) {
   HandleScope scope;  // create a new handle scope
   ASSERT(args.length() == 3);
   CONVERT_CHECKED(JSRegExp, raw_re, args[0]);
   Handle<JSRegExp> re(raw_re);
   CONVERT_CHECKED(String, raw_pattern, args[1]);
   Handle<String> pattern(raw_pattern);
   CONVERT_CHECKED(String, raw_flags, args[2]);
   Handle<String> flags(raw_flags);
-  return *RegExpImpl::JsreCompile(re, pattern, flags);
+  return *RegExpImpl::Compile(re, pattern, flags);
 }
 
 
 static Object* Runtime_CreateApiFunction(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 1);
   CONVERT_CHECKED(FunctionTemplateInfo, raw_data, args[0]);
   Handle<FunctionTemplateInfo> data(raw_data);
   return *Factory::CreateApiFunction(data);
 }
@@ skipping 432 matching lines @@
 
 static Object* Runtime_RegExpExec(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 3);
   CONVERT_CHECKED(JSRegExp, raw_regexp, args[0]);
   Handle<JSRegExp> regexp(raw_regexp);
   CONVERT_CHECKED(String, raw_subject, args[1]);
   Handle<String> subject(raw_subject);
   Handle<Object> index(args[2]);
   ASSERT(index->IsNumber());
-  return *RegExpImpl::JsreExec(regexp, subject, index);
+  return *RegExpImpl::Exec(regexp, subject, index);
 }
 
 
 static Object* Runtime_RegExpExecGlobal(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 2);
   CONVERT_CHECKED(JSRegExp, raw_regexp, args[0]);
   Handle<JSRegExp> regexp(raw_regexp);
   CONVERT_CHECKED(String, raw_subject, args[1]);
   Handle<String> subject(raw_subject);
-  return *RegExpImpl::JsreExecGlobal(regexp, subject);
+  return *RegExpImpl::ExecGlobal(regexp, subject);
 }
 
 
 static Object* Runtime_MaterializeRegExpLiteral(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 4);
   CONVERT_ARG_CHECKED(FixedArray, literals, 0);
   int index = Smi::cast(args[1])->value();
   Handle<String> pattern = args.at<String>(2);
   Handle<String> flags = args.at<String>(3);
@@ skipping 206 matching lines @@
     p = buffer->GetNext();
     if (p == pattern->Get(j)) {
       next_table[i] = next_table[j];
     } else {
       next_table[i] = j;
     }
   }
 }
 
 
-static Object* Runtime_StringIndexOf(Arguments args) {
-  NoHandleAllocation ha;
-  ASSERT(args.length() == 3);
-
-  CONVERT_CHECKED(String, sub, args[0]);
-  CONVERT_CHECKED(String, pat, args[1]);
-  Object* index = args[2];
-
+int Runtime::StringMatchKmp(String* sub, String* pat, int start_index) {
   sub->TryFlatten();
   pat->TryFlatten();
 
   int subject_length = sub->length();
   int pattern_length = pat->length();
 
-  uint32_t start_index;
-  if (!Array::IndexFromObject(index, &start_index)) return Smi::FromInt(-1);
-  if (pattern_length == 0) return Smi::FromInt(start_index);
+  if (start_index > subject_length) return -1;
+  if (pattern_length == 0) return start_index;
 
   // Searching for one specific character is common.  For one
   // character patterns the KMP algorithm is guaranteed to slow down
   // the search, so we just run through the subject string.
   if (pattern_length == 1) {
     uint16_t pattern_char = pat->Get(0);
     for (int i = start_index; i < subject_length; i++) {
       if (sub->Get(i) == pattern_char) {
-        return Smi::FromInt(i);
+        return i;
       }
     }
-    return Smi::FromInt(-1);
+    return -1;
   }
 
   // For small searches, KMP is not worth the setup overhead.
   if (subject_length < 100) {
     // We know our pattern is at least 2 characters, we cache the first so
     // the common case of the first character not matching is faster.
     uint16_t pattern_first_char = pat->Get(0);
     for (int i = start_index; i + pattern_length <= subject_length; i++) {
       if (sub->Get(i) != pattern_first_char) continue;
 
       for (int j = 1; j < pattern_length; j++) {
         if (pat->Get(j) != sub->Get(j + i)) break;
-        if (j == pattern_length - 1) return Smi::FromInt(i);
+        if (j == pattern_length - 1) return i;
       }
     }
-    return Smi::FromInt(-1);
+    return -1;
   }
 
   // For patterns with a larger length we use the KMP algorithm.
   //
   // Compute the 'next' table.
   int* next_table = NewArray<int>(pattern_length);
   ComputeKMPNextTable(pat, next_table);
   // Search using the 'next' table.
   int pattern_index = 0;
   // We would like to use StringInputBuffer here, but it does not have
   // the ability to start anywhere but the first character of a
   // string.  It would be nice to have efficient forward-seeking
   // support on StringInputBuffers.
   int subject_index = start_index;
   while (subject_index < subject_length) {
     uint16_t subject_char = sub->Get(subject_index);
     while (pattern_index > -1 && pat->Get(pattern_index) != subject_char) {
       pattern_index = next_table[pattern_index];
     }
     pattern_index++;
     subject_index++;
     if (pattern_index >= pattern_length) {
       DeleteArray(next_table);
-      return Smi::FromInt(subject_index - pattern_index);
+      return subject_index - pattern_index;
     }
   }
   DeleteArray(next_table);
-  return Smi::FromInt(-1);
+  return -1;
 }
 
 
+static Object* Runtime_StringIndexOf(Arguments args) {
+  NoHandleAllocation ha;
+  ASSERT(args.length() == 3);
+
+  CONVERT_CHECKED(String, sub, args[0]);
+  CONVERT_CHECKED(String, pat, args[1]);
+  Object* index = args[2];
+  uint32_t start_index;
+  if (!Array::IndexFromObject(index, &start_index)) return Smi::FromInt(-1);
+
+  return Smi::FromInt(Runtime::StringMatchKmp(sub, pat, start_index));
+}
+
+
 static Object* Runtime_StringLastIndexOf(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 3);
 
   CONVERT_CHECKED(String, sub, args[0]);
   CONVERT_CHECKED(String, pat, args[1]);
   Object* index = args[2];
 
   sub->TryFlatten();
   pat->TryFlatten();
@@ skipping 3985 matching lines @@
 
 void Runtime::PerformGC(Object* result) {
   Failure* failure = Failure::cast(result);
   // Try to do a garbage collection; ignore it if it fails. The C
   // entry stub will throw an out-of-memory exception in that case.
   Heap::CollectGarbage(failure->requested(), failure->allocation_space());
 }
 
 
 } }  // namespace v8::internal