#ifndef NBYTES_H

#define NBYTES_H

#include <algorithm>

#include <cmath>

#include <cstddef>

#include <cstdint>

#include <cstring>

#include <string>

namespace nbytes {

#if NBYTES_DEVELOPMENT_CHECKS

#define NBYTES_STR(x) #x

#define NBYTES_REQUIRE(EXPR) \

{ \

if (!(EXPR) { abort(); }) }

#define NBYTES_FAIL(MESSAGE) \

do { \

std::cerr << "FAIL: " << (MESSAGE) << std::endl; \

abort(); \

} while (0);

#define NBYTES_ASSERT_EQUAL(LHS, RHS, MESSAGE) \

do { \

if (LHS != RHS) { \

std::cerr << "Mismatch: '" << LHS << "' - '" << RHS << "'" << std::endl; \

NBYTES_FAIL(MESSAGE); \

} \

} while (0);

#define NBYTES_ASSERT_TRUE(COND) \

do { \

if (!(COND)) { \

std::cerr << "Assert at line " << __LINE__ << " of file " << __FILE__ \

<< std::endl; \

NBYTES_FAIL(NBYTES_STR(COND)); \

} \

} while (0);

#else

#define NBYTES_FAIL(MESSAGE)

#define NBYTES_ASSERT_EQUAL(LHS, RHS, MESSAGE)

#define NBYTES_ASSERT_TRUE(COND)

#endif

[[noreturn]] inline void unreachable() {

}

template <typename T>

constexpr T RoundUp(T a, T b) {

return a % b != 0 ? a + b - (a % b) : a;

}

template <typename T, typename U>

constexpr T *AlignUp(T *ptr, U alignment) {

return reinterpret_cast<T *>(

RoundUp(reinterpret_cast<uintptr_t>(ptr), alignment));

}

template <typename T, typename U>

inline T AlignDown(T value, U alignment) {

return reinterpret_cast<T>(

(reinterpret_cast<uintptr_t>(value) & ~(alignment - 1)));

}

template <typename T>

inline T MultiplyWithOverflowCheck(T a, T b) {

}

void ForceAsciiSlow(const char *src, char *dst, size_t len);

void ForceAscii(const char *src, char *dst, size_t len);

bool SwapBytes16(char *data, size_t nbytes);

bool SwapBytes32(char *data, size_t nbytes);

bool SwapBytes64(char *data, size_t nbytes);

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable : 4003)

#endif

extern const int8_t unbase64_table[256];

template <typename TypeName>

bool Base64DecodeGroupSlow(char *const dst, const size_t dstlen,

} \

expr; \

if (*i >= srclen) return false; \

if (*k >= dstlen) return false; \

hi = lo;

V(/* Nothing. */);

V(dst[(*k)++] = ((hi & 0x3F) << 2) | ((lo & 0x30) >> 4));

V(dst[(*k)++] = ((hi & 0x0F) << 4) | ((lo & 0x3C) >> 2));

V(dst[(*k)++] = ((hi & 0x03) << 6) | ((lo & 0x3F) >> 0));

#undef V

return true; // Continue decoding.

}

enum class Base64Mode { NORMAL, URL };

inline constexpr size_t Base64EncodedSize(

}

inline constexpr size_t Base64DecodedSizeFast(size_t size) {

// 1-byte input cannot be decoded

return size > 1 ? (size / 4) * 3 + (size % 4 + 1) / 2 : 0;

}

inline uint32_t ReadUint32BE(const unsigned char *p) {

}

template <typename TypeName>

size_t Base64DecodedSize(const TypeName *src, size_t size) {

}

template <typename TypeName>

size_t Base64DecodeFast(char *const dst, const size_t dstlen,

}

template <typename TypeName>

size_t Base64Decode(char *const dst, const size_t dstlen,

}

#ifdef _MSC_VER

#pragma warning(pop)

#endif

extern const int8_t unhex_table[256];

template <typename TypeName>

static size_t HexDecode(char *buf, size_t len, const TypeName *src,

}

size_t HexEncode(const char *src, size_t slen, char *dst, size_t dlen);

std::string HexEncode(const char *src, size_t slen);

namespace stringsearch {

template <typename T>

class Vector {

};

class StringSearchBase {

};

template <typename Char>

class StringSearch : private StringSearchBase {

};

inline uint8_t GetHighestValueByte(uint16_t character) {

return std::max(static_cast<uint8_t>(character & 0xFF),

static_cast<uint8_t>(character >> 8));

}

inline uint8_t GetHighestValueByte(uint8_t character) { return character; }

inline const void *MemrchrFill(const void *haystack, uint8_t needle,

size_t haystack_len) {

#ifdef _GNU_SOURCE

return memrchr(haystack, needle, haystack_len);

#else

const uint8_t *haystack8 = static_cast<const uint8_t *>(haystack);

for (size_t i = haystack_len - 1; i != static_cast<size_t>(-1); i--) {

if (haystack8[i] == needle) {

return haystack8 + i;

}

}

return nullptr;

#endif

}

template <typename Char>

inline size_t FindFirstCharacter(Vector<const Char> pattern,

}

template <>

inline size_t FindFirstCharacter(Vector<const uint8_t> pattern,

}

template <typename Char>

size_t StringSearch<Char>::SingleCharSearch(Vector subject, size_t index) {

NBYTES_ASSERT_TRUE(1 == pattern_.length());

return FindFirstCharacter(pattern_, subject, index);

}

template <typename Char>

size_t StringSearch<Char>::LinearSearch(Vector subject, size_t index) {

NBYTES_ASSERT_TRUE(pattern_.length() > 1);

const size_t n = subject.length() - pattern_.length();

for (size_t i = index; i <= n; i++) {

i = FindFirstCharacter(pattern_, subject, i);

if (i == subject.length()) return subject.length();

NBYTES_ASSERT_TRUE(i <= n);

bool matches = true;

for (size_t j = 1; j < pattern_.length(); j++) {

if (pattern_[j] != subject[i + j]) {

matches = false;

break;

}

}

if (matches) {

return i;

}

}

return subject.length();

}

template <typename Char>

size_t StringSearch<Char>::BoyerMooreSearch(Vector subject,

size_t start_index) {

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 = start_;

int *bad_char_occurrence = bad_char_shift_table_;

int *good_suffix_shift = good_suffix_shift_table_ - start_;

Char 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_occurrence, c);

index += shift;

if (index > subject_length - pattern_length) {

return subject.length();

}

}

while (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_occurrence, last_char);

} else {

int gs_shift = good_suffix_shift[j + 1];

int bc_occ = CharOccurrence(bad_char_occurrence, c);

int shift = j - bc_occ;

if (gs_shift > shift) {

shift = gs_shift;

}

index += shift;

}

}

return subject.length();

}

template <typename Char>

void StringSearch<Char>::PopulateBoyerMooreTable() {

const size_t pattern_length = pattern_.length();

// 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_ - start_;

int *suffix_table = suffix_table_ - start_;

// 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.

Char last_char = pattern_[pattern_length - 1];

size_t suffix = pattern_length + 1;

{

size_t i = pattern_length;

while (i > start) {

Char 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];

}

}

}

}

template <typename Char>

size_t StringSearch<Char>::BoyerMooreHorspoolSearch(Vector subject,

size_t start_index) {

const size_t subject_length = subject.length();

const size_t pattern_length = pattern_.length();

int *char_occurrences = bad_char_shift_table_;

int64_t badness = -static_cast<int64_t>(pattern_length);

// How bad we are doing without a good-suffix table.

Char last_char = pattern_[pattern_length - 1];

int last_char_shift =

pattern_length - 1 - CharOccurrence(char_occurrences, 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 (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) {

PopulateBoyerMooreTable();

strategy_ = SearchStrategy::kBoyerMoore;

return BoyerMooreSearch(subject, index);

}

}

return subject.length();

}

template <typename Char>

void StringSearch<Char>::PopulateBoyerMooreHorspoolTable() {

const size_t pattern_length = pattern_.length();

int *bad_char_occurrence = bad_char_shift_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++) {

Char c = pattern_[i];

int bucket = (sizeof(Char) == 1) ? c : c % AlphabetSize();

bad_char_occurrence[bucket] = i;

}

}

template <typename Char>

size_t StringSearch<Char>::InitialSearch(Vector subject, size_t index) {

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();

NBYTES_ASSERT_TRUE(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 {

PopulateBoyerMooreHorspoolTable();

strategy_ = SearchStrategy::kBoyerMooreHorspool;

return BoyerMooreHorspoolSearch(subject, i);

}

}

return subject.length();

}

template <typename Char>

size_t SearchString(Vector<const Char> subject, Vector<const Char> pattern,

}

} // namespace stringsearch

template <typename Char>

size_t SearchString(const Char *haystack, size_t haystack_length,

}

template <size_t N>

size_t SearchString(const char *haystack, size_t haystack_length,

}

#define NBYTES_VERSION "0.1.1"

enum {

NBYTES_VERSION_MAJOR = 0,

NBYTES_VERSION_MINOR = 1,

NBYTES_VERSION_REVISION = 1,

};

} // namespace nbytes

#endif // NBYTES_H