2011-11-29 10:56:11 +00:00
|
|
|
// Copyright 2011 the V8 project authors. All rights reserved.
|
2014-04-29 06:42:26 +00:00
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file.
|
2010-09-10 09:22:41 +00:00
|
|
|
|
|
|
|
#ifndef V8_STRING_SEARCH_H_
|
|
|
|
#define V8_STRING_SEARCH_H_
|
|
|
|
|
2015-08-20 07:44:00 +00:00
|
|
|
#include "src/isolate.h"
|
|
|
|
#include "src/vector.h"
|
|
|
|
|
2010-09-10 09:22:41 +00:00
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
|
|
|
|
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
//---------------------------------------------------------------------
|
|
|
|
// String Search object.
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
|
|
|
|
// Class holding constants and methods that apply to all string search variants,
|
|
|
|
// independently of subject and pattern char size.
|
|
|
|
class StringSearchBase {
|
|
|
|
protected:
|
|
|
|
// Cap on the maximal shift in the Boyer-Moore implementation. By setting a
|
|
|
|
// limit, we can fix the size of tables. For a needle longer than this limit,
|
|
|
|
// search will not be optimal, since we only build tables for a suffix
|
|
|
|
// of the string, but it is a safe approximation.
|
2011-03-18 20:35:07 +00:00
|
|
|
static const int kBMMaxShift = Isolate::kBMMaxShift;
|
2010-09-29 10:57:23 +00:00
|
|
|
|
|
|
|
// 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.
|
2014-09-10 12:38:12 +00:00
|
|
|
static const int kLatin1AlphabetSize = 256;
|
2011-03-18 20:35:07 +00:00
|
|
|
static const int kUC16AlphabetSize = Isolate::kUC16AlphabetSize;
|
2010-09-29 10:57:23 +00:00
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
2013-01-09 15:47:53 +00:00
|
|
|
static inline bool IsOneByteString(Vector<const uint8_t> string) {
|
2010-09-29 10:57:23 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-01-09 10:30:54 +00:00
|
|
|
static inline bool IsOneByteString(Vector<const uc16> string) {
|
|
|
|
return String::IsOneByte(string.start(), string.length());
|
2010-09-29 10:57:23 +00:00
|
|
|
}
|
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
friend class Isolate;
|
2010-09-29 10:57:23 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
template <typename PatternChar, typename SubjectChar>
|
|
|
|
class StringSearch : private StringSearchBase {
|
2010-09-10 09:22:41 +00:00
|
|
|
public:
|
2011-03-18 20:35:07 +00:00
|
|
|
StringSearch(Isolate* isolate, Vector<const PatternChar> pattern)
|
|
|
|
: isolate_(isolate),
|
|
|
|
pattern_(pattern),
|
2010-09-29 10:57:23 +00:00
|
|
|
start_(Max(0, pattern.length() - kBMMaxShift)) {
|
|
|
|
if (sizeof(PatternChar) > sizeof(SubjectChar)) {
|
2013-01-09 10:30:54 +00:00
|
|
|
if (!IsOneByteString(pattern_)) {
|
2010-09-29 10:57:23 +00:00
|
|
|
strategy_ = &FailSearch;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
int pattern_length = pattern_.length();
|
|
|
|
if (pattern_length < kBMMinPatternLength) {
|
|
|
|
if (pattern_length == 1) {
|
|
|
|
strategy_ = &SingleCharSearch;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
strategy_ = &LinearSearch;
|
|
|
|
return;
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
2010-09-29 10:57:23 +00:00
|
|
|
strategy_ = &InitialSearch;
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
2010-09-29 10:57:23 +00:00
|
|
|
|
|
|
|
int Search(Vector<const SubjectChar> subject, int index) {
|
|
|
|
return strategy_(this, subject, index);
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
2010-09-29 10:57:23 +00:00
|
|
|
|
|
|
|
static inline int AlphabetSize() {
|
|
|
|
if (sizeof(PatternChar) == 1) {
|
2014-09-10 12:38:12 +00:00
|
|
|
// Latin1 needle.
|
|
|
|
return kLatin1AlphabetSize;
|
2010-09-29 10:57:23 +00:00
|
|
|
} else {
|
2014-08-04 11:34:54 +00:00
|
|
|
DCHECK(sizeof(PatternChar) == 2);
|
2010-09-29 10:57:23 +00:00
|
|
|
// UC16 needle.
|
|
|
|
return kUC16AlphabetSize;
|
|
|
|
}
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
2010-09-29 10:57:23 +00:00
|
|
|
|
2010-09-10 09:22:41 +00:00
|
|
|
private:
|
2010-09-29 10:57:23 +00:00
|
|
|
typedef int (*SearchFunction)( // NOLINT - it's not a cast!
|
|
|
|
StringSearch<PatternChar, SubjectChar>*,
|
|
|
|
Vector<const SubjectChar>,
|
|
|
|
int);
|
|
|
|
|
|
|
|
static int FailSearch(StringSearch<PatternChar, SubjectChar>*,
|
|
|
|
Vector<const SubjectChar>,
|
|
|
|
int) {
|
|
|
|
return -1;
|
|
|
|
}
|
2010-09-10 09:22:41 +00:00
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
void PopulateBoyerMooreHorspoolTable();
|
|
|
|
|
|
|
|
void PopulateBoyerMooreTable();
|
|
|
|
|
2013-01-09 15:47:53 +00:00
|
|
|
static inline bool exceedsOneByte(uint8_t c) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool exceedsOneByte(uint16_t c) {
|
|
|
|
return c > String::kMaxOneByteCharCodeU;
|
|
|
|
}
|
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
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) {
|
2013-01-09 15:47:53 +00:00
|
|
|
if (exceedsOneByte(char_code)) {
|
2010-09-29 10:57:23 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2010-10-01 09:08:52 +00:00
|
|
|
return bad_char_occurrence[static_cast<unsigned int>(char_code)];
|
2010-09-29 10:57:23 +00:00
|
|
|
}
|
2010-10-01 09:08:52 +00:00
|
|
|
// Both pattern and subject are UC16. Reduce character to equivalence class.
|
2010-09-29 10:57:23 +00:00
|
|
|
int equiv_class = char_code % kUC16AlphabetSize;
|
|
|
|
return bad_char_occurrence[equiv_class];
|
|
|
|
}
|
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
// The following tables are shared by all searches.
|
|
|
|
// TODO(lrn): Introduce a way for a pattern to keep its tables
|
|
|
|
// between searches (e.g., for an Atom RegExp).
|
|
|
|
|
|
|
|
// Store for the BoyerMoore(Horspool) bad char shift table.
|
2010-09-29 10:57:23 +00:00
|
|
|
// Return a table covering the last kBMMaxShift+1 positions of
|
|
|
|
// pattern.
|
|
|
|
int* bad_char_table() {
|
2011-03-18 20:35:07 +00:00
|
|
|
return isolate_->bad_char_shift_table();
|
2010-09-29 10:57:23 +00:00
|
|
|
}
|
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
// Store for the BoyerMoore good suffix shift table.
|
2010-09-29 10:57:23 +00:00
|
|
|
int* good_suffix_shift_table() {
|
|
|
|
// Return biased pointer that maps the range [start_..pattern_.length()
|
|
|
|
// to the kGoodSuffixShiftTable array.
|
2011-03-18 20:35:07 +00:00
|
|
|
return isolate_->good_suffix_shift_table() - start_;
|
2010-09-29 10:57:23 +00:00
|
|
|
}
|
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
// Table used temporarily while building the BoyerMoore good suffix
|
|
|
|
// shift table.
|
2010-09-29 10:57:23 +00:00
|
|
|
int* suffix_table() {
|
|
|
|
// Return biased pointer that maps the range [start_..pattern_.length()
|
|
|
|
// to the kSuffixTable array.
|
2011-03-18 20:35:07 +00:00
|
|
|
return isolate_->suffix_table() - start_;
|
2010-09-29 10:57:23 +00:00
|
|
|
}
|
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
Isolate* isolate_;
|
2010-09-29 10:57:23 +00:00
|
|
|
// The pattern to search for.
|
|
|
|
Vector<const PatternChar> pattern_;
|
|
|
|
// Pointer to implementation of the search.
|
|
|
|
SearchFunction strategy_;
|
|
|
|
// Cache value of Max(0, pattern_length() - kBMMaxShift)
|
|
|
|
int start_;
|
2010-09-10 09:22:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2015-09-04 19:58:35 +00:00
|
|
|
template <typename PatternChar, typename SubjectChar>
|
|
|
|
int FindFirstCharacter(Vector<const PatternChar> pattern,
|
|
|
|
Vector<const SubjectChar> subject, int index) {
|
|
|
|
PatternChar pattern_first_char = pattern[0];
|
|
|
|
const int max_n = (subject.length() - pattern.length() + 1);
|
|
|
|
|
|
|
|
if (sizeof(SubjectChar) == 1 && sizeof(PatternChar) == 1) {
|
|
|
|
DCHECK_GE(max_n - index, 0);
|
|
|
|
const SubjectChar* char_pos = reinterpret_cast<const SubjectChar*>(
|
|
|
|
memchr(subject.start() + index, pattern_first_char, max_n - index));
|
|
|
|
if (char_pos == NULL) return -1;
|
|
|
|
return static_cast<int>(char_pos - subject.start());
|
|
|
|
} else {
|
|
|
|
const uint8_t search_low_byte =
|
|
|
|
static_cast<uint8_t>(pattern_first_char & 0xFF);
|
|
|
|
const SubjectChar search_char =
|
|
|
|
static_cast<SubjectChar>(pattern_first_char);
|
|
|
|
int pos = index;
|
|
|
|
do {
|
|
|
|
DCHECK_GE(max_n - pos, 0);
|
|
|
|
const SubjectChar* char_pos = reinterpret_cast<const SubjectChar*>(
|
|
|
|
memchr(subject.start() + pos, search_low_byte,
|
|
|
|
(max_n - pos) * sizeof(SubjectChar)));
|
|
|
|
if (char_pos == NULL) return -1;
|
|
|
|
pos = static_cast<int>(char_pos - subject.start());
|
|
|
|
if (IsAligned(reinterpret_cast<uintptr_t>(char_pos),
|
|
|
|
sizeof(SubjectChar))) {
|
|
|
|
if (subject[pos] == search_char) return pos;
|
|
|
|
}
|
|
|
|
} while (++pos < max_n);
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
//---------------------------------------------------------------------
|
|
|
|
// Single Character Pattern Search Strategy
|
|
|
|
//---------------------------------------------------------------------
|
2010-09-10 09:22:41 +00:00
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
template <typename PatternChar, typename SubjectChar>
|
|
|
|
int StringSearch<PatternChar, SubjectChar>::SingleCharSearch(
|
|
|
|
StringSearch<PatternChar, SubjectChar>* search,
|
|
|
|
Vector<const SubjectChar> subject,
|
|
|
|
int index) {
|
2014-08-04 11:34:54 +00:00
|
|
|
DCHECK_EQ(1, search->pattern_.length());
|
2010-09-29 10:57:23 +00:00
|
|
|
PatternChar pattern_first_char = search->pattern_[0];
|
|
|
|
if (sizeof(SubjectChar) == 1 && sizeof(PatternChar) == 1) {
|
2015-09-04 19:58:35 +00:00
|
|
|
return FindFirstCharacter(search->pattern_, subject, index);
|
2010-09-10 09:22:41 +00:00
|
|
|
} else {
|
2010-09-29 10:57:23 +00:00
|
|
|
if (sizeof(PatternChar) > sizeof(SubjectChar)) {
|
2013-01-09 15:47:53 +00:00
|
|
|
if (exceedsOneByte(pattern_first_char)) {
|
2010-09-29 10:57:23 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
2015-09-04 19:58:35 +00:00
|
|
|
return FindFirstCharacter(search->pattern_, subject, index);
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
2010-09-29 10:57:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
// Linear Search Strategy
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
template <typename PatternChar, typename SubjectChar>
|
2011-11-29 10:56:11 +00:00
|
|
|
inline bool CharCompare(const PatternChar* pattern,
|
|
|
|
const SubjectChar* subject,
|
|
|
|
int length) {
|
2014-08-04 11:34:54 +00:00
|
|
|
DCHECK(length > 0);
|
2010-09-29 10:57:23 +00:00
|
|
|
int pos = 0;
|
|
|
|
do {
|
|
|
|
if (pattern[pos] != subject[pos]) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
pos++;
|
|
|
|
} while (pos < length);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Simple linear search for short patterns. Never bails out.
|
|
|
|
template <typename PatternChar, typename SubjectChar>
|
|
|
|
int StringSearch<PatternChar, SubjectChar>::LinearSearch(
|
|
|
|
StringSearch<PatternChar, SubjectChar>* search,
|
|
|
|
Vector<const SubjectChar> subject,
|
|
|
|
int index) {
|
|
|
|
Vector<const PatternChar> pattern = search->pattern_;
|
2014-08-04 11:34:54 +00:00
|
|
|
DCHECK(pattern.length() > 1);
|
2010-09-29 10:57:23 +00:00
|
|
|
int pattern_length = pattern.length();
|
|
|
|
int i = index;
|
|
|
|
int n = subject.length() - pattern_length;
|
|
|
|
while (i <= n) {
|
2015-09-04 19:58:35 +00:00
|
|
|
i = FindFirstCharacter(pattern, subject, i);
|
|
|
|
if (i == -1) return -1;
|
|
|
|
DCHECK_LE(i, n);
|
|
|
|
i++;
|
2010-09-29 10:57:23 +00:00
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
// Boyer-Moore string search
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
|
|
|
|
template <typename PatternChar, typename SubjectChar>
|
|
|
|
int StringSearch<PatternChar, SubjectChar>::BoyerMooreSearch(
|
|
|
|
StringSearch<PatternChar, SubjectChar>* search,
|
|
|
|
Vector<const SubjectChar> subject,
|
|
|
|
int start_index) {
|
|
|
|
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.
|
2010-09-29 14:06:30 +00:00
|
|
|
index += pattern_length - 1
|
|
|
|
- CharOccurrence(bad_char_occurence,
|
|
|
|
static_cast<SubjectChar>(last_char));
|
2010-09-29 10:57:23 +00:00
|
|
|
} 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;
|
|
|
|
}
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
2010-09-29 10:57:23 +00:00
|
|
|
|
|
|
|
return -1;
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
template <typename PatternChar, typename SubjectChar>
|
|
|
|
void StringSearch<PatternChar, SubjectChar>::PopulateBoyerMooreTable() {
|
|
|
|
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;
|
2010-09-10 09:22:41 +00:00
|
|
|
|
2011-12-21 21:28:41 +00:00
|
|
|
if (pattern_length <= start) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
// Find suffixes.
|
|
|
|
PatternChar last_char = pattern[pattern_length - 1];
|
|
|
|
int suffix = pattern_length + 1;
|
2010-09-10 09:22:41 +00:00
|
|
|
{
|
2010-09-29 10:57:23 +00:00
|
|
|
int i = pattern_length;
|
2010-09-10 09:22:41 +00:00
|
|
|
while (i > start) {
|
|
|
|
PatternChar c = pattern[i - 1];
|
2010-09-29 10:57:23 +00:00
|
|
|
while (suffix <= pattern_length && c != pattern[suffix - 1]) {
|
|
|
|
if (shift_table[suffix] == length) {
|
|
|
|
shift_table[suffix] = suffix - i;
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
2010-09-29 10:57:23 +00:00
|
|
|
suffix = suffix_table[suffix];
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
2010-09-29 10:57:23 +00:00
|
|
|
suffix_table[--i] = --suffix;
|
|
|
|
if (suffix == pattern_length) {
|
2010-09-10 09:22:41 +00:00
|
|
|
// No suffix to extend, so we check against last_char only.
|
|
|
|
while ((i > start) && (pattern[i - 1] != last_char)) {
|
2010-09-29 10:57:23 +00:00
|
|
|
if (shift_table[pattern_length] == length) {
|
|
|
|
shift_table[pattern_length] = pattern_length - i;
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
2010-09-29 10:57:23 +00:00
|
|
|
suffix_table[--i] = pattern_length;
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
|
|
|
if (i > start) {
|
2010-09-29 10:57:23 +00:00
|
|
|
suffix_table[--i] = --suffix;
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-09-29 10:57:23 +00:00
|
|
|
// 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;
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
|
|
|
if (i == suffix) {
|
2010-09-29 10:57:23 +00:00
|
|
|
suffix = suffix_table[suffix];
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
//---------------------------------------------------------------------
|
|
|
|
// Boyer-Moore-Horspool string search.
|
|
|
|
//---------------------------------------------------------------------
|
2010-09-10 09:22:41 +00:00
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
template <typename PatternChar, typename SubjectChar>
|
|
|
|
int StringSearch<PatternChar, SubjectChar>::BoyerMooreHorspoolSearch(
|
|
|
|
StringSearch<PatternChar, SubjectChar>* search,
|
|
|
|
Vector<const SubjectChar> subject,
|
|
|
|
int start_index) {
|
|
|
|
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;
|
2010-09-10 09:22:41 +00:00
|
|
|
|
|
|
|
// How bad we are doing without a good-suffix table.
|
2010-09-29 10:57:23 +00:00
|
|
|
PatternChar last_char = pattern[pattern_length - 1];
|
|
|
|
int last_char_shift = pattern_length - 1 -
|
2010-09-29 14:06:30 +00:00
|
|
|
CharOccurrence(char_occurrences, static_cast<SubjectChar>(last_char));
|
2010-09-10 09:22:41 +00:00
|
|
|
// Perform search
|
2010-09-29 10:57:23 +00:00
|
|
|
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);
|
2010-09-10 09:22:41 +00:00
|
|
|
int shift = j - bc_occ;
|
2010-09-29 10:57:23 +00:00
|
|
|
index += shift;
|
2010-09-10 09:22:41 +00:00
|
|
|
badness += 1 - shift; // at most zero, so badness cannot increase.
|
2010-09-29 10:57:23 +00:00
|
|
|
if (index > subject_length - pattern_length) {
|
2010-09-10 09:22:41 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
j--;
|
2010-09-29 10:57:23 +00:00
|
|
|
while (j >= 0 && pattern[j] == (subject[index + j])) j--;
|
2010-09-10 09:22:41 +00:00
|
|
|
if (j < 0) {
|
2010-09-29 10:57:23 +00:00
|
|
|
return index;
|
2010-09-10 09:22:41 +00:00
|
|
|
} else {
|
2010-09-29 10:57:23 +00:00
|
|
|
index += last_char_shift;
|
2010-09-10 09:22:41 +00:00
|
|
|
// 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.
|
2010-09-29 10:57:23 +00:00
|
|
|
badness += (pattern_length - j) - last_char_shift;
|
2010-09-10 09:22:41 +00:00
|
|
|
if (badness > 0) {
|
2010-09-29 10:57:23 +00:00
|
|
|
search->PopulateBoyerMooreTable();
|
|
|
|
search->strategy_ = &BoyerMooreSearch;
|
|
|
|
return BoyerMooreSearch(search, subject, index);
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
template <typename PatternChar, typename SubjectChar>
|
|
|
|
void StringSearch<PatternChar, SubjectChar>::PopulateBoyerMooreHorspoolTable() {
|
|
|
|
int pattern_length = pattern_.length();
|
2010-09-10 09:22:41 +00:00
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
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;
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
|
|
|
}
|
2010-09-29 10:57:23 +00:00
|
|
|
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;
|
|
|
|
}
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
//---------------------------------------------------------------------
|
|
|
|
// Linear string search with bailout to BMH.
|
|
|
|
//---------------------------------------------------------------------
|
2010-09-10 09:22:41 +00:00
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
// Simple linear search for short patterns, which bails out if the string
|
|
|
|
// isn't found very early in the subject. Upgrades to BoyerMooreHorspool.
|
2010-09-10 09:22:41 +00:00
|
|
|
template <typename PatternChar, typename SubjectChar>
|
2010-09-29 10:57:23 +00:00
|
|
|
int StringSearch<PatternChar, SubjectChar>::InitialSearch(
|
|
|
|
StringSearch<PatternChar, SubjectChar>* search,
|
|
|
|
Vector<const SubjectChar> subject,
|
|
|
|
int index) {
|
|
|
|
Vector<const PatternChar> pattern = search->pattern_;
|
2010-09-10 09:22:41 +00:00
|
|
|
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.
|
2010-09-29 10:57:23 +00:00
|
|
|
for (int i = index, n = subject.length() - pattern_length; i <= n; i++) {
|
2010-09-10 09:22:41 +00:00
|
|
|
badness++;
|
2010-09-29 10:57:23 +00:00
|
|
|
if (badness <= 0) {
|
2015-09-04 19:58:35 +00:00
|
|
|
i = FindFirstCharacter(pattern, subject, i);
|
|
|
|
if (i == -1) return -1;
|
|
|
|
DCHECK_LE(i, n);
|
2010-09-29 10:57:23 +00:00
|
|
|
int j = 1;
|
|
|
|
do {
|
|
|
|
if (pattern[j] != subject[i + j]) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
j++;
|
|
|
|
} while (j < pattern_length);
|
|
|
|
if (j == pattern_length) {
|
|
|
|
return i;
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
2010-09-29 10:57:23 +00:00
|
|
|
badness += j;
|
2010-09-10 09:22:41 +00:00
|
|
|
} else {
|
2010-09-29 10:57:23 +00:00
|
|
|
search->PopulateBoyerMooreHorspoolTable();
|
|
|
|
search->strategy_ = &BoyerMooreHorspoolSearch;
|
|
|
|
return BoyerMooreHorspoolSearch(search, subject, i);
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-09-29 10:57:23 +00:00
|
|
|
// Perform a a single stand-alone search.
|
|
|
|
// If searching multiple times for the same pattern, a search
|
|
|
|
// object should be constructed once and the Search function then called
|
|
|
|
// for each search.
|
2010-09-10 09:22:41 +00:00
|
|
|
template <typename SubjectChar, typename PatternChar>
|
2011-11-29 10:56:11 +00:00
|
|
|
int SearchString(Isolate* isolate,
|
|
|
|
Vector<const SubjectChar> subject,
|
|
|
|
Vector<const PatternChar> pattern,
|
|
|
|
int start_index) {
|
2011-03-18 20:35:07 +00:00
|
|
|
StringSearch<PatternChar, SubjectChar> search(isolate, pattern);
|
2010-09-29 10:57:23 +00:00
|
|
|
return search.Search(subject, start_index);
|
2010-09-10 09:22:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}} // namespace v8::internal
|
|
|
|
|
|
|
|
#endif // V8_STRING_SEARCH_H_
|