* StringSearch now tests aginst non-ascii needle on an ascii string as the first thing.

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 978 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BMGoodSuffixBuffers);
 };
 
 // buffers reused by BoyerMoore
 static int bad_char_occurence[kBMAlphabetSize];
 static BMGoodSuffixBuffers bmgs_buffers;
 
 // Compute the bad-char table for Boyer-Moore in the static buffer.
 // Return false if the pattern contains non-ASCII characters that cannot be
 // in the searched string.
-template <typename pchar, bool check_ascii>
-static bool BoyerMoorePopulateBadCharTable(Vector<const pchar> pattern,
+template <typename pchar>
+static void BoyerMoorePopulateBadCharTable(Vector<const pchar> pattern,
                                           int start) {
   // Run forwards to populate bad_char_table, so that *last* instance
   // of character equivalence class is the one registered.
   // Notice: Doesn't include the last character.
   for (int i = 0; i < kBMAlphabetSize; i++) {
     bad_char_occurence[i] = start - 1;
   }
   for (int i = start; i < pattern.length(); i++) {
-    uc32 c = pattern[i];
-    bad_char_occurence[c % kBMAlphabetSize] = i;
-    if (check_ascii &&
-        c > String::kMaxAsciiCharCode) {
-      return false;
-    }
+    bad_char_occurence[pattern[i] % kBMAlphabetSize] = i;
   }
-  return true;
 }
 
 template <typename pchar>
 static void BoyerMoorePopulateGoodSuffixTable(Vector<const pchar> pattern,
                                               int start,
                                               int len) {
   int m = pattern.length();
   // Compute Good Suffix tables.
   bmgs_buffers.init(m);
 
@@ skipping 47 matching lines @@
 static int BoyerMooreIndexOf(Vector<const schar> subject,
                              Vector<const pchar> pattern,
                              int start_index) {
   int m = pattern.length();
   int n = subject.length();
 
   // Only preprocess at most kBMMaxShift last characters of pattern.
   int start = m < kBMMaxShift ? 0 : m - kBMMaxShift;
   int len = m - start;
 
-  if (sizeof(pchar) > 1 && sizeof(schar) == 1) {
-    BoyerMoorePopulateBadCharTable<pchar, true>(pattern, start);
-  } else {
-    if (!BoyerMoorePopulateBadCharTable<pchar, false>(pattern, start)) {
-      return -1;
-    }
-  }
+  BoyerMoorePopulateBadCharTable(pattern, start);
 
   int badness = 0;  // How bad we are doing without a good-suffix table.
   int idx;  // No matches found prior to this index.
   // Perform search
   for (idx = start_index; idx <= n - m;) {
     int j = m - 1;
     schar c;
     while (j >= 0 && pattern[j] == (c = subject[idx + j])) j--;
     if (j < 0) {
       return idx;
@@ skipping 93 matching lines @@
   return -1;
 }
 
 // Dispatch to different algorithms for different length of pattern/subject
 template <typename schar, typename pchar>
 static int StringMatchStrategy(Vector<const schar> sub,
                                Vector<const pchar> pat,
                                int start_index) {
   ASSERT(pat.length() > 1);
 
+  // We have an ASCII haystack and a non-ASCII needle. Check if there
+  // really is a non-ASCII character in the needle and bail out if there
+  // is.
+  if (sizeof(pchar) > 1 && sizeof(schar) == 1) {
+    for (int i = 0; i < pat.length(); i++) {
+      uc16 c = pat[i];
+      if (c > String::kMaxAsciiCharCode) {
+        return -1;
+      }
+    }
+  }
   // For small searches, a complex sort is not worth the setup overhead.
   bool complete;
   int idx = SimpleIndexOf(sub, pat, start_index, complete);
   if (complete) return idx;
   return BoyerMooreIndexOf(sub, pat, idx);
 }
 
 // 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()
@@ skipping 4117 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