v8::internal::StringSearch< PatternChar, SubjectChar > Class Template Reference

#include <string-search.h>

Inheritance diagram for v8::internal::StringSearch< PatternChar, SubjectChar >:

Collaboration diagram for v8::internal::StringSearch< PatternChar, SubjectChar >:

Public Member Functions
	StringSearch (Isolate *isolate, Vector< const PatternChar > pattern)
int	Search (Vector< const SubjectChar > subject, int index)

Static Public Member Functions
static int	AlphabetSize ()

Private Types
typedef int(*	SearchFunction) (StringSearch< PatternChar, SubjectChar > *, Vector< const SubjectChar >, int)

Private Member Functions
void	PopulateBoyerMooreHorspoolTable ()
void	PopulateBoyerMooreTable ()
int *	bad_char_table ()
int *	good_suffix_shift_table ()
int *	suffix_table ()

Static Private Member Functions
static int	FailSearch (StringSearch< PatternChar, SubjectChar > *, Vector< const SubjectChar >, int)
static int	SingleCharSearch (StringSearch< PatternChar, SubjectChar > *search, Vector< const SubjectChar > subject, int start_index)
static int	LinearSearch (StringSearch< PatternChar, SubjectChar > *search, Vector< const SubjectChar > subject, int start_index)
static int	InitialSearch (StringSearch< PatternChar, SubjectChar > *search, Vector< const SubjectChar > subject, int start_index)
static int	BoyerMooreHorspoolSearch (StringSearch< PatternChar, SubjectChar > *search, Vector< const SubjectChar > subject, int start_index)
static int	BoyerMooreSearch (StringSearch< PatternChar, SubjectChar > *search, Vector< const SubjectChar > subject, int start_index)
static bool	exceedsOneByte (uint8_t c)
static bool	exceedsOneByte (uint16_t c)
static int	CharOccurrence (int *bad_char_occurrence, SubjectChar char_code)
Static Private Member Functions inherited from v8::internal::StringSearchBase
static bool	IsOneByteString (Vector< const uint8_t > string)
static bool	IsOneByteString (Vector< const uc16 > string)

Private Attributes
Isolate *	isolate_
Vector< const PatternChar >	pattern_
SearchFunction	strategy_
int	start_

Additional Inherited Members
Static Private Attributes inherited from v8::internal::StringSearchBase
static const int	kBMMaxShift = Isolate::kBMMaxShift
static const int	kLatin1AlphabetSize = 256
static const int	kUC16AlphabetSize = Isolate::kUC16AlphabetSize
static const int	kBMMinPatternLength = 7

Detailed Description

template<typename PatternChar, typename SubjectChar>
class v8::internal::StringSearch< PatternChar, SubjectChar >

Definition at line 54 of file string-search.h.

Member Typedef Documentation

SearchFunction

template<typename PatternChar , typename SubjectChar >

typedef int(* v8::internal::StringSearch< PatternChar, SubjectChar >::SearchFunction) ( StringSearch< PatternChar, SubjectChar > *, Vector< const SubjectChar >, int)

private

Definition at line 94 of file string-search.h.

Constructor & Destructor Documentation

StringSearch()

template<typename PatternChar , typename SubjectChar >

v8::internal::StringSearch< PatternChar, SubjectChar >::StringSearch ( Isolate *  isolate, Vector< const PatternChar >  pattern  )

inline

Definition at line 56 of file string-search.h.

      : isolate_(isolate),
        pattern_(pattern),
        start_(Max(0, pattern.length() - kBMMaxShift)) {
    if (sizeof(PatternChar) > sizeof(SubjectChar)) {
      if (!IsOneByteString(pattern_)) {
        strategy_ = &FailSearch;
        return;
      }
    }
    int pattern_length = pattern_.length();
    if (pattern_length < kBMMinPatternLength) {
      if (pattern_length == 1) {
        strategy_ = &SingleCharSearch;
        return;
      }
      strategy_ = &LinearSearch;
      return;
    }
    strategy_ = &InitialSearch;
  }

References v8::internal::StringSearch< PatternChar, SubjectChar >::FailSearch(), v8::internal::StringSearch< PatternChar, SubjectChar >::InitialSearch(), v8::internal::StringSearchBase::IsOneByteString(), v8::internal::StringSearchBase::kBMMinPatternLength, v8::internal::Vector< T >::length(), v8::internal::StringSearch< PatternChar, SubjectChar >::LinearSearch(), v8::internal::StringSearch< PatternChar, SubjectChar >::pattern_, v8::internal::StringSearch< PatternChar, SubjectChar >::SingleCharSearch(), and v8::internal::StringSearch< PatternChar, SubjectChar >::strategy_.

Here is the call graph for this function:

Member Function Documentation

AlphabetSize()

template<typename PatternChar , typename SubjectChar >

static int v8::internal::StringSearch< PatternChar, SubjectChar >::AlphabetSize ( )

inlinestatic

Definition at line 82 of file string-search.h.

                                   {
    if (sizeof(PatternChar) == 1) {
      // Latin1 needle.
      return kLatin1AlphabetSize;
    } else {
      DCHECK(sizeof(PatternChar) == 2);
      // UC16 needle.
      return kUC16AlphabetSize;
    }
  }

References DCHECK, v8::internal::StringSearchBase::kLatin1AlphabetSize, and v8::internal::StringSearchBase::kUC16AlphabetSize.

bad_char_table()

template<typename PatternChar , typename SubjectChar >

int* v8::internal::StringSearch< PatternChar, SubjectChar >::bad_char_table ( )

inlineprivate

Definition at line 161 of file string-search.h.

                        {
    return isolate_->bad_char_shift_table();
  }

References v8::internal::StringSearch< PatternChar, SubjectChar >::isolate_.

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::BoyerMooreHorspoolSearch(), and v8::internal::StringSearch< PatternChar, SubjectChar >::BoyerMooreSearch().

Here is the caller graph for this function:

BoyerMooreHorspoolSearch()

template<typename PatternChar , typename SubjectChar >

int v8::internal::StringSearch< PatternChar, SubjectChar >::BoyerMooreHorspoolSearch ( StringSearch< PatternChar, SubjectChar > *  search, Vector< const SubjectChar >  subject, int  start_index  )

staticprivate

Definition at line 407 of file string-search.h.

                     {
  Vector<const PatternChar> pattern = search->pattern_;
  int subject_length = subject.length();
  int pattern_length = pattern.length();
  int* char_occurrences = search->bad_char_table();
  int badness = -pattern_length;
 
  // How bad we are doing without a good-suffix table.
  PatternChar last_char = pattern[pattern_length - 1];
  int last_char_shift = pattern_length - 1 -
      CharOccurrence(char_occurrences, static_cast<SubjectChar>(last_char));
  // Perform search
  int index = start_index;  // No matches found prior to this index.
  while (index <= subject_length - pattern_length) {
    int j = pattern_length - 1;
    int subject_char;
    while (last_char != (subject_char = subject[index + j])) {
      int bc_occ = CharOccurrence(char_occurrences, subject_char);
      int shift = j - bc_occ;
      index += shift;
      badness += 1 - shift;  // at most zero, so badness cannot increase.
      if (index > subject_length - pattern_length) {
        return -1;
      }
    }
    j--;
    while (j >= 0 && pattern[j] == (subject[index + j])) j--;
    if (j < 0) {
      return index;
    } else {
      index += last_char_shift;
      // Badness increases by the number of characters we have
      // checked, and decreases by the number of characters we
      // can skip by shifting. It's a measure of how we are doing
      // compared to reading each character exactly once.
      badness += (pattern_length - j) - last_char_shift;
      if (badness > 0) {
        search->PopulateBoyerMooreTable();
        search->strategy_ = &BoyerMooreSearch;
        return BoyerMooreSearch(search, subject, index);
      }
    }
  }
  return -1;
}

References v8::internal::StringSearch< PatternChar, SubjectChar >::bad_char_table(), v8::internal::Vector< T >::length(), v8::internal::StringSearch< PatternChar, SubjectChar >::pattern_, v8::internal::StringSearch< PatternChar, SubjectChar >::PopulateBoyerMooreTable(), shift, and v8::internal::StringSearch< PatternChar, SubjectChar >::strategy_.

Here is the call graph for this function:

BoyerMooreSearch()

template<typename PatternChar , typename SubjectChar >

int v8::internal::StringSearch< PatternChar, SubjectChar >::BoyerMooreSearch ( StringSearch< PatternChar, SubjectChar > *  search, Vector< const SubjectChar >  subject, int  start_index  )

staticprivate

Definition at line 284 of file string-search.h.

                     {
  Vector<const PatternChar> pattern = search->pattern_;
  int subject_length = subject.length();
  int pattern_length = pattern.length();
  // Only preprocess at most kBMMaxShift last characters of pattern.
  int start = search->start_;
 
  int* bad_char_occurence = search->bad_char_table();
  int* good_suffix_shift = search->good_suffix_shift_table();
 
  PatternChar last_char = pattern[pattern_length - 1];
  int index = start_index;
  // Continue search from i.
  while (index <= subject_length - pattern_length) {
    int j = pattern_length - 1;
    int c;
    while (last_char != (c = subject[index + j])) {
      int shift =
          j - CharOccurrence(bad_char_occurence, c);
      index += shift;
      if (index > subject_length - pattern_length) {
        return -1;
      }
    }
    while (j >= 0 && pattern[j] == (c = subject[index + j])) j--;
    if (j < 0) {
      return index;
    } else if (j < start) {
      // we have matched more than our tables allow us to be smart about.
      // Fall back on BMH shift.
      index += pattern_length - 1
          - CharOccurrence(bad_char_occurence,
                           static_cast<SubjectChar>(last_char));
    } else {
      int gs_shift = good_suffix_shift[j + 1];
      int bc_occ =
          CharOccurrence(bad_char_occurence, c);
      int shift = j - bc_occ;
      if (gs_shift > shift) {
        shift = gs_shift;
      }
      index += shift;
    }
  }
 
  return -1;
}

References v8::internal::StringSearch< PatternChar, SubjectChar >::bad_char_table(), v8::internal::StringSearch< PatternChar, SubjectChar >::good_suffix_shift_table(), v8::internal::Vector< T >::length(), v8::internal::StringSearch< PatternChar, SubjectChar >::pattern_, shift, and v8::internal::StringSearch< PatternChar, SubjectChar >::start_.

Here is the call graph for this function:

CharOccurrence()

template<typename PatternChar , typename SubjectChar >

static int v8::internal::StringSearch< PatternChar, SubjectChar >::CharOccurrence ( int *  bad_char_occurrence, SubjectChar  char_code  )

inlinestaticprivate

Definition at line 138 of file string-search.h.

                                                          {
    if (sizeof(SubjectChar) == 1) {
      return bad_char_occurrence[static_cast<int>(char_code)];
    }
    if (sizeof(PatternChar) == 1) {
      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];
  }

References v8::internal::StringSearch< PatternChar, SubjectChar >::exceedsOneByte(), and v8::internal::StringSearchBase::kUC16AlphabetSize.

Here is the call graph for this function:

exceedsOneByte() [1/2]

template<typename PatternChar , typename SubjectChar >

static bool v8::internal::StringSearch< PatternChar, SubjectChar >::exceedsOneByte ( uint16_t  c )

inlinestaticprivate

Definition at line 134 of file string-search.h.

                                                {
    return c > String::kMaxOneByteCharCodeU;
  }

References v8::internal::String::kMaxOneByteCharCodeU.

exceedsOneByte() [2/2]

template<typename PatternChar , typename SubjectChar >

static bool v8::internal::StringSearch< PatternChar, SubjectChar >::exceedsOneByte ( uint8_t  c )

inlinestaticprivate

Definition at line 130 of file string-search.h.

                                               {
    return false;
  }

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::CharOccurrence().

Here is the caller graph for this function:

FailSearch()

template<typename PatternChar , typename SubjectChar >

static int v8::internal::StringSearch< PatternChar, SubjectChar >::FailSearch ( StringSearch< PatternChar, SubjectChar > *  , Vector< const SubjectChar >  , int    )

inlinestaticprivate

Definition at line 99 of file string-search.h.

                             {
    return -1;
  }

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::StringSearch().

Here is the caller graph for this function:

good_suffix_shift_table()

template<typename PatternChar , typename SubjectChar >

int* v8::internal::StringSearch< PatternChar, SubjectChar >::good_suffix_shift_table ( )

inlineprivate

Definition at line 166 of file string-search.h.

                                 {
    // Return biased pointer that maps the range  [start_..pattern_.length()
    // to the kGoodSuffixShiftTable array.
    return isolate_->good_suffix_shift_table() - start_;
  }

References v8::internal::StringSearch< PatternChar, SubjectChar >::isolate_, and v8::internal::StringSearch< PatternChar, SubjectChar >::start_.

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::BoyerMooreSearch().

Here is the caller graph for this function:

InitialSearch()

template<typename PatternChar , typename SubjectChar >

int v8::internal::StringSearch< PatternChar, SubjectChar >::InitialSearch ( StringSearch< PatternChar, SubjectChar > *  search, Vector< const SubjectChar >  subject, int  start_index  )

staticprivate

Definition at line 492 of file string-search.h.

               {
  Vector<const PatternChar> pattern = search->pattern_;
  int pattern_length = pattern.length();
  // Badness is a count of how much work we have done.  When we have
  // done enough work we decide it's probably worth switching to a better
  // algorithm.
  int badness = -10 - (pattern_length << 2);
 
  // 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.
  PatternChar pattern_first_char = pattern[0];
  for (int i = index, n = subject.length() - pattern_length; i <= n; i++) {
    badness++;
    if (badness <= 0) {
      if (sizeof(SubjectChar) == 1 && sizeof(PatternChar) == 1) {
        const SubjectChar* pos = reinterpret_cast<const SubjectChar*>(
            memchr(subject.start() + i,
                   pattern_first_char,
                   n - i + 1));
        if (pos == NULL) {
          return -1;
        }
        i = static_cast<int>(pos - subject.start());
      } else {
        if (subject[i] != pattern_first_char) continue;
      }
      int j = 1;
      do {
        if (pattern[j] != subject[i + j]) {
          break;
        }
        j++;
      } while (j < pattern_length);
      if (j == pattern_length) {
        return i;
      }
      badness += j;
    } else {
      search->PopulateBoyerMooreHorspoolTable();
      search->strategy_ = &BoyerMooreHorspoolSearch;
      return BoyerMooreHorspoolSearch(search, subject, i);
    }
  }
  return -1;
}

References v8::internal::Vector< T >::length(), NULL, v8::internal::StringSearch< PatternChar, SubjectChar >::pattern_, v8::internal::StringSearch< PatternChar, SubjectChar >::PopulateBoyerMooreHorspoolTable(), v8::internal::Vector< T >::start(), and v8::internal::StringSearch< PatternChar, SubjectChar >::strategy_.

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::StringSearch().

Here is the call graph for this function:

Here is the caller graph for this function:

LinearSearch()

template<typename PatternChar , typename SubjectChar >

int v8::internal::StringSearch< PatternChar, SubjectChar >::LinearSearch ( StringSearch< PatternChar, SubjectChar > *  search, Vector< const SubjectChar >  subject, int  start_index  )

staticprivate

Definition at line 247 of file string-search.h.

               {
  Vector<const PatternChar> pattern = search->pattern_;
  DCHECK(pattern.length() > 1);
  int pattern_length = pattern.length();
  PatternChar pattern_first_char = pattern[0];
  int i = index;
  int n = subject.length() - pattern_length;
  while (i <= n) {
    if (sizeof(SubjectChar) == 1 && sizeof(PatternChar) == 1) {
      const SubjectChar* pos = reinterpret_cast<const SubjectChar*>(
          memchr(subject.start() + i,
                 pattern_first_char,
                 n - i + 1));
      if (pos == NULL) return -1;
      i = static_cast<int>(pos - subject.start()) + 1;
    } else {
      if (subject[i++] != pattern_first_char) continue;
    }
    // Loop extracted to separate function to allow using return to do
    // a deeper break.
    if (CharCompare(pattern.start() + 1,
                    subject.start() + i,
                    pattern_length - 1)) {
      return i - 1;
    }
  }
  return -1;
}

References v8::internal::CharCompare(), DCHECK, v8::internal::Vector< T >::length(), NULL, v8::internal::StringSearch< PatternChar, SubjectChar >::pattern_, and v8::internal::Vector< T >::start().

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::StringSearch().

Here is the call graph for this function:

Here is the caller graph for this function:

PopulateBoyerMooreHorspoolTable()

template<typename PatternChar , typename SubjectChar >

void v8::internal::StringSearch< PatternChar, SubjectChar >::PopulateBoyerMooreHorspoolTable

private

Definition at line 458 of file string-search.h.

                                                                             {
  int pattern_length = pattern_.length();
 
  int* bad_char_occurrence = bad_char_table();
 
  // Only preprocess at most kBMMaxShift last characters of pattern.
  int start = 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.
  int table_size = AlphabetSize();
  if (start == 0) {  // All patterns less than kBMMaxShift in length.
    memset(bad_char_occurrence,
           -1,
           table_size * sizeof(*bad_char_occurrence));
  } else {
    for (int i = 0; i < table_size; i++) {
      bad_char_occurrence[i] = start - 1;
    }
  }
  for (int i = start; i < pattern_length - 1; i++) {
    PatternChar c = pattern_[i];
    int bucket = (sizeof(PatternChar) == 1) ? c : c % AlphabetSize();
    bad_char_occurrence[bucket] = i;
  }
}

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::InitialSearch().

Here is the caller graph for this function:

PopulateBoyerMooreTable()

template<typename PatternChar , typename SubjectChar >

void v8::internal::StringSearch< PatternChar, SubjectChar >::PopulateBoyerMooreTable

private

Definition at line 337 of file string-search.h.

                                                                     {
  int pattern_length = pattern_.length();
  const PatternChar* pattern = pattern_.start();
  // Only look at the last kBMMaxShift characters of pattern (from start_
  // to pattern_length).
  int start = start_;
  int length = pattern_length - start;
 
  // Biased tables so that we can use pattern indices as table indices,
  // even if we only cover the part of the pattern from offset start.
  int* shift_table = good_suffix_shift_table();
  int* suffix_table = this->suffix_table();
 
  // Initialize table.
  for (int i = start; i < pattern_length; i++) {
    shift_table[i] = length;
  }
  shift_table[pattern_length] = 1;
  suffix_table[pattern_length] = pattern_length + 1;
 
  if (pattern_length <= start) {
    return;
  }
 
  // Find suffixes.
  PatternChar last_char = pattern[pattern_length - 1];
  int suffix = pattern_length + 1;
  {
    int i = pattern_length;
    while (i > start) {
      PatternChar c = pattern[i - 1];
      while (suffix <= pattern_length && c != pattern[suffix - 1]) {
        if (shift_table[suffix] == length) {
          shift_table[suffix] = suffix - i;
        }
        suffix = suffix_table[suffix];
      }
      suffix_table[--i] = --suffix;
      if (suffix == pattern_length) {
        // No suffix to extend, so we check against last_char only.
        while ((i > start) && (pattern[i - 1] != last_char)) {
          if (shift_table[pattern_length] == length) {
            shift_table[pattern_length] = pattern_length - i;
          }
          suffix_table[--i] = pattern_length;
        }
        if (i > start) {
          suffix_table[--i] = --suffix;
        }
      }
    }
  }
  // Build shift table using suffixes.
  if (suffix < pattern_length) {
    for (int i = start; i <= pattern_length; i++) {
      if (shift_table[i] == length) {
        shift_table[i] = suffix - start;
      }
      if (i == suffix) {
        suffix = suffix_table[suffix];
      }
    }
  }
}

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::BoyerMooreHorspoolSearch().

Here is the caller graph for this function:

Search()

template<typename PatternChar , typename SubjectChar >

int v8::internal::StringSearch< PatternChar, SubjectChar >::Search ( Vector< const SubjectChar >  subject, int  index  )

inline

Definition at line 78 of file string-search.h.

                                                           {
    return strategy_(this, subject, index);
  }

References v8::internal::StringSearch< PatternChar, SubjectChar >::strategy_.

Referenced by v8::internal::CalculateLineEndsImpl(), v8::internal::FindStringIndices(), v8::internal::SearchString(), and v8::internal::URIUnescape::Unescape().

Here is the caller graph for this function:

SingleCharSearch()

template<typename PatternChar , typename SubjectChar >

int v8::internal::StringSearch< PatternChar, SubjectChar >::SingleCharSearch ( StringSearch< PatternChar, SubjectChar > *  search, Vector< const SubjectChar >  subject, int  start_index  )

staticprivate

Definition at line 195 of file string-search.h.

               {
  DCHECK_EQ(1, search->pattern_.length());
  PatternChar pattern_first_char = search->pattern_[0];
  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 (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;
  }
}

References DCHECK_EQ, v8::internal::Vector< T >::length(), NULL, v8::internal::StringSearch< PatternChar, SubjectChar >::pattern_, and v8::internal::Vector< T >::start().

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::StringSearch().

Here is the call graph for this function:

Here is the caller graph for this function:

suffix_table()

template<typename PatternChar , typename SubjectChar >

int* v8::internal::StringSearch< PatternChar, SubjectChar >::suffix_table ( )

inlineprivate

Definition at line 174 of file string-search.h.

                      {
    // Return biased pointer that maps the range  [start_..pattern_.length()
    // to the kSuffixTable array.
    return isolate_->suffix_table() - start_;
  }

References v8::internal::StringSearch< PatternChar, SubjectChar >::isolate_, and v8::internal::StringSearch< PatternChar, SubjectChar >::start_.

Member Data Documentation

isolate_

template<typename PatternChar , typename SubjectChar >

Isolate* v8::internal::StringSearch< PatternChar, SubjectChar >::isolate_

private

Definition at line 180 of file string-search.h.

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::bad_char_table(), v8::internal::StringSearch< PatternChar, SubjectChar >::good_suffix_shift_table(), and v8::internal::StringSearch< PatternChar, SubjectChar >::suffix_table().

pattern_

template<typename PatternChar , typename SubjectChar >

Vector<const PatternChar> v8::internal::StringSearch< PatternChar, SubjectChar >::pattern_

private

Definition at line 182 of file string-search.h.

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::BoyerMooreHorspoolSearch(), v8::internal::StringSearch< PatternChar, SubjectChar >::BoyerMooreSearch(), v8::internal::StringSearch< PatternChar, SubjectChar >::InitialSearch(), v8::internal::StringSearch< PatternChar, SubjectChar >::LinearSearch(), v8::internal::StringSearch< PatternChar, SubjectChar >::SingleCharSearch(), and v8::internal::StringSearch< PatternChar, SubjectChar >::StringSearch().

start_

template<typename PatternChar , typename SubjectChar >

int v8::internal::StringSearch< PatternChar, SubjectChar >::start_

private

Definition at line 186 of file string-search.h.

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::BoyerMooreSearch(), v8::internal::StringSearch< PatternChar, SubjectChar >::good_suffix_shift_table(), and v8::internal::StringSearch< PatternChar, SubjectChar >::suffix_table().

strategy_

template<typename PatternChar , typename SubjectChar >

SearchFunction v8::internal::StringSearch< PatternChar, SubjectChar >::strategy_

private

Definition at line 184 of file string-search.h.

Referenced by v8::internal::StringSearch< PatternChar, SubjectChar >::BoyerMooreHorspoolSearch(), v8::internal::StringSearch< PatternChar, SubjectChar >::InitialSearch(), v8::internal::StringSearch< PatternChar, SubjectChar >::Search(), and v8::internal::StringSearch< PatternChar, SubjectChar >::StringSearch().

---

The documentation for this class was generated from the following file:

• /mnt/V8SourceCode/src/string-search.h