mirror of https://github.com/lukechilds/node.git
Browse Source
Adds the string search implementation from v8 which uses naive search if pattern length < 8 or to a specific badness then uses Boyer-Moore-Horspool Added benchmark shows the expected improvements Added option to use ucs2 encoding with Buffer::IndexOf Reviewed-By: James M Snell <jasnell@gmail.com> Reviewed-By: Trevor Norris <trev.norris@gmail.com> PR-URL: https://github.com/nodejs/node/pull/2539v5.x
Karl Skomski
9 years ago
committed by
James M Snell
James M Snell
8 changed files with 4935 additions and 60 deletions
@ -0,0 +1,38 @@ |
|||||
|
var common = require('../common.js'); |
||||
|
var fs = require('fs'); |
||||
|
|
||||
|
var bench = common.createBenchmark(main, { |
||||
|
search: ['@', 'SQ', '10x', '--l', 'Alice', 'Gryphon', 'Panther', |
||||
|
'Ou est ma chatte?', 'found it very', 'among mad people', |
||||
|
'neighbouring pool', 'Soo--oop', 'aaaaaaaaaaaaaaaaa', |
||||
|
'venture to go near the house till she had brought herself down to', |
||||
|
'</i> to the Caterpillar'], |
||||
|
encoding: ['undefined', 'utf8', 'ucs2', 'binary'], |
||||
|
type: ['buffer', 'string'], |
||||
|
iter: [1] |
||||
|
}); |
||||
|
|
||||
|
function main(conf) { |
||||
|
var iter = (conf.iter) * 100000; |
||||
|
var aliceBuffer = fs.readFileSync(__dirname + '/../fixtures/alice.html'); |
||||
|
var search = conf.search; |
||||
|
var encoding = conf.encoding; |
||||
|
|
||||
|
if (encoding === 'undefined') { |
||||
|
encoding = undefined; |
||||
|
} |
||||
|
|
||||
|
if (encoding === 'ucs2') { |
||||
|
aliceBuffer = new Buffer(aliceBuffer.toString(), encoding); |
||||
|
} |
||||
|
|
||||
|
if (conf.type === 'buffer') { |
||||
|
search = new Buffer(new Buffer(search).toString(), encoding); |
||||
|
} |
||||
|
|
||||
|
bench.start(); |
||||
|
for (var i = 0; i < iter; i++) { |
||||
|
aliceBuffer.indexOf(search, 0, encoding); |
||||
|
} |
||||
|
bench.end(iter); |
||||
|
} |
||||
File diff suppressed because it is too large
@ -0,0 +1,10 @@ |
|||||
|
#include "string_search.h" |
||||
|
|
||||
|
namespace node { |
||||
|
namespace stringsearch { |
||||
|
|
||||
|
int StringSearchBase::kBadCharShiftTable[kUC16AlphabetSize]; |
||||
|
int StringSearchBase::kGoodSuffixShiftTable[kBMMaxShift + 1]; |
||||
|
int StringSearchBase::kSuffixTable[kBMMaxShift + 1]; |
||||
|
} |
||||
|
} // namespace node::stringsearch
|
||||
@ -0,0 +1,671 @@ |
|||||
|
// Copyright 2011 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 SRC_STRING_SEARCH_H_ |
||||
|
#define SRC_STRING_SEARCH_H_ |
||||
|
|
||||
|
#include "node.h" |
||||
|
#include <string.h> |
||||
|
|
||||
|
namespace node { |
||||
|
namespace stringsearch { |
||||
|
|
||||
|
|
||||
|
// Returns the maximum of the two parameters.
|
||||
|
template <typename T> |
||||
|
T Max(T a, T b) { |
||||
|
return a < b ? b : a; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static const uint32_t kMaxOneByteCharCodeU = 0xff; |
||||
|
|
||||
|
|
||||
|
static inline size_t NonOneByteStart(const uint16_t* chars, size_t length) { |
||||
|
const uint16_t* limit = chars + length; |
||||
|
const uint16_t* start = chars; |
||||
|
while (chars < limit) { |
||||
|
if (*chars > kMaxOneByteCharCodeU) |
||||
|
return static_cast<size_t>(chars - start); |
||||
|
++chars; |
||||
|
} |
||||
|
return static_cast<size_t>(chars - start); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static inline bool IsOneByte(const uint16_t* chars, size_t length) { |
||||
|
return NonOneByteStart(chars, length) >= length; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
template <typename T> |
||||
|
class Vector { |
||||
|
public: |
||||
|
Vector(T* data, size_t length) : start_(data), length_(length) { |
||||
|
ASSERT(length > 0 && data != nullptr); |
||||
|
} |
||||
|
|
||||
|
// Returns the length of the vector.
|
||||
|
size_t length() const { return length_; } |
||||
|
|
||||
|
T* start() const { return start_; } |
||||
|
|
||||
|
// Access individual vector elements - checks bounds in debug mode.
|
||||
|
T& operator[](size_t index) const { |
||||
|
ASSERT(0 <= index && index < length_); |
||||
|
return start_[index]; |
||||
|
} |
||||
|
|
||||
|
const T& at(size_t index) const { return operator[](index); } |
||||
|
|
||||
|
bool operator==(const Vector<T>& other) const { |
||||
|
if (length_ != other.length_) |
||||
|
return false; |
||||
|
if (start_ == other.start_) |
||||
|
return true; |
||||
|
for (size_t i = 0; i < length_; ++i) { |
||||
|
if (start_[i] != other.start_[i]) { |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
T* start_; |
||||
|
size_t length_; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
//---------------------------------------------------------------------
|
||||
|
// 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.
|
||||
|
static const int kBMMaxShift = 250; |
||||
|
|
||||
|
// 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.
|
||||
|
static const int kLatin1AlphabetSize = 256; |
||||
|
static const int kUC16AlphabetSize = 256; |
||||
|
|
||||
|
// 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 = 8; |
||||
|
|
||||
|
// Store for the BoyerMoore(Horspool) bad char shift table.
|
||||
|
static int kBadCharShiftTable[kUC16AlphabetSize]; |
||||
|
// Store for the BoyerMoore good suffix shift table.
|
||||
|
static int kGoodSuffixShiftTable[kBMMaxShift + 1]; |
||||
|
// Table used temporarily while building the BoyerMoore good suffix
|
||||
|
// shift table.
|
||||
|
static int kSuffixTable[kBMMaxShift + 1]; |
||||
|
|
||||
|
static inline bool IsOneByteString(Vector<const uint8_t> string) { |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
static inline bool IsOneByteString(Vector<const uint16_t> string) { |
||||
|
return IsOneByte(string.start(), string.length()); |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
template <typename PatternChar, typename SubjectChar> |
||||
|
class StringSearch : private StringSearchBase { |
||||
|
public: |
||||
|
explicit StringSearch(Vector<const PatternChar> pattern) |
||||
|
: pattern_(pattern), start_(0) { |
||||
|
if (pattern.length() >= kBMMaxShift) { |
||||
|
start_ = pattern.length() - kBMMaxShift; |
||||
|
} |
||||
|
|
||||
|
if (sizeof(PatternChar) > sizeof(SubjectChar)) { |
||||
|
if (!IsOneByteString(pattern_)) { |
||||
|
strategy_ = &FailSearch; |
||||
|
return; |
||||
|
} |
||||
|
} |
||||
|
size_t pattern_length = pattern_.length(); |
||||
|
CHECK_GT(pattern_length, 0); |
||||
|
if (pattern_length < kBMMinPatternLength) { |
||||
|
if (pattern_length == 1) { |
||||
|
strategy_ = &SingleCharSearch; |
||||
|
return; |
||||
|
} |
||||
|
strategy_ = &LinearSearch; |
||||
|
return; |
||||
|
} |
||||
|
strategy_ = &InitialSearch; |
||||
|
} |
||||
|
|
||||
|
size_t Search(Vector<const SubjectChar> subject, size_t index) { |
||||
|
return strategy_(this, subject, index); |
||||
|
} |
||||
|
|
||||
|
static inline int AlphabetSize() { |
||||
|
if (sizeof(PatternChar) == 1) { |
||||
|
// Latin1 needle.
|
||||
|
return kLatin1AlphabetSize; |
||||
|
} else { |
||||
|
// UC16 needle.
|
||||
|
return kUC16AlphabetSize; |
||||
|
} |
||||
|
|
||||
|
static_assert(sizeof(PatternChar) == sizeof(uint8_t) || |
||||
|
sizeof(PatternChar) == sizeof(uint16_t), |
||||
|
"sizeof(PatternChar) == sizeof(uint16_t) || sizeof(uint8_t)"); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
typedef size_t (*SearchFunction)( // NOLINT - it's not a cast!
|
||||
|
StringSearch<PatternChar, SubjectChar>*, |
||||
|
Vector<const SubjectChar>, |
||||
|
size_t); |
||||
|
|
||||
|
static size_t FailSearch(StringSearch<PatternChar, SubjectChar>*, |
||||
|
Vector<const SubjectChar> subject, |
||||
|
size_t) { |
||||
|
return subject.length(); |
||||
|
} |
||||
|
|
||||
|
static size_t SingleCharSearch(StringSearch<PatternChar, SubjectChar>* search, |
||||
|
Vector<const SubjectChar> subject, |
||||
|
size_t start_index); |
||||
|
|
||||
|
static size_t LinearSearch(StringSearch<PatternChar, SubjectChar>* search, |
||||
|
Vector<const SubjectChar> subject, |
||||
|
size_t start_index); |
||||
|
|
||||
|
static size_t InitialSearch(StringSearch<PatternChar, SubjectChar>* search, |
||||
|
Vector<const SubjectChar> subject, |
||||
|
size_t start_index); |
||||
|
|
||||
|
static size_t BoyerMooreHorspoolSearch( |
||||
|
StringSearch<PatternChar, SubjectChar>* search, |
||||
|
Vector<const SubjectChar> subject, |
||||
|
size_t start_index); |
||||
|
|
||||
|
static size_t BoyerMooreSearch(StringSearch<PatternChar, SubjectChar>* search, |
||||
|
Vector<const SubjectChar> subject, |
||||
|
size_t start_index); |
||||
|
|
||||
|
void PopulateBoyerMooreHorspoolTable(); |
||||
|
|
||||
|
void PopulateBoyerMooreTable(); |
||||
|
|
||||
|
static inline bool exceedsOneByte(uint8_t c) { return false; } |
||||
|
|
||||
|
static inline bool exceedsOneByte(uint16_t c) { |
||||
|
return c > 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 (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]; |
||||
|
} |
||||
|
|
||||
|
// Store for the BoyerMoore(Horspool) bad char shift table.
|
||||
|
// Return a table covering the last kBMMaxShift+1 positions of
|
||||
|
// pattern.
|
||||
|
int* bad_char_table() { return kBadCharShiftTable; } |
||||
|
|
||||
|
// Store for the BoyerMoore good suffix shift table.
|
||||
|
int* good_suffix_shift_table() { |
||||
|
// Return biased pointer that maps the range [start_..pattern_.length()
|
||||
|
// to the kGoodSuffixShiftTable array.
|
||||
|
return kGoodSuffixShiftTable - start_; |
||||
|
} |
||||
|
|
||||
|
// Table used temporarily while building the BoyerMoore good suffix
|
||||
|
// shift table.
|
||||
|
int* suffix_table() { |
||||
|
// Return biased pointer that maps the range [start_..pattern_.length()
|
||||
|
// to the kSuffixTable array.
|
||||
|
return kSuffixTable - start_; |
||||
|
} |
||||
|
|
||||
|
// 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)
|
||||
|
size_t start_; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
template <typename T, typename U> |
||||
|
inline T AlignDown(T value, U alignment) { |
||||
|
return reinterpret_cast<T>( |
||||
|
(reinterpret_cast<uintptr_t>(value) & ~(alignment - 1))); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
inline uint8_t GetHighestValueByte(uint16_t character) { |
||||
|
return Max(static_cast<uint8_t>(character & 0xFF), |
||||
|
static_cast<uint8_t>(character >> 8)); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
inline uint8_t GetHighestValueByte(uint8_t character) { return character; } |
||||
|
|
||||
|
|
||||
|
template <typename PatternChar, typename SubjectChar> |
||||
|
inline size_t FindFirstCharacter(Vector<const PatternChar> pattern, |
||||
|
Vector<const SubjectChar> subject, size_t index) { |
||||
|
const PatternChar pattern_first_char = pattern[0]; |
||||
|
const size_t max_n = (subject.length() - pattern.length() + 1); |
||||
|
|
||||
|
const uint8_t search_byte = GetHighestValueByte(pattern_first_char); |
||||
|
const SubjectChar search_char = static_cast<SubjectChar>(pattern_first_char); |
||||
|
size_t pos = index; |
||||
|
do { |
||||
|
const SubjectChar* char_pos = reinterpret_cast<const SubjectChar*>( |
||||
|
memchr(subject.start() + pos, search_byte, |
||||
|
(max_n - pos) * sizeof(SubjectChar))); |
||||
|
if (char_pos == nullptr) |
||||
|
return subject.length(); |
||||
|
char_pos = AlignDown(char_pos, sizeof(SubjectChar)); |
||||
|
pos = static_cast<size_t>(char_pos - subject.start()); |
||||
|
if (subject[pos] == search_char) |
||||
|
return pos; |
||||
|
} while (++pos < max_n); |
||||
|
|
||||
|
return subject.length(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
template <> |
||||
|
inline size_t FindFirstCharacter(Vector<const uint8_t> pattern, |
||||
|
Vector<const uint8_t> subject, |
||||
|
size_t index) { |
||||
|
const uint8_t pattern_first_char = pattern[0]; |
||||
|
const size_t max_n = (subject.length() - pattern.length() + 1); |
||||
|
|
||||
|
const uint8_t* char_pos = reinterpret_cast<const uint8_t*>( |
||||
|
memchr(subject.start() + index, pattern_first_char, max_n - index)); |
||||
|
if (char_pos == nullptr) |
||||
|
return subject.length(); |
||||
|
return static_cast<size_t>(char_pos - subject.start()); |
||||
|
} |
||||
|
|
||||
|
//---------------------------------------------------------------------
|
||||
|
// Single Character Pattern Search Strategy
|
||||
|
//---------------------------------------------------------------------
|
||||
|
|
||||
|
template <typename PatternChar, typename SubjectChar> |
||||
|
size_t StringSearch<PatternChar, SubjectChar>::SingleCharSearch( |
||||
|
StringSearch<PatternChar, SubjectChar>* search, |
||||
|
Vector<const SubjectChar> subject, |
||||
|
size_t index) { |
||||
|
CHECK_EQ(1, search->pattern_.length()); |
||||
|
PatternChar pattern_first_char = search->pattern_[0]; |
||||
|
|
||||
|
if (sizeof(SubjectChar) == 1 && sizeof(PatternChar) == 1) { |
||||
|
return FindFirstCharacter(search->pattern_, subject, index); |
||||
|
} else { |
||||
|
if (sizeof(PatternChar) > sizeof(SubjectChar)) { |
||||
|
if (exceedsOneByte(pattern_first_char)) { |
||||
|
return -1; |
||||
|
} |
||||
|
} |
||||
|
return FindFirstCharacter(search->pattern_, subject, index); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
//---------------------------------------------------------------------
|
||||
|
// Linear Search Strategy
|
||||
|
//---------------------------------------------------------------------
|
||||
|
|
||||
|
template <typename PatternChar, typename SubjectChar> |
||||
|
inline bool CharCompare(const PatternChar* pattern, |
||||
|
const SubjectChar* subject, |
||||
|
size_t length) { |
||||
|
ASSERT_GT(length, 0); |
||||
|
size_t 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> |
||||
|
size_t StringSearch<PatternChar, SubjectChar>::LinearSearch( |
||||
|
StringSearch<PatternChar, SubjectChar>* search, |
||||
|
Vector<const SubjectChar> subject, |
||||
|
size_t index) { |
||||
|
Vector<const PatternChar> pattern = search->pattern_; |
||||
|
CHECK_GT(pattern.length(), 1); |
||||
|
const size_t pattern_length = pattern.length(); |
||||
|
size_t i = index; |
||||
|
const size_t n = subject.length() - pattern_length; |
||||
|
while (i <= n) { |
||||
|
i = FindFirstCharacter(pattern, subject, i); |
||||
|
if (i == subject.length()) |
||||
|
return subject.length(); |
||||
|
ASSERT_LE(i, n); |
||||
|
i++; |
||||
|
|
||||
|
// 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 subject.length(); |
||||
|
} |
||||
|
|
||||
|
//---------------------------------------------------------------------
|
||||
|
// Boyer-Moore string search
|
||||
|
//---------------------------------------------------------------------
|
||||
|
|
||||
|
template <typename PatternChar, typename SubjectChar> |
||||
|
size_t StringSearch<PatternChar, SubjectChar>::BoyerMooreSearch( |
||||
|
StringSearch<PatternChar, SubjectChar>* search, |
||||
|
Vector<const SubjectChar> subject, |
||||
|
size_t start_index) { |
||||
|
Vector<const PatternChar> pattern = search->pattern_; |
||||
|
const size_t subject_length = subject.length(); |
||||
|
const size_t pattern_length = pattern.length(); |
||||
|
// Only preprocess at most kBMMaxShift last characters of pattern.
|
||||
|
size_t 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]; |
||||
|
size_t index = start_index; |
||||
|
// Continue search from i.
|
||||
|
while (index <= subject_length - pattern_length) { |
||||
|
size_t 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 subject.length(); |
||||
|
} |
||||
|
} |
||||
|
while (j >= 0 && pattern[j] == (c = subject[index + j])) { |
||||
|
if (j == 0) { |
||||
|
return index; |
||||
|
} |
||||
|
j--; |
||||
|
} |
||||
|
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 subject.length(); |
||||
|
} |
||||
|
|
||||
|
template <typename PatternChar, typename SubjectChar> |
||||
|
void StringSearch<PatternChar, SubjectChar>::PopulateBoyerMooreTable() { |
||||
|
const size_t pattern_length = pattern_.length(); |
||||
|
const PatternChar* pattern = pattern_.start(); |
||||
|
// Only look at the last kBMMaxShift characters of pattern (from start_
|
||||
|
// to pattern_length).
|
||||
|
const size_t start = start_; |
||||
|
const size_t 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 (size_t 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]; |
||||
|
size_t suffix = pattern_length + 1; |
||||
|
{ |
||||
|
size_t i = pattern_length; |
||||
|
while (i > start) { |
||||
|
PatternChar c = pattern[i - 1]; |
||||
|
while (suffix <= pattern_length && c != pattern[suffix - 1]) { |
||||
|
if (static_cast<size_t>(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 (static_cast<size_t>(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 (size_t i = start; i <= pattern_length; i++) { |
||||
|
if (static_cast<size_t>(shift_table[i]) == length) { |
||||
|
shift_table[i] = suffix - start; |
||||
|
} |
||||
|
if (i == suffix) { |
||||
|
suffix = suffix_table[suffix]; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
//---------------------------------------------------------------------
|
||||
|
// Boyer-Moore-Horspool string search.
|
||||
|
//---------------------------------------------------------------------
|
||||
|
|
||||
|
template <typename PatternChar, typename SubjectChar> |
||||
|
size_t StringSearch<PatternChar, SubjectChar>::BoyerMooreHorspoolSearch( |
||||
|
StringSearch<PatternChar, SubjectChar>* search, |
||||
|
Vector<const SubjectChar> subject, |
||||
|
size_t start_index) { |
||||
|
Vector<const PatternChar> pattern = search->pattern_; |
||||
|
const size_t subject_length = subject.length(); |
||||
|
const size_t pattern_length = pattern.length(); |
||||
|
int* char_occurrences = search->bad_char_table(); |
||||
|
int64_t 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
|
||||
|
size_t index = start_index; // No matches found prior to this index.
|
||||
|
while (index <= subject_length - pattern_length) { |
||||
|
size_t 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 subject_length; |
||||
|
} |
||||
|
} |
||||
|
j--; |
||||
|
while (j >= 0 && pattern[j] == (subject[index + j])) { |
||||
|
if (j == 0) { |
||||
|
return index; |
||||
|
} |
||||
|
j--; |
||||
|
} |
||||
|
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 subject.length(); |
||||
|
} |
||||
|
|
||||
|
template <typename PatternChar, typename SubjectChar> |
||||
|
void StringSearch<PatternChar, SubjectChar>::PopulateBoyerMooreHorspoolTable() { |
||||
|
const size_t pattern_length = pattern_.length(); |
||||
|
|
||||
|
int* bad_char_occurrence = bad_char_table(); |
||||
|
|
||||
|
// Only preprocess at most kBMMaxShift last characters of pattern.
|
||||
|
const size_t 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.
|
||||
|
const size_t 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 (size_t i = 0; i < table_size; i++) { |
||||
|
bad_char_occurrence[i] = start - 1; |
||||
|
} |
||||
|
} |
||||
|
for (size_t i = start; i < pattern_length - 1; i++) { |
||||
|
PatternChar c = pattern_[i]; |
||||
|
int bucket = (sizeof(PatternChar) == 1) ? c : c % AlphabetSize(); |
||||
|
bad_char_occurrence[bucket] = i; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
//---------------------------------------------------------------------
|
||||
|
// Linear string search with bailout to BMH.
|
||||
|
//---------------------------------------------------------------------
|
||||
|
|
||||
|
// Simple linear search for short patterns, which bails out if the string
|
||||
|
// isn't found very early in the subject. Upgrades to BoyerMooreHorspool.
|
||||
|
template <typename PatternChar, typename SubjectChar> |
||||
|
size_t StringSearch<PatternChar, SubjectChar>::InitialSearch( |
||||
|
StringSearch<PatternChar, SubjectChar>* search, |
||||
|
Vector<const SubjectChar> subject, |
||||
|
size_t index) { |
||||
|
Vector<const PatternChar> pattern = search->pattern_; |
||||
|
const size_t 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.
|
||||
|
int64_t 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.
|
||||
|
for (size_t i = index, n = subject.length() - pattern_length; i <= n; i++) { |
||||
|
badness++; |
||||
|
if (badness <= 0) { |
||||
|
i = FindFirstCharacter(pattern, subject, i); |
||||
|
if (i == subject.length()) |
||||
|
return subject.length(); |
||||
|
ASSERT_LE(i, n); |
||||
|
size_t 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 subject.length(); |
||||
|
} |
||||
|
|
||||
|
// 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.
|
||||
|
template <typename SubjectChar, typename PatternChar> |
||||
|
size_t SearchString(Vector<const SubjectChar> subject, |
||||
|
Vector<const PatternChar> pattern, |
||||
|
size_t start_index) { |
||||
|
StringSearch<PatternChar, SubjectChar> search(pattern); |
||||
|
return search.Search(subject, start_index); |
||||
|
} |
||||
|
} |
||||
|
} // namespace node::stringsearch
|
||||
|
|
||||
|
namespace node { |
||||
|
using node::stringsearch::Vector; |
||||
|
|
||||
|
template <typename SubjectChar, typename PatternChar> |
||||
|
size_t SearchString(const SubjectChar* haystack, |
||||
|
size_t haystack_length, |
||||
|
const PatternChar* needle, |
||||
|
size_t needle_length, |
||||
|
size_t start_index) { |
||||
|
return node::stringsearch::SearchString( |
||||
|
Vector<const SubjectChar>(haystack, haystack_length), |
||||
|
Vector<const PatternChar>(needle, needle_length), |
||||
|
start_index); |
||||
|
} |
||||
|
} // namespace node
|
||||
|
|
||||
|
#endif // SRC_STRING_SEARCH_H_
|
||||
Loading…
Reference in new issue