Move some Runtime:: functions and remove runtime.h as include when unnecessary.

src/runtime/runtime-strings.cc

 // Copyright 2014 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/arguments.h"
 #include "src/jsregexp-inl.h"
 #include "src/jsregexp.h"
-#include "src/runtime/runtime.h"
 #include "src/runtime/runtime-utils.h"
 #include "src/runtime/string-builder.h"
 #include "src/string-search.h"
 
 namespace v8 {
 namespace internal {
 
 
+// Perform string match of pattern on subject, starting at start index.
+// Caller must ensure that 0 <= start_index <= sub->length(),
+// and should check that pat->length() + start_index <= sub->length().
+int StringMatch(Isolate* isolate, Handle<String> sub, Handle<String> pat,
+                int start_index) {
+  DCHECK(0 <= start_index);
+  DCHECK(start_index <= sub->length());
+
+  int pattern_length = pat->length();
+  if (pattern_length == 0) return start_index;
+
+  int subject_length = sub->length();
+  if (start_index + pattern_length > subject_length) return -1;
+
+  sub = String::Flatten(sub);
+  pat = String::Flatten(pat);
+
+  DisallowHeapAllocation no_gc;  // ensure vectors stay valid
+  // Extract flattened substrings of cons strings before getting encoding.
+  String::FlatContent seq_sub = sub->GetFlatContent();
+  String::FlatContent seq_pat = pat->GetFlatContent();
+
+  // dispatch on type of strings
+  if (seq_pat.IsOneByte()) {
+    Vector<const uint8_t> pat_vector = seq_pat.ToOneByteVector();
+    if (seq_sub.IsOneByte()) {
+      return SearchString(isolate, seq_sub.ToOneByteVector(), pat_vector,
+                          start_index);
+    }
+    return SearchString(isolate, seq_sub.ToUC16Vector(), pat_vector,
+                        start_index);
+  }
+  Vector<const uc16> pat_vector = seq_pat.ToUC16Vector();
+  if (seq_sub.IsOneByte()) {
+    return SearchString(isolate, seq_sub.ToOneByteVector(), pat_vector,
+                        start_index);
+  }
+  return SearchString(isolate, seq_sub.ToUC16Vector(), pat_vector, start_index);
+}
+
+
 // This may return an empty MaybeHandle if an exception is thrown or
 // we abort due to reaching the recursion limit.
 MaybeHandle<String> StringReplaceOneCharWithString(
     Isolate* isolate, Handle<String> subject, Handle<String> search,
     Handle<String> replace, bool* found, int recursion_limit) {
   StackLimitCheck stackLimitCheck(isolate);
   if (stackLimitCheck.HasOverflowed() || (recursion_limit == 0)) {
     return MaybeHandle<String>();
   }
   recursion_limit--;
@@ skipping 11 matching lines @@
     Handle<String> new_second;
     if (!StringReplaceOneCharWithString(isolate, second, search, replace, found,
                                         recursion_limit)
              .ToHandle(&new_second)) {
       return MaybeHandle<String>();
     }
     if (*found) return isolate->factory()->NewConsString(first, new_second);
 
     return subject;
   } else {
-    int index = Runtime::StringMatch(isolate, subject, search, 0);
+    int index = StringMatch(isolate, subject, search, 0);
     if (index == -1) return subject;
     *found = true;
     Handle<String> first = isolate->factory()->NewSubString(subject, 0, index);
     Handle<String> cons1;
     ASSIGN_RETURN_ON_EXCEPTION(
         isolate, cons1, isolate->factory()->NewConsString(first, replace),
         String);
     Handle<String> second =
         isolate->factory()->NewSubString(subject, index + 1, subject->length());
     return isolate->factory()->NewConsString(cons1, second);
@@ skipping 33 matching lines @@
   DCHECK(args.length() == 3);
 
   CONVERT_ARG_HANDLE_CHECKED(String, sub, 0);
   CONVERT_ARG_HANDLE_CHECKED(String, pat, 1);
   CONVERT_ARG_HANDLE_CHECKED(Object, index, 2);
 
   uint32_t start_index;
   if (!index->ToArrayIndex(&start_index)) return Smi::FromInt(-1);
 
   RUNTIME_ASSERT(start_index <= static_cast<uint32_t>(sub->length()));
-  int position = Runtime::StringMatch(isolate, sub, pat, start_index);
+  int position = StringMatch(isolate, sub, pat, start_index);
   return Smi::FromInt(position);
 }
 
 
 template <typename schar, typename pchar>
 static int StringMatchBackwards(Vector<const schar> subject,
                                 Vector<const pchar> pattern, int idx) {
   int pattern_length = pattern.length();
   DCHECK(pattern_length >= 1);
   DCHECK(idx + pattern_length <= subject.length());
@@ skipping 1142 matching lines @@
   return __RT_impl_Runtime_StringAdd(args, isolate);
 }
 
 
 RUNTIME_FUNCTION(RuntimeReference_IsStringWrapperSafeForDefaultValueOf) {
   UNIMPLEMENTED();
   return NULL;
 }
 }
 }  // namespace v8::internal