re2 1.19.2 → 1.20.0

package/vendor/re2/stringpiece.h

@@ -1,213 +0,0 @@
-// Copyright 2001-2010 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_STRINGPIECE_H_
-#define RE2_STRINGPIECE_H_
-
-// A string-like object that points to a sized piece of memory.
-//
-// Functions or methods may use const StringPiece& parameters to accept either
-// a "const char*" or a "string" value that will be implicitly converted to
-// a StringPiece.  The implicit conversion means that it is often appropriate
-// to include this .h file in other files rather than forward-declaring
-// StringPiece as would be appropriate for most other Google classes.
-//
-// Systematic usage of StringPiece is encouraged as it will reduce unnecessary
-// conversions from "const char*" to "string" and back again.
-//
-//
-// Arghh!  I wish C++ literals were "string".
-
-#include <stddef.h>
-#include <string.h>
-#include <algorithm>
-#include <iosfwd>
-#include <iterator>
-#include <string>
-#ifdef __cpp_lib_string_view
-#include <string_view>
-#endif
-
-namespace re2 {
-
-class StringPiece {
- public:
-  typedef std::char_traits<char> traits_type;
-  typedef char value_type;
-  typedef char* pointer;
-  typedef const char* const_pointer;
-  typedef char& reference;
-  typedef const char& const_reference;
-  typedef const char* const_iterator;
-  typedef const_iterator iterator;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-  typedef const_reverse_iterator reverse_iterator;
-  typedef size_t size_type;
-  typedef ptrdiff_t difference_type;
-  static const size_type npos = static_cast<size_type>(-1);
-
-  // We provide non-explicit singleton constructors so users can pass
-  // in a "const char*" or a "string" wherever a "StringPiece" is
-  // expected.
-  StringPiece()
-      : data_(NULL), size_(0) {}
-#ifdef __cpp_lib_string_view
-  StringPiece(const std::string_view& str)
-      : data_(str.data()), size_(str.size()) {}
-#endif
-  StringPiece(const std::string& str)
-      : data_(str.data()), size_(str.size()) {}
-  StringPiece(const char* str)
-      : data_(str), size_(str == NULL ? 0 : strlen(str)) {}
-  StringPiece(const char* str, size_type len)
-      : data_(str), size_(len) {}
-
-  const_iterator begin() const { return data_; }
-  const_iterator end() const { return data_ + size_; }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(data_ + size_);
-  }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(data_);
-  }
-
-  size_type size() const { return size_; }
-  size_type length() const { return size_; }
-  bool empty() const { return size_ == 0; }
-
-  const_reference operator[](size_type i) const { return data_[i]; }
-  const_pointer data() const { return data_; }
-
-  void remove_prefix(size_type n) {
-    data_ += n;
-    size_ -= n;
-  }
-
-  void remove_suffix(size_type n) {
-    size_ -= n;
-  }
-
-  void set(const char* str) {
-    data_ = str;
-    size_ = str == NULL ? 0 : strlen(str);
-  }
-
-  void set(const char* str, size_type len) {
-    data_ = str;
-    size_ = len;
-  }
-
-#ifdef __cpp_lib_string_view
-  // Converts to `std::basic_string_view`.
-  operator std::basic_string_view<char, traits_type>() const {
-    if (!data_) return {};
-    return std::basic_string_view<char, traits_type>(data_, size_);
-  }
-#endif
-
-  // Converts to `std::basic_string`.
-  template <typename A>
-  explicit operator std::basic_string<char, traits_type, A>() const {
-    if (!data_) return {};
-    return std::basic_string<char, traits_type, A>(data_, size_);
-  }
-
-  std::string as_string() const {
-    return std::string(data_, size_);
-  }
-
-  // We also define ToString() here, since many other string-like
-  // interfaces name the routine that converts to a C++ string
-  // "ToString", and it's confusing to have the method that does that
-  // for a StringPiece be called "as_string()".  We also leave the
-  // "as_string()" method defined here for existing code.
-  std::string ToString() const {
-    return std::string(data_, size_);
-  }
-
-  void CopyToString(std::string* target) const {
-    target->assign(data_, size_);
-  }
-
-  void AppendToString(std::string* target) const {
-    target->append(data_, size_);
-  }
-
-  size_type copy(char* buf, size_type n, size_type pos = 0) const;
-  StringPiece substr(size_type pos = 0, size_type n = npos) const;
-
-  int compare(const StringPiece& x) const {
-    size_type min_size = std::min(size(), x.size());
-    if (min_size > 0) {
-      int r = memcmp(data(), x.data(), min_size);
-      if (r < 0) return -1;
-      if (r > 0) return 1;
-    }
-    if (size() < x.size()) return -1;
-    if (size() > x.size()) return 1;
-    return 0;
-  }
-
-  // Does "this" start with "x"?
-  bool starts_with(const StringPiece& x) const {
-    return x.empty() ||
-           (size() >= x.size() && memcmp(data(), x.data(), x.size()) == 0);
-  }
-
-  // Does "this" end with "x"?
-  bool ends_with(const StringPiece& x) const {
-    return x.empty() ||
-           (size() >= x.size() &&
-            memcmp(data() + (size() - x.size()), x.data(), x.size()) == 0);
-  }
-
-  bool contains(const StringPiece& s) const {
-    return find(s) != npos;
-  }
-
-  size_type find(const StringPiece& s, size_type pos = 0) const;
-  size_type find(char c, size_type pos = 0) const;
-  size_type rfind(const StringPiece& s, size_type pos = npos) const;
-  size_type rfind(char c, size_type pos = npos) const;
-
- private:
-  const_pointer data_;
-  size_type size_;
-};
-
-inline bool operator==(const StringPiece& x, const StringPiece& y) {
-  StringPiece::size_type len = x.size();
-  if (len != y.size()) return false;
-  return x.data() == y.data() || len == 0 ||
-         memcmp(x.data(), y.data(), len) == 0;
-}
-
-inline bool operator!=(const StringPiece& x, const StringPiece& y) {
-  return !(x == y);
-}
-
-inline bool operator<(const StringPiece& x, const StringPiece& y) {
-  StringPiece::size_type min_size = std::min(x.size(), y.size());
-  int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
-  return (r < 0) || (r == 0 && x.size() < y.size());
-}
-
-inline bool operator>(const StringPiece& x, const StringPiece& y) {
-  return y < x;
-}
-
-inline bool operator<=(const StringPiece& x, const StringPiece& y) {
-  return !(x > y);
-}
-
-inline bool operator>=(const StringPiece& x, const StringPiece& y) {
-  return !(x < y);
-}
-
-// Allow StringPiece to be logged.
-std::ostream& operator<<(std::ostream& o, const StringPiece& p);
-
-}  // namespace re2
-
-#endif  // RE2_STRINGPIECE_H_

package/vendor/util/benchmark.cc

@@ -1,131 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <algorithm>
-#include <chrono>
-
-#include "util/benchmark.h"
-#include "util/flags.h"
-#include "re2/re2.h"
-
-#ifdef _WIN32
-#define snprintf _snprintf
-#endif
-
-using ::testing::Benchmark;
-
-static Benchmark* benchmarks[10000];
-static int nbenchmarks;
-
-void Benchmark::Register() {
-  lo_ = std::max(1, lo_);
-  hi_ = std::max(lo_, hi_);
-  benchmarks[nbenchmarks++] = this;
-}
-
-static int64_t nsec() {
-  return std::chrono::duration_cast<std::chrono::nanoseconds>(
-             std::chrono::steady_clock::now().time_since_epoch())
-      .count();
-}
-
-static int64_t t0;
-static int64_t ns;
-static int64_t bytes;
-static int64_t items;
-
-void StartBenchmarkTiming() {
-  if (t0 == 0) {
-    t0 = nsec();
-  }
-}
-
-void StopBenchmarkTiming() {
-  if (t0 != 0) {
-    ns += nsec() - t0;
-    t0 = 0;
-  }
-}
-
-void SetBenchmarkBytesProcessed(int64_t b) { bytes = b; }
-
-void SetBenchmarkItemsProcessed(int64_t i) { items = i; }
-
-static void RunFunc(Benchmark* b, int iters, int arg) {
-  t0 = nsec();
-  ns = 0;
-  bytes = 0;
-  items = 0;
-  b->func()(iters, arg);
-  StopBenchmarkTiming();
-}
-
-static int round(int n) {
-  int base = 1;
-  while (base * 10 < n) base *= 10;
-  if (n < 2 * base) return 2 * base;
-  if (n < 5 * base) return 5 * base;
-  return 10 * base;
-}
-
-static void RunBench(Benchmark* b, int arg) {
-  int iters, last;
-
-  // Run once just in case it's expensive.
-  iters = 1;
-  RunFunc(b, iters, arg);
-  while (ns < (int)1e9 && iters < (int)1e9) {
-    last = iters;
-    if (ns / iters == 0) {
-      iters = (int)1e9;
-    } else {
-      iters = (int)1e9 / static_cast<int>(ns / iters);
-    }
-    iters = std::max(last + 1, std::min(iters + iters / 2, 100 * last));
-    iters = round(iters);
-    RunFunc(b, iters, arg);
-  }
-
-  char mb[100];
-  char suf[100];
-  mb[0] = '\0';
-  suf[0] = '\0';
-  if (ns > 0 && bytes > 0)
-    snprintf(mb, sizeof mb, "\t%7.2f MB/s",
-             ((double)bytes / 1e6) / ((double)ns / 1e9));
-  if (b->has_arg()) {
-    if (arg >= (1 << 20)) {
-      snprintf(suf, sizeof suf, "/%dM", arg / (1 << 20));
-    } else if (arg >= (1 << 10)) {
-      snprintf(suf, sizeof suf, "/%dK", arg / (1 << 10));
-    } else {
-      snprintf(suf, sizeof suf, "/%d", arg);
-    }
-  }
-  printf("%s%s\t%8d\t%10lld ns/op%s\n", b->name(), suf, iters,
-         (long long)ns / iters, mb);
-  fflush(stdout);
-}
-
-static bool WantBench(const char* name, int argc, const char** argv) {
-  if (argc == 1) return true;
-  for (int i = 1; i < argc; i++) {
-    if (RE2::PartialMatch(name, argv[i]))
-      return true;
-  }
-  return false;
-}
-
-int main(int argc, const char** argv) {
-  for (int i = 0; i < nbenchmarks; i++) {
-    Benchmark* b = benchmarks[i];
-    if (!WantBench(b->name(), argc, argv))
-      continue;
-    for (int arg = b->lo(); arg <= b->hi(); arg <<= 1)
-      RunBench(b, arg);
-  }
-}

package/vendor/util/benchmark.h

@@ -1,156 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_BENCHMARK_H_
-#define UTIL_BENCHMARK_H_
-
-#include <stdint.h>
-#include <functional>
-
-#include "util/logging.h"
-#include "util/util.h"
-
-// Globals for the old benchmark API.
-void StartBenchmarkTiming();
-void StopBenchmarkTiming();
-void SetBenchmarkBytesProcessed(int64_t b);
-void SetBenchmarkItemsProcessed(int64_t i);
-
-namespace benchmark {
-
-// The new benchmark API implemented as a layer over the old benchmark API.
-// (Please refer to https://github.com/google/benchmark for documentation.)
-class State {
- private:
-  class Iterator {
-   public:
-    // Benchmark code looks like this:
-    //
-    //   for (auto _ : state) {
-    //     // ...
-    //   }
-    //
-    // We try to avoid compiler warnings about such variables being unused.
-    struct ATTRIBUTE_UNUSED Value {};
-
-    explicit Iterator(int64_t iters) : iters_(iters) {}
-
-    bool operator!=(const Iterator& that) const {
-      if (iters_ != that.iters_) {
-        return true;
-      } else {
-        // We are about to stop the loop, so stop timing.
-        StopBenchmarkTiming();
-        return false;
-      }
-    }
-
-    Value operator*() const {
-      return Value();
-    }
-
-    Iterator& operator++() {
-      --iters_;
-      return *this;
-    }
-
-   private:
-    int64_t iters_;
-  };
-
- public:
-  explicit State(int64_t iters)
-      : iters_(iters), arg_(0), has_arg_(false) {}
-
-  State(int64_t iters, int64_t arg)
-      : iters_(iters), arg_(arg), has_arg_(true) {}
-
-  Iterator begin() {
-    // We are about to start the loop, so start timing.
-    StartBenchmarkTiming();
-    return Iterator(iters_);
-  }
-
-  Iterator end() {
-    return Iterator(0);
-  }
-
-  void SetBytesProcessed(int64_t b) { SetBenchmarkBytesProcessed(b); }
-  void SetItemsProcessed(int64_t i) { SetBenchmarkItemsProcessed(i); }
-  int64_t iterations() const { return iters_; }
-  // Pretend to support multiple arguments.
-  int64_t range(int pos) const { CHECK(has_arg_); return arg_; }
-
- private:
-  int64_t iters_;
-  int64_t arg_;
-  bool has_arg_;
-
-  State(const State&) = delete;
-  State& operator=(const State&) = delete;
-};
-
-}  // namespace benchmark
-
-namespace testing {
-
-class Benchmark {
- public:
-  Benchmark(const char* name, void (*func)(benchmark::State&))
-      : name_(name),
-        func_([func](int iters, int arg) {
-          benchmark::State state(iters);
-          func(state);
-        }),
-        lo_(0),
-        hi_(0),
-        has_arg_(false) {
-    Register();
-  }
-
-  Benchmark(const char* name, void (*func)(benchmark::State&), int lo, int hi)
-      : name_(name),
-        func_([func](int iters, int arg) {
-          benchmark::State state(iters, arg);
-          func(state);
-        }),
-        lo_(lo),
-        hi_(hi),
-        has_arg_(true) {
-    Register();
-  }
-
-  // Pretend to support multiple threads.
-  Benchmark* ThreadRange(int lo, int hi) { return this; }
-
-  const char* name() const { return name_; }
-  const std::function<void(int, int)>& func() const { return func_; }
-  int lo() const { return lo_; }
-  int hi() const { return hi_; }
-  bool has_arg() const { return has_arg_; }
-
- private:
-  void Register();
-
-  const char* name_;
-  std::function<void(int, int)> func_;
-  int lo_;
-  int hi_;
-  bool has_arg_;
-
-  Benchmark(const Benchmark&) = delete;
-  Benchmark& operator=(const Benchmark&) = delete;
-};
-
-}  // namespace testing
-
-#define BENCHMARK(f)                     \
-  ::testing::Benchmark* _benchmark_##f = \
-      (new ::testing::Benchmark(#f, f))
-
-#define BENCHMARK_RANGE(f, lo, hi)       \
-  ::testing::Benchmark* _benchmark_##f = \
-      (new ::testing::Benchmark(#f, f, lo, hi))
-
-#endif  // UTIL_BENCHMARK_H_

package/vendor/util/flags.h

@@ -1,26 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_FLAGS_H_
-#define UTIL_FLAGS_H_
-
-// Simplified version of Google's command line flags.
-// Does not support parsing the command line.
-// If you want to do that, see
-// https://gflags.github.io/gflags/
-
-#define DEFINE_FLAG(type, name, deflt, desc) \
-	namespace re2 { type FLAGS_##name = deflt; }
-
-#define DECLARE_FLAG(type, name) \
-	namespace re2 { extern type FLAGS_##name; }
-
-namespace re2 {
-template <typename T>
-T GetFlag(const T& flag) {
-  return flag;
-}
-}  // namespace re2
-
-#endif  // UTIL_FLAGS_H_

package/vendor/util/mix.h

@@ -1,41 +0,0 @@
-// Copyright 2016 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_MIX_H_
-#define UTIL_MIX_H_
-
-#include <stddef.h>
-#include <limits>
-
-namespace re2 {
-
-// Silence "truncation of constant value" warning for kMul in 32-bit mode.
-// Since this is a header file, push and then pop to limit the scope.
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4309)
-#endif
-
-class HashMix {
- public:
-  HashMix() : hash_(1) {}
-  explicit HashMix(size_t val) : hash_(val + 83) {}
-  void Mix(size_t val) {
-    static const size_t kMul = static_cast<size_t>(0xdc3eb94af8ab4c93ULL);
-    hash_ *= kMul;
-    hash_ = ((hash_ << 19) |
-             (hash_ >> (std::numeric_limits<size_t>::digits - 19))) + val;
-  }
-  size_t get() const { return hash_; }
- private:
-  size_t hash_;
-};
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-}  // namespace re2
-
-#endif  // UTIL_MIX_H_