src/commons/strings.h

// TODO: move whatever you can to C99 Commons

#ifndef COMMONS_STRINGS_H
#define COMMONS_STRINGS_H

#include <strings.h>

#include <commons/check.h>

namespace commons
{

  using namespace std;

  inline const char *
  strchrrep(const char *p, char c, int n)
  {
    for (int i = 0; i < n; i++) {
      p = strchr(p, c);
      check(p);
      p++;
    }
    return p;
  }

  inline char *
  strchrrep(char *p, char c, int n)
  {
    return const_cast<char *>(strchrrep(const_cast<const char *>(p), c, n));
  }

  struct eqstr
  {
    bool operator()(const char* s1, const char* s2) const
    {
      return strcmp(s1, s2) == 0;
    }
  };

  inline char *
  unsafe_strstr(char *p, const char *, const char *lim)
  {
    if (lim == 0) {
      while (true) {
        for (; !(*p == '\0' && *(p+1) == '\0'); p++) {}
        return p;
      }
    } else {
      check(p < lim);
      while (true) {
        for (; !(*p == '\0' && *(p+1) == '\0') && p < lim; p++) {}
        if (p == lim) return NULL;
        return p;
      }
    }
  }

  inline const char*
  unsafe_strstr(const char *p, const char *q, const char *lim)
  {
    return unsafe_strstr(const_cast<char*>(p), q, lim);
  }

  inline char
  scan(const void* buf, size_t len)
  {
    char sum = 0;
    const char* start = reinterpret_cast<const char*>(buf);
    for (const char* p = start; p < start + len; p++) {
      sum = static_cast<char>(sum | *p);
    }
    return sum;
  }

  inline char
  scan_big_step(const void* buf, size_t len)
  {
    const size_t sz = 1024;
    char tmp[sz];
    const char* p = reinterpret_cast<const char*>(buf);
    const char* end = p + len;
    for (; p + sz < end; p += 1024) {
      memcpy(tmp, p, sz);
    }
    memcpy(tmp, p, end - p);
    return sz == 0 ? 0 : tmp[0];
  }

//  /**
//   * Find an int in the buffer. Return pointer to the first occurrence on
//   * success, NULL on failure.
//   */
//  inline const void*
//  findint(const void* buf, size_t len, int x)
//  {
//    const void* pend = (buf + len);
//    // Word-align the start and end pointers.
//    const int* end = (const int*) round_up(p, sizeof(int));
//    const int* start = (const int*) round_down(buf, sizeof(int));
//    for (const int* p = buf; p < end; ++p) {
//      if (*p == x) return p;
//    }
//    return NULL;
//  }

}

#endif

---