Reland Extend big-disjunction optimization to case-independent regexps

src/vector.h

 // 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.
 
 #ifndef V8_VECTOR_H_
 #define V8_VECTOR_H_
 
 #include <string.h>
 #include <algorithm>
 
@@ skipping 51 matching lines @@
   inline iterator begin() const { return &start_[0]; }
   inline iterator end() const { return &start_[length_]; }
 
   // Returns a clone of this vector with a new backing store.
   Vector<T> Clone() const {
     T* result = NewArray<T>(length_);
     for (int i = 0; i < length_; i++) result[i] = start_[i];
     return Vector<T>(result, length_);
   }
 
-  void Sort(int (*cmp)(const T*, const T*), size_t s, size_t l) {
-    std::sort(start() + s, start() + s + l, RawComparer(cmp));
+  template <typename CompareFunction>
+  void Sort(CompareFunction cmp, size_t s, size_t l) {
+    std::sort(start() + s, start() + s + l, RawComparer<CompareFunction>(cmp));
   }
 
-  void Sort(int (*cmp)(const T*, const T*)) {
-    std::sort(start(), start() + length(), RawComparer(cmp));
+  template <typename CompareFunction>
+  void Sort(CompareFunction cmp) {
+    std::sort(start(), start() + length(), RawComparer<CompareFunction>(cmp));
   }
 
   void Sort() {
     std::sort(start(), start() + length());
   }
 
-  void StableSort(int (*cmp)(const T*, const T*), size_t s, size_t l) {
-    std::stable_sort(start() + s, start() + s + l, RawComparer(cmp));
+  template <typename CompareFunction>
+  void StableSort(CompareFunction cmp, size_t s, size_t l) {
+    std::stable_sort(start() + s, start() + s + l,
+                     RawComparer<CompareFunction>(cmp));
   }
 
-  void StableSort(int (*cmp)(const T*, const T*)) {
-    std::stable_sort(start(), start() + length(), RawComparer(cmp));
+  template <typename CompareFunction>
+  void StableSort(CompareFunction cmp) {
+    std::stable_sort(start(), start() + length(),
+                     RawComparer<CompareFunction>(cmp));
   }
 
   void StableSort() { std::stable_sort(start(), start() + length()); }
 
   void Truncate(int length) {
     DCHECK(length <= length_);
     length_ = length;
   }
 
   // Releases the array underlying this vector. Once disposed the
@@ skipping 29 matching lines @@
     return true;
   }
 
  protected:
   void set_start(T* start) { start_ = start; }
 
  private:
   T* start_;
   int length_;
 
+  template <typename CookedComparer>
   class RawComparer {
    public:
-    explicit RawComparer(int (*cmp)(const T*, const T*)) : cmp_(cmp) {}
+    explicit RawComparer(CookedComparer cmp) : cmp_(cmp) {}
     bool operator()(const T& a, const T& b) {
       return cmp_(&a, &b) < 0;
     }
 
    private:
-    int (*cmp_)(const T*, const T*);
+    CookedComparer cmp_;
   };
 };
 
 
 template <typename T>
 class ScopedVector : public Vector<T> {
  public:
   explicit ScopedVector(int length) : Vector<T>(NewArray<T>(length), length) { }
   ~ScopedVector() {
     DeleteArray(this->start());
@@ skipping 33 matching lines @@
 
 inline Vector<char> MutableCStrVector(char* data, int max) {
   int length = StrLength(data);
   return Vector<char>(data, (length < max) ? length : max);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VECTOR_H_