| // |
| // 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; |
| } |
| |
| // 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; |
| } |