re2 1.10.2 → 1.11.0

package/vendor/re2/testing/regexp_generator.cc

@@ -256,7 +256,7 @@ std::vector<std::string> Explode(const StringPiece& s) {
 std::vector<std::string> Split(const StringPiece& sep, const StringPiece& s) {
   std::vector<std::string> v;
 
-  if (sep.size() == 0)
+  if (sep.empty())
     return Explode(s);
 
   const char *p = s.data();

package/vendor/re2/testing/tester.cc

@@ -18,14 +18,15 @@
 #include "re2/re2.h"
 #include "re2/regexp.h"
 
-DEFINE_bool(dump_prog, false, "dump regexp program");
-DEFINE_bool(log_okay, false, "log successful runs");
-DEFINE_bool(dump_rprog, false, "dump reversed regexp program");
+DEFINE_FLAG(bool, dump_prog, false, "dump regexp program");
+DEFINE_FLAG(bool, log_okay, false, "log successful runs");
+DEFINE_FLAG(bool, dump_rprog, false, "dump reversed regexp program");
 
-DEFINE_int32(max_regexp_failures, 100,
-             "maximum number of regexp test failures (-1 = unlimited)");
+DEFINE_FLAG(int, max_regexp_failures, 100,
+            "maximum number of regexp test failures (-1 = unlimited)");
 
-DEFINE_string(regexp_engines, "", "pattern to select regexp engines to test");
+DEFINE_FLAG(std::string, regexp_engines, "",
+            "pattern to select regexp engines to test");
 
 namespace re2 {
 
@@ -62,11 +63,11 @@ static uint32_t Engines() {
   if (did_parse)
     return cached_engines;
 
-  if (FLAGS_regexp_engines.empty()) {
+  if (GetFlag(FLAGS_regexp_engines).empty()) {
     cached_engines = ~0;
   } else {
     for (Engine i = static_cast<Engine>(0); i < kEngineMax; i++)
-      if (FLAGS_regexp_engines.find(EngineName(i)) != std::string::npos)
+      if (GetFlag(FLAGS_regexp_engines).find(EngineName(i)) != std::string::npos)
         cached_engines |= 1<<i;
   }
 
@@ -102,7 +103,8 @@ static std::string FormatCapture(const StringPiece& text,
   if (s.data() == NULL)
     return "(?,?)";
   return StringPrintf("(%td,%td)",
-                      s.begin() - text.begin(), s.end() - text.begin());
+                      s.begin() - text.begin(),
+                      s.end() - text.begin());
 }
 
 // Returns whether text contains non-ASCII (>= 0x80) bytes.
@@ -198,7 +200,7 @@ TestInstance::TestInstance(const StringPiece& regexp_str, Prog::MatchKind kind,
     error_ = true;
     return;
   }
-  if (FLAGS_dump_prog) {
+  if (GetFlag(FLAGS_dump_prog)) {
     LOG(INFO) << "Prog for "
               << " regexp "
               << CEscape(regexp_str_)
@@ -216,7 +218,7 @@ TestInstance::TestInstance(const StringPiece& regexp_str, Prog::MatchKind kind,
       error_ = true;
       return;
     }
-    if (FLAGS_dump_rprog)
+    if (GetFlag(FLAGS_dump_rprog))
       LOG(INFO) << rprog_->Dump();
   }
 
@@ -528,7 +530,7 @@ bool TestInstance::RunCase(const StringPiece& text, const StringPiece& context,
     Result r;
     RunSearch(i, text, context, anchor, &r);
     if (ResultOkay(r, correct)) {
-      if (FLAGS_log_okay)
+      if (GetFlag(FLAGS_log_okay))
         LogMatch(r.skipped ? "Skipped: " : "Okay: ", i, text, context, anchor);
       continue;
     }
@@ -571,7 +573,10 @@ bool TestInstance::RunCase(const StringPiece& text, const StringPiece& context,
   }
 
   if (!all_okay) {
-    if (FLAGS_max_regexp_failures > 0 && --FLAGS_max_regexp_failures == 0)
+    // This will be initialised once (after flags have been initialised)
+    // and that is desirable because we want to enforce a global limit.
+    static int max_regexp_failures = GetFlag(FLAGS_max_regexp_failures);
+    if (max_regexp_failures > 0 && --max_regexp_failures == 0)
       LOG(QFATAL) << "Too many regexp failures.";
   }
 
@@ -640,7 +645,7 @@ static Prog::Anchor anchors[] = {
 
 bool Tester::TestInput(const StringPiece& text) {
   bool okay = TestInputInContext(text, text);
-  if (text.size() > 0) {
+  if (!text.empty()) {
     StringPiece sp;
     sp = text;
     sp.remove_prefix(1);

package/vendor/re2/walker-inl.h

@@ -150,7 +150,7 @@ template<typename T> void Regexp::Walker<T>::Reset() {
   if (stack_ && stack_->size() > 0) {
     LOG(DFATAL) << "Stack not empty.";
     while (stack_->size() > 0) {
-      delete stack_->top().child_args;
+      delete[] stack_->top().child_args;
       stack_->pop();
     }
   }

package/vendor/util/benchmark.cc

@@ -7,155 +7,125 @@
 #include <stdlib.h>
 #include <algorithm>
 #include <chrono>
-#include <thread>
 
-#include "util/util.h"
-#include "util/flags.h"
 #include "util/benchmark.h"
+#include "util/flags.h"
 #include "re2/re2.h"
 
-DEFINE_string(test_tmpdir, "/var/tmp", "temp directory");
-
 #ifdef _WIN32
 #define snprintf _snprintf
 #endif
 
-using testing::Benchmark;
+using ::testing::Benchmark;
 
 static Benchmark* benchmarks[10000];
 static int nbenchmarks;
 
 void Benchmark::Register() {
-	benchmarks[nbenchmarks] = this;
-	if(lo < 1)
-		lo = 1;
-	if(hi < lo)
-		hi = lo;
-	nbenchmarks++;
+  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();
+  return std::chrono::duration_cast<std::chrono::nanoseconds>(
+             std::chrono::steady_clock::now().time_since_epoch())
+      .count();
 }
 
-static int64_t bytes;
-static int64_t ns;
 static int64_t t0;
+static int64_t ns;
+static int64_t bytes;
 static int64_t items;
 
-void SetBenchmarkBytesProcessed(int64_t x) {
-	bytes = x;
-}
-
-void StopBenchmarkTiming() {
-	if(t0 != 0)
-		ns += nsec() - t0;
-	t0 = 0;
-}
-
 void StartBenchmarkTiming() {
-	if(t0 == 0)
-		t0 = nsec();
+  if (t0 == 0) {
+    t0 = nsec();
+  }
 }
 
-void SetBenchmarkItemsProcessed(int n) {
-	items = n;
+void StopBenchmarkTiming() {
+  if (t0 != 0) {
+    ns += nsec() - t0;
+    t0 = 0;
+  }
 }
 
-void BenchmarkMemoryUsage() {
-	// TODO(rsc): Implement.
-}
+void SetBenchmarkBytesProcessed(int64_t b) { bytes = b; }
 
-int NumCPUs() {
-	return static_cast<int>(std::thread::hardware_concurrency());
-}
+void SetBenchmarkItemsProcessed(int64_t i) { items = i; }
 
-static void runN(Benchmark *b, int n, int siz) {
-	bytes = 0;
-	items = 0;
-	ns = 0;
-	t0 = nsec();
-	if(b->fn)
-		b->fn(n);
-	else if(b->fnr)
-		b->fnr(n, siz);
-	else {
-		fprintf(stderr, "%s: missing function\n", b->name);
-		abort();
-	}
-	if(t0 != 0)
-		ns += nsec() - t0;
+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;
+  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;
 }
 
-void RunBench(Benchmark* b, int nthread, int siz) {
-	int n, last;
-
-	// TODO(rsc): Threaded benchmarks.
-	if(nthread != 1)
-		return;
-	
-	// run once in case it's expensive
-	n = 1;
-	runN(b, n, siz);
-	while(ns < (int)1e9 && n < (int)1e9) {
-		last = n;
-		if(ns/n == 0)
-			n = (int)1e9;
-		else
-			n = (int)1e9 / static_cast<int>(ns/n);
-		
-		n = std::max(last+1, std::min(n+n/2, 100*last));
-		n = round(n);
-		runN(b, n, siz);
-	}
-	
-	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->fnr || b->lo != b->hi) {
-		if(siz >= (1<<20))
-			snprintf(suf, sizeof suf, "/%dM", siz/(1<<20));
-		else if(siz >= (1<<10))
-			snprintf(suf, sizeof suf, "/%dK", siz/(1<<10));
-		else
-			snprintf(suf, sizeof suf, "/%d", siz);
-	}
-	printf("%s%s\t%8lld\t%10lld ns/op%s\n", b->name, suf, (long long)n, (long long)ns/n, mb);
-	fflush(stdout);
+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 int match(const char* name, int argc, const char** argv) {
-	if(argc == 1)
-		return 1;
-	for(int i = 1; i < argc; i++)
-		if(RE2::PartialMatch(name, argv[i]))
-			return 1;
-	return 0;
+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(match(b->name, argc, argv))
-			for(int j = b->threadlo; j <= b->threadhi; j++)
-				for(int k = std::max(b->lo, 1); k <= std::max(b->hi, 1); k<<=1)
-					RunBench(b, j, k);
-	}
+  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

@@ -6,38 +6,151 @@
 #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 {
-struct Benchmark {
-  const char* name;
-  void (*fn)(int);
-  void (*fnr)(int, int);
-  int lo;
-  int hi;
-  int threadlo;
-  int threadhi;
 
+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();
-  Benchmark(const char* name, void (*f)(int)) { Clear(name); fn = f; Register(); }
-  Benchmark(const char* name, void (*f)(int, int), int l, int h) { Clear(name); fnr = f; lo = l; hi = h; Register(); }
-  void Clear(const char* n) { name = n; fn = 0; fnr = 0; lo = 0; hi = 0; threadlo = 0; threadhi = 0; }
-  Benchmark* ThreadRange(int lo, int hi) { threadlo = lo; threadhi = hi; return this; }
-};
-}  // namespace testing
 
-void SetBenchmarkBytesProcessed(int64_t);
-void StopBenchmarkTiming();
-void StartBenchmarkTiming();
-void BenchmarkMemoryUsage();
-void SetBenchmarkItemsProcessed(int);
+  const char* name_;
+  std::function<void(int, int)> func_;
+  int lo_;
+  int hi_;
+  bool has_arg_;
 
-int NumCPUs();
+  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(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))
+#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

@@ -10,20 +10,17 @@
 // If you want to do that, see
 // https://gflags.github.io/gflags/
 
-#include <stdint.h>
-
-#define DEFINE_flag(type, name, deflt, desc) \
+#define DEFINE_FLAG(type, name, deflt, desc) \
 	namespace re2 { type FLAGS_##name = deflt; }
 
-#define DECLARE_flag(type, name) \
+#define DECLARE_FLAG(type, name) \
 	namespace re2 { extern type FLAGS_##name; }
 
-#define DEFINE_bool(name, deflt, desc) DEFINE_flag(bool, name, deflt, desc)
-#define DEFINE_int32(name, deflt, desc) DEFINE_flag(int32_t, name, deflt, desc)
-#define DEFINE_string(name, deflt, desc) DEFINE_flag(std::string, name, deflt, desc)
-
-#define DECLARE_bool(name) DECLARE_flag(bool, name)
-#define DECLARE_int32(name) DECLARE_flag(int32_t, name)
-#define DECLARE_string(name) DECLARE_flag(std::string, name)
+namespace re2 {
+template <typename T>
+T GetFlag(const T& flag) {
+  return flag;
+}
+}  // namespace re2
 
 #endif  // UTIL_FLAGS_H_

package/vendor/util/malloc_counter.h

@@ -0,0 +1,19 @@
+// 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_MALLOC_COUNTER_H_
+#define UTIL_MALLOC_COUNTER_H_
+
+namespace testing {
+class MallocCounter {
+ public:
+  MallocCounter(int x) {}
+  static const int THIS_THREAD_ONLY = 0;
+  long long HeapGrowth() { return 0; }
+  long long PeakHeapGrowth() { return 0; }
+  void Reset() {}
+};
+}  // namespace testing
+
+#endif  // UTIL_MALLOC_COUNTER_H_

package/vendor/util/pcre.cc

@@ -35,9 +35,10 @@
 // not exceed main thread stacks.  Note that other threads
 // often have smaller stacks, and therefore tightening
 // regexp_stack_limit may frequently be necessary.
-DEFINE_int32(regexp_stack_limit, 256<<10, "default PCRE stack limit (bytes)");
-DEFINE_int32(regexp_match_limit, 1000000,
-             "default PCRE match limit (function calls)");
+DEFINE_FLAG(int, regexp_stack_limit, 256 << 10,
+            "default PCRE stack limit (bytes)");
+DEFINE_FLAG(int, regexp_match_limit, 1000000,
+            "default PCRE match limit (function calls)");
 
 #ifndef USEPCRE
 
@@ -523,12 +524,12 @@ int PCRE::TryMatch(const StringPiece& text,
 
   int match_limit = match_limit_;
   if (match_limit <= 0) {
-    match_limit = FLAGS_regexp_match_limit;
+    match_limit = GetFlag(FLAGS_regexp_match_limit);
   }
 
   int stack_limit = stack_limit_;
   if (stack_limit <= 0) {
-    stack_limit = FLAGS_regexp_stack_limit;
+    stack_limit = GetFlag(FLAGS_regexp_stack_limit);
   }
 
   pcre_extra extra = { 0 };
@@ -977,32 +978,7 @@ static bool parse_double_float(const char* str, size_t n, bool isfloat,
   } else {
     r = strtod(buf, &end);
   }
-  if (end != buf + n) {
-#ifdef _WIN32
-    // Microsoft's strtod() doesn't handle inf and nan, so we have to
-    // handle it explicitly.  Speed is not important here because this
-    // code is only called in unit tests.
-    bool pos = true;
-    const char* i = buf;
-    if ('-' == *i) {
-      pos = false;
-      ++i;
-    } else if ('+' == *i) {
-      ++i;
-    }
-    if (0 == _stricmp(i, "inf") || 0 == _stricmp(i, "infinity")) {
-      r = std::numeric_limits<double>::infinity();
-      if (!pos)
-        r = -r;
-    } else if (0 == _stricmp(i, "nan")) {
-      r = std::numeric_limits<double>::quiet_NaN();
-    } else {
-      return false;
-    }
-#else
-    return false;   // Leftover junk
-#endif
-  }
+  if (end != buf + n) return false;   // Leftover junk
   if (errno) return false;
   if (dest == NULL) return true;
   if (isfloat) {

package/vendor/util/test.cc

@@ -3,10 +3,13 @@
 // license that can be found in the LICENSE file.
 
 #include <stdio.h>
+#include <string>
 
 #include "util/test.h"
 
-DEFINE_string(test_tmpdir, "/var/tmp", "temp directory");
+namespace testing {
+std::string TempDir() { return "/tmp/"; }
+}  // namespace testing
 
 struct Test {
   void (*fn)(void);