Continues Latin-1 support. All tests pass with ENABLE_LATIN_1 flag.

src/string-search.h

 // Copyright 2011 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 35 matching lines @@
   // of the string, but it is a safe approximation.
   static const int kBMMaxShift = Isolate::kBMMaxShift;
 
   // Reduce alphabet to this size.
   // One of the tables used by Boyer-Moore and Boyer-Moore-Horspool has size
   // proportional to the input alphabet. We reduce the alphabet size by
   // equating input characters modulo a smaller alphabet size. This gives
   // a potentially less efficient searching, but is a safe approximation.
   // For needles using only characters in the same Unicode 256-code point page,
   // there is no search speed degradation.
+#ifndef ENABLE_LATIN_1
   static const int kAsciiAlphabetSize = 128;
+#else
+  static const int kAsciiAlphabetSize = 256;
+#endif
   static const int kUC16AlphabetSize = Isolate::kUC16AlphabetSize;
 
   // Bad-char shift table stored in the state. It's length is the alphabet size.
   // For patterns below this length, the skip length of Boyer-Moore is too short
   // to compensate for the algorithmic overhead compared to simple brute force.
   static const int kBMMinPatternLength = 7;
 
-  static inline bool IsOneByteString(Vector<const char> string) {
+  static inline bool IsOneByteString(Vector<const uint8_t> string) {
     return true;
   }
 
   static inline bool IsOneByteString(Vector<const uc16> string) {
     return String::IsOneByte(string.start(), string.length());
   }
 
   friend class Isolate;
 };
 
@@ skipping 68 matching lines @@
       int start_index);
 
   static int BoyerMooreSearch(StringSearch<PatternChar, SubjectChar>* search,
                               Vector<const SubjectChar> subject,
                               int start_index);
 
   void PopulateBoyerMooreHorspoolTable();
 
   void PopulateBoyerMooreTable();
 
+  static inline bool exceedsOneByte(uint8_t c) {
+    return false;

[Yang, 2013/01/09 15:39:30]

Don't we still need to gate this with ENABLE_LATIN_1?

+  }
+
+  static inline bool exceedsOneByte(uint16_t c) {
+    return c > String::kMaxOneByteCharCodeU;
+  }
+
   static inline int CharOccurrence(int* bad_char_occurrence,
                                    SubjectChar char_code) {
     if (sizeof(SubjectChar) == 1) {
       return bad_char_occurrence[static_cast<int>(char_code)];
     }
     if (sizeof(PatternChar) == 1) {
-      if (static_cast<unsigned int>(char_code) > String::kMaxOneByteCharCodeU) {
+      if (exceedsOneByte(char_code)) {
         return -1;
       }
       return bad_char_occurrence[static_cast<unsigned int>(char_code)];
     }
     // Both pattern and subject are UC16. Reduce character to equivalence class.
     int equiv_class = char_code % kUC16AlphabetSize;
     return bad_char_occurrence[equiv_class];
   }
 
   // The following tables are shared by all searches.
@@ skipping 46 matching lines @@
   int i = index;
   if (sizeof(SubjectChar) == 1 && sizeof(PatternChar) == 1) {
     const SubjectChar* pos = reinterpret_cast<const SubjectChar*>(
         memchr(subject.start() + i,
                pattern_first_char,
                subject.length() - i));
     if (pos == NULL) return -1;
     return static_cast<int>(pos - subject.start());
   } else {
     if (sizeof(PatternChar) > sizeof(SubjectChar)) {
-      if (static_cast<uc16>(pattern_first_char) >
-            String::kMaxOneByteCharCodeU) {
+      if (exceedsOneByte(pattern_first_char)) {
         return -1;
       }
     }
     SubjectChar search_char = static_cast<SubjectChar>(pattern_first_char);
     int n = subject.length();
     while (i < n) {
       if (subject[i++] == search_char) return i - 1;
     }
     return -1;
   }
@@ skipping 326 matching lines @@
                  Vector<const SubjectChar> subject,
                  Vector<const PatternChar> pattern,
                  int start_index) {
   StringSearch<PatternChar, SubjectChar> search(isolate, pattern);
   return search.Search(subject, start_index);
 }
 
 }}  // namespace v8::internal
 
 #endif  // V8_STRING_SEARCH_H_