//

// Copyright (C) 2001 and onwards Google, Inc.

//

#include "gutil/strings/memutil.h"

#include <stdlib.h> // for malloc, NULL

#include "gutil/strings/ascii_ctype.h" // for ascii_tolower

int memcasecmp(const char* s1, const char* s2, size_t len) {

    const unsigned char* us1 = reinterpret_cast<const unsigned char*>(s1);

    const unsigned char* us2 = reinterpret_cast<const unsigned char*>(s2);

    for (int i = 0; i < len; i++) {

        const int diff = static_cast<int>(static_cast<unsigned char>(ascii_tolower(us1[i]))) -

                         static_cast<int>(static_cast<unsigned char>(ascii_tolower(us2[i])));

        if (diff != 0) return diff;

    }

    return 0;

}

char* memdup(const char* s, size_t slen) {

    void* copy;

    if ((copy = malloc(slen)) == nullptr) return nullptr;

    memcpy(copy, s, slen);

    return reinterpret_cast<char*>(copy);

}

char* memrchr(const char* s, int c, size_t slen) {

    for (const char* e = s + slen - 1; e >= s; e--) {

        if (*e == c) return const_cast<char*>(e);

    }

    return nullptr;

}

size_t memspn(const char* s, size_t slen, const char* accept) {

    const char *p = s, *spanp;

    char c, sc;

cont:

    c = *p++;

    if (slen-- == 0) return p - 1 - s;

    for (spanp = accept; (sc = *spanp++) != '\0';)

        if (sc == c) goto cont;

    return p - 1 - s;

}

size_t memcspn(const char* s, size_t slen, const char* reject) {

    const char *p = s, *spanp;

    char c, sc;

    while (slen-- != 0) {

        c = *p++;

        for (spanp = reject; (sc = *spanp++) != '\0';)

            if (sc == c) return p - 1 - s;

    }

    return p - s;

}

char* mempbrk(const char* s, size_t slen, const char* accept) {

    const char* scanp;

    int sc;

    for (; slen; ++s, --slen) {

        for (scanp = accept; (sc = *scanp++) != '\0';)

            if (sc == *s) return const_cast<char*>(s);

    }

    return nullptr;

}

template <bool case_sensitive>

const char* int_memmatch(const char* phaystack, size_t haylen, const char* pneedle, size_t neelen) {

    if (0 == neelen) {

        return phaystack; // even if haylen is 0

    }

    const unsigned char* haystack = (const unsigned char*)phaystack;

    const unsigned char* hayend = (const unsigned char*)phaystack + haylen;

    const unsigned char* needlestart = (const unsigned char*)pneedle;

    const unsigned char* needle = (const unsigned char*)pneedle;

    const unsigned char* needleend = (const unsigned char*)pneedle + neelen;

    for (; haystack < hayend; ++haystack) {

        unsigned char hay =

                case_sensitive ? *haystack : static_cast<unsigned char>(ascii_tolower(*haystack));

        unsigned char nee =

                case_sensitive ? *needle : static_cast<unsigned char>(ascii_tolower(*needle));

        if (hay == nee) {

            if (++needle == needleend) {

                return (const char*)(haystack + 1 - neelen);

            }

        } else if (needle != needlestart) {

            // must back up haystack in case a prefix matched (find "aab" in "aaab")

            haystack -= needle - needlestart; // for loop will advance one more

            needle = needlestart;

        }

    }

    return nullptr;

}

Unexecuted instantiation: _Z12int_memmatchILb1EEPKcS1_mS1_m

Unexecuted instantiation: _Z12int_memmatchILb0EEPKcS1_mS1_m

// explicit template instantiations

template const char* int_memmatch<true>(const char* phaystack, size_t haylen, const char* pneedle,

                                        size_t neelen);

template const char* int_memmatch<false>(const char* phaystack, size_t haylen, const char* pneedle,

                                         size_t neelen);

// This is significantly faster for case-sensitive matches with very

// few possible matches.  See unit test for benchmarks.

const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle, size_t neelen) {

    if (0 == neelen) {

        return phaystack; // even if haylen is 0

    }

    if (haylen < neelen) return nullptr;

    const char* match;

    const char* hayend = phaystack + haylen - neelen + 1;

    // A C-style cast is used here to work around the fact that memchr returns a

    // void* on Posix-compliant systems and const void* on Windows.

    while ((match = (const char*)(memchr(phaystack, pneedle[0], hayend - phaystack)))) {

        if (memcmp(match, pneedle, neelen) == 0)

            return match;

        else

            phaystack = match + 1;

    }

    return nullptr;

}