be/src/gutil/strings/memutil.h

//
// Copyright (C) 2001 and onwards Google, Inc.
//
// (Please see comments in strutil.h near the include of <asm/string.h>
//  if you feel compelled to try to provide more efficient implementations
//  of these routines.)
//
// These routines provide mem versions of standard C string routines,
// such a strpbrk.  They function exactly the same as the str version,
// so if you wonder what they are, replace the word "mem" by
// "str" and check out the man page.  I could return void*, as the
// strutil.h mem*() routines tend to do, but I return char* instead
// since this is by far the most common way these functions are called.
//
// The difference between the mem and str versions is the mem version
// takes a pointer and a length, rather than a NULL-terminated string.
// The memcase* routines defined here assume the locale is "C"
// (they use ascii_tolower instead of tolower).
//
// These routines are based on the BSD library.
//
// Here's a list of routines from string.h, and their mem analogues.
// Functions in lowercase are defined in string.h; those in UPPERCASE
// are defined here:
//
// strlen                  --
// strcat strncat          MEMCAT
// strcpy strncpy          memcpy
// --                      memccpy   (very cool function, btw)
// --                      memmove
// --                      memset
// strcmp strncmp          memcmp
// strcasecmp strncasecmp  MEMCASECMP
// strchr                  memchr
// strcoll                 --
// strxfrm                 --
// strdup strndup          MEMDUP
// strrchr                 MEMRCHR
// strspn                  MEMSPN
// strcspn                 MEMCSPN
// strpbrk                 MEMPBRK
// strstr                  MEMSTR MEMMEM
// (g)strcasestr           MEMCASESTR MEMCASEMEM
// strtok                  --
// strprefix               MEMPREFIX      (strprefix is from strutil.h)
// strcaseprefix           MEMCASEPREFIX  (strcaseprefix is from strutil.h)
// strsuffix               MEMSUFFIX      (strsuffix is from strutil.h)
// strcasesuffix           MEMCASESUFFIX  (strcasesuffix is from strutil.h)
// --                      MEMIS
// --                      MEMCASEIS
// strcount                MEMCOUNT       (strcount is from strutil.h)

#pragma once

#include <stddef.h>
#include <string.h> // to get the POSIX mem*() routines

inline char* memcat(char* dest, size_t destlen, const char* src, size_t srclen) {
    return reinterpret_cast<char*>(memcpy(dest + destlen, src, srclen));
}

int memcasecmp(const char* s1, const char* s2, size_t len);
char* memdup(const char* s, size_t slen);
char* memrchr(const char* s, int c, size_t slen);
size_t memspn(const char* s, size_t slen, const char* accept);
size_t memcspn(const char* s, size_t slen, const char* reject);
char* mempbrk(const char* s, size_t slen, const char* accept);

// This is for internal use only.  Don't call this directly
template <bool case_sensitive>
const char* int_memmatch(const char* phaystack, size_t haylen, const char* pneedle, size_t neelen);

// These are the guys you can call directly
inline const char* memstr(const char* phaystack, size_t haylen, const char* pneedle) {
    return int_memmatch<true>(phaystack, haylen, pneedle, strlen(pneedle));
}

inline const char* memcasestr(const char* phaystack, size_t haylen, const char* pneedle) {
    return int_memmatch<false>(phaystack, haylen, pneedle, strlen(pneedle));
}

inline const char* memmem(const char* phaystack, size_t haylen, const char* pneedle,
                          size_t needlelen) {
    return int_memmatch<true>(phaystack, haylen, pneedle, needlelen);
}

inline const char* memcasemem(const char* phaystack, size_t haylen, const char* pneedle,
                              size_t needlelen) {
    return int_memmatch<false>(phaystack, haylen, pneedle, needlelen);
}

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

// The ""'s catch people who don't pass in a literal for "str"
#define strliterallen(str) (sizeof("" str "") - 1)

// Must use a string literal for prefix.
#define memprefix(str, len, prefix)                                                        \
    ((((len) >= strliterallen(prefix)) && memcmp(str, prefix, strliterallen(prefix)) == 0) \
             ? str + strliterallen(prefix)                                                 \
             : NULL)

#define memcaseprefix(str, len, prefix)                                                        \
    ((((len) >= strliterallen(prefix)) && memcasecmp(str, prefix, strliterallen(prefix)) == 0) \
             ? str + strliterallen(prefix)                                                     \
             : NULL)

// Must use a string literal for suffix.
#define memsuffix(str, len, suffix)                                                  \
    ((((len) >= strliterallen(suffix)) &&                                            \
      memcmp(str + (len)-strliterallen(suffix), suffix, strliterallen(suffix)) == 0) \
             ? str + (len)-strliterallen(suffix)                                     \
             : NULL)

#define memcasesuffix(str, len, suffix)                                                  \
    ((((len) >= strliterallen(suffix)) &&                                                \
      memcasecmp(str + (len)-strliterallen(suffix), suffix, strliterallen(suffix)) == 0) \
             ? str + (len)-strliterallen(suffix)                                         \
             : NULL)

#define memis(str, len, literal) \
    ((((len) == strliterallen(literal)) && memcmp(str, literal, strliterallen(literal)) == 0))

#define memcaseis(str, len, literal) \
    ((((len) == strliterallen(literal)) && memcasecmp(str, literal, strliterallen(literal)) == 0))

inline int memcount(const char* buf, size_t len, char c) {
    int num = 0;
    for (int i = 0; i < len; i++) {
        if (buf[i] == c) num++;
    }
    return num;
}