@nxtedition/rocksdb 15.1.5 → 15.2.1

package/deps/re2/python/toolchains/generate.py

@@ -0,0 +1,100 @@
+# Copyright 2019 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.
+
+import os
+import shutil
+import sys
+import sysconfig
+
+
+def generate():
+  include = sysconfig.get_path('include')
+  libs = os.path.join(include, '../libs')
+
+  mydir = os.path.dirname(sys.argv[0]) or '.'
+  shutil.copytree(include, f'{mydir}/include')
+  try:
+    shutil.copytree(libs, f'{mydir}/libs')
+  except FileNotFoundError:
+    # We must not be running on Windows. :)
+    pass
+
+  with open(f'{mydir}/BUILD.bazel', 'x') as file:
+    file.write(
+        """\
+load("@rules_cc//cc:cc_import.bzl", "cc_import")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_python//python/cc:py_cc_toolchain.bzl", "py_cc_toolchain")
+load("@rules_python//python:py_runtime.bzl", "py_runtime")
+load("@rules_python//python:py_runtime_pair.bzl", "py_runtime_pair")
+
+package(default_visibility = ["//visibility:public"])
+
+toolchain(
+    name = "py",
+    toolchain = ":py_toolchain",
+    toolchain_type = "@rules_python//python:toolchain_type",
+)
+
+py_runtime_pair(
+    name = "py_toolchain",
+    py3_runtime = ":interpreter",
+)
+
+py_runtime(
+    name = "interpreter",
+    interpreter_path = "{interpreter_path}",
+    interpreter_version_info = {{
+        "major": "{major}",
+        "minor": "{minor}",
+    }},
+    python_version = "PY3",
+)
+
+toolchain(
+    name = "py_cc",
+    toolchain = ":py_cc_toolchain",
+    toolchain_type = "@rules_python//python/cc:toolchain_type",
+)
+
+py_cc_toolchain(
+    name = "py_cc_toolchain",
+    headers = ":headers",
+    libs = ":libraries",
+    python_version = "{major}.{minor}",
+)
+
+cc_library(
+    name = "headers",
+    hdrs = glob(["include/**/*.h"]),
+    includes = ["include"],
+    deps = select({{
+        "@platforms//os:windows": [":interface_library"],
+        "//conditions:default": [],
+    }}),
+)
+
+cc_import(
+    name = "interface_library",
+    interface_library = select({{
+        "@platforms//os:windows": "libs/python{major}{minor}.lib",
+        "//conditions:default": None,
+    }}),
+    system_provided = True,
+)
+
+# Not actually necessary for our purposes. :)
+cc_library(
+    name = "libraries",
+)
+""".format(
+            interpreter_path=sys.executable.replace('\\', '/'),
+            major=sys.version_info.major,
+            minor=sys.version_info.minor,
+        )
+    )
+
+
+if __name__ == '__main__':
+  generate()

package/deps/re2/re2/bitmap256.cc

@@ -0,0 +1,43 @@
+// Copyright 2023 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 "re2/bitmap256.h"
+
+#include <stdint.h>
+
+#include "absl/log/absl_check.h"
+
+namespace re2 {
+
+int Bitmap256::FindNextSetBit(int c) const {
+  ABSL_DCHECK_GE(c, 0);
+  ABSL_DCHECK_LE(c, 255);
+
+  // Check the word that contains the bit. Mask out any lower bits.
+  int i = c / 64;
+  uint64_t word = words_[i] & (~uint64_t{0} << (c % 64));
+  if (word != 0)
+    return (i * 64) + FindLSBSet(word);
+
+  // Check any following words.
+  i++;
+  switch (i) {
+    case 1:
+      if (words_[1] != 0)
+        return (1 * 64) + FindLSBSet(words_[1]);
+      [[fallthrough]];
+    case 2:
+      if (words_[2] != 0)
+        return (2 * 64) + FindLSBSet(words_[2]);
+      [[fallthrough]];
+    case 3:
+      if (words_[3] != 0)
+        return (3 * 64) + FindLSBSet(words_[3]);
+      [[fallthrough]];
+    default:
+      return -1;
+  }
+}
+
+}  // namespace re2

package/deps/re2/re2/bitmap256.h

@@ -0,0 +1,88 @@
+// 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 RE2_BITMAP256_H_
+#define RE2_BITMAP256_H_
+
+#include <stdint.h>
+#include <string.h>
+
+#include "absl/log/absl_check.h"
+#include "absl/log/absl_log.h"
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+namespace re2 {
+
+class Bitmap256 {
+ public:
+  Bitmap256() {
+    Clear();
+  }
+
+  // Clears all of the bits.
+  void Clear() {
+    memset(words_, 0, sizeof words_);
+  }
+
+  // Tests the bit with index c.
+  bool Test(int c) const {
+    ABSL_DCHECK_GE(c, 0);
+    ABSL_DCHECK_LE(c, 255);
+
+    return (words_[c / 64] & (uint64_t{1} << (c % 64))) != 0;
+  }
+
+  // Sets the bit with index c.
+  void Set(int c) {
+    ABSL_DCHECK_GE(c, 0);
+    ABSL_DCHECK_LE(c, 255);
+
+    words_[c / 64] |= (uint64_t{1} << (c % 64));
+  }
+
+  // Finds the next non-zero bit with index >= c.
+  // Returns -1 if no such bit exists.
+  int FindNextSetBit(int c) const;
+
+ private:
+  // Finds the least significant non-zero bit in n.
+  static int FindLSBSet(uint64_t n) {
+    ABSL_DCHECK_NE(n, uint64_t{0});
+#if defined(__GNUC__)
+    return __builtin_ctzll(n);
+#elif defined(_MSC_VER) && defined(_M_X64)
+    unsigned long c;
+    _BitScanForward64(&c, n);
+    return static_cast<int>(c);
+#elif defined(_MSC_VER) && defined(_M_IX86)
+    unsigned long c;
+    if (static_cast<uint32_t>(n) != 0) {
+      _BitScanForward(&c, static_cast<uint32_t>(n));
+      return static_cast<int>(c);
+    } else {
+      _BitScanForward(&c, static_cast<uint32_t>(n >> 32));
+      return static_cast<int>(c) + 32;
+    }
+#else
+    int c = 63;
+    for (int shift = 1 << 5; shift != 0; shift >>= 1) {
+      uint64_t word = n << shift;
+      if (word != 0) {
+        n = word;
+        c -= shift;
+      }
+    }
+    return c;
+#endif
+  }
+
+  uint64_t words_[4];
+};
+
+}  // namespace re2
+
+#endif  // RE2_BITMAP256_H_

package/deps/re2/re2/bitstate.cc

@@ -0,0 +1,389 @@
+// Copyright 2008 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.
+
+// Tested by search_test.cc, exhaustive_test.cc, tester.cc
+
+// Prog::SearchBitState is a regular expression search with submatch
+// tracking for small regular expressions and texts.  Similarly to
+// testing/backtrack.cc, it allocates a bitmap with (count of
+// lists) * (length of text) bits to make sure it never explores the
+// same (instruction list, character position) multiple times.  This
+// limits the search to run in time linear in the length of the text.
+//
+// Unlike testing/backtrack.cc, SearchBitState is not recursive
+// on the text.
+//
+// SearchBitState is a fast replacement for the NFA code on small
+// regexps and texts when SearchOnePass cannot be used.
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <limits>
+#include <utility>
+
+#include "absl/log/absl_check.h"
+#include "absl/log/absl_log.h"
+#include "absl/strings/string_view.h"
+#include "re2/pod_array.h"
+#include "re2/prog.h"
+#include "re2/regexp.h"
+
+namespace re2 {
+
+struct Job {
+  int id;
+  int rle;  // run length encoding
+  const char* p;
+};
+
+class BitState {
+ public:
+  explicit BitState(Prog* prog);
+
+  // The usual Search prototype.
+  // Can only call Search once per BitState.
+  bool Search(absl::string_view text, absl::string_view context, bool anchored,
+              bool longest, absl::string_view* submatch, int nsubmatch);
+
+ private:
+  static inline bool ShouldVisit(absl::string_view text, uint64_t* visited, uint16_t id, const char* p);
+  void Push(int id, const char* p);
+  void GrowStack();
+  bool TrySearch(int id, const char* p);
+
+  // Search parameters
+  Prog* prog_;                   // program being run
+  absl::string_view text_;       // text being searched
+  absl::string_view context_;    // greater context of text being searched
+  bool anchored_;                // whether search is anchored at text.begin()
+  bool longest_;                 // whether search wants leftmost-longest match
+  bool endmatch_;                // whether match must end at text.end()
+  absl::string_view* submatch_;  // submatches to fill in
+  int nsubmatch_;                //   # of submatches to fill in
+
+  // Search state
+  static constexpr int kVisitedBits = 64;
+  PODArray<uint64_t> visited_;  // bitmap: (list ID, char*) pairs visited
+  PODArray<const char*> cap_;   // capture registers
+  PODArray<Job> job_;           // stack of text positions to explore
+  int njob_;                    // stack size
+
+  BitState(const BitState&) = delete;
+  BitState& operator=(const BitState&) = delete;
+};
+
+BitState::BitState(Prog* prog)
+  : prog_(prog),
+    anchored_(false),
+    longest_(false),
+    endmatch_(false),
+    submatch_(NULL),
+    nsubmatch_(0),
+    njob_(0) {
+}
+
+// Given the text being searched and current visited state,
+// as well as a list ID, should the search visit the (list ID, p) pair?
+// If so, remember that it was visited so that the next time,
+// we don't repeat the visit.
+// We pass text and visited to this as a static method so that the
+// caller can do those loads once instead of this code dereferencing
+// them multiple times.
+bool BitState::ShouldVisit(absl::string_view text, uint64_t* visited, uint16_t list_id, const char* p) {
+  int n = list_id * static_cast<int>(text.size()+1) +
+          static_cast<int>(p-text.data());
+  if (visited[n/kVisitedBits] & (uint64_t{1} << (n & (kVisitedBits-1))))
+    return false;
+  visited[n/kVisitedBits] |= uint64_t{1} << (n & (kVisitedBits-1));
+  return true;
+}
+
+// Grow the stack.
+void BitState::GrowStack() {
+  PODArray<Job> tmp(2*job_.size());
+  memmove(tmp.data(), job_.data(), njob_*sizeof job_[0]);
+  job_ = std::move(tmp);
+}
+
+// Push (id, p) onto the stack, growing it if necessary.
+void BitState::Push(int id, const char* p) {
+  if (njob_ >= job_.size()) {
+    GrowStack();
+    if (njob_ >= job_.size()) {
+      ABSL_LOG(DFATAL) << "GrowStack() failed: "
+                       << "njob_ = " << njob_ << ", "
+                       << "job_.size() = " << job_.size();
+      return;
+    }
+  }
+
+  // If id < 0, it's undoing a Capture,
+  // so we mustn't interfere with that.
+  if (id >= 0 && njob_ > 0) {
+    Job* top = &job_[njob_-1];
+    if (id == top->id &&
+        p == top->p + top->rle + 1 &&
+        top->rle < std::numeric_limits<int>::max()) {
+      ++top->rle;
+      return;
+    }
+  }
+
+  Job* top = &job_[njob_++];
+  top->id = id;
+  top->rle = 0;
+  top->p = p;
+}
+
+// Try a search from instruction id0 in state p0.
+// Return whether it succeeded.
+bool BitState::TrySearch(int id0, const char* p0) {
+  bool matched = false;
+  const char* end = text_.data() + text_.size();
+  uint16_t* list_heads = prog_->list_heads();
+  uint64_t* visited = visited_.data();
+  njob_ = 0;
+  // Push() no longer checks ShouldVisit(),
+  // so we must perform the check ourselves.
+  if (ShouldVisit(text_, visited, list_heads[id0], p0))
+    Push(id0, p0);
+  while (njob_ > 0) {
+    // Pop job off stack.
+    --njob_;
+    int id = job_[njob_].id;
+    int& rle = job_[njob_].rle;
+    const char* p = job_[njob_].p;
+
+    if (id < 0) {
+      // Undo the Capture.
+      cap_[prog_->inst(-id)->cap()] = p;
+      continue;
+    }
+
+    if (rle > 0) {
+      p += rle;
+      // Revivify job on stack.
+      --rle;
+      ++njob_;
+    }
+
+  Loop:
+    // Visit id, p.
+    Prog::Inst* ip = prog_->inst(id);
+    switch (ip->opcode()) {
+      default:
+        ABSL_LOG(DFATAL) << "Unexpected opcode: " << ip->opcode();
+        return false;
+
+      case kInstFail:
+        break;
+
+      case kInstAltMatch:
+        if (ip->greedy(prog_)) {
+          // out1 is the Match instruction.
+          id = ip->out1();
+          p = end;
+          goto Loop;
+        }
+        if (longest_) {
+          // ip must be non-greedy...
+          // out is the Match instruction.
+          id = ip->out();
+          p = end;
+          goto Loop;
+        }
+        goto Next;
+
+      case kInstByteRange: {
+        int c = -1;
+        if (p < end)
+          c = *p & 0xFF;
+        if (!ip->Matches(c))
+          goto Next;
+
+        if (ip->hint() != 0)
+          Push(id+ip->hint(), p);  // try the next when we're done
+        id = ip->out();
+        p++;
+        goto CheckAndLoop;
+      }
+
+      case kInstCapture:
+        if (!ip->last())
+          Push(id+1, p);  // try the next when we're done
+
+        if (0 <= ip->cap() && ip->cap() < cap_.size()) {
+          // Capture p to register, but save old value first.
+          Push(-id, cap_[ip->cap()]);  // undo when we're done
+          cap_[ip->cap()] = p;
+        }
+
+        id = ip->out();
+        goto CheckAndLoop;
+
+      case kInstEmptyWidth:
+        if (ip->empty() & ~Prog::EmptyFlags(context_, p))
+          goto Next;
+
+        if (!ip->last())
+          Push(id+1, p);  // try the next when we're done
+        id = ip->out();
+        goto CheckAndLoop;
+
+      case kInstNop:
+        if (!ip->last())
+          Push(id+1, p);  // try the next when we're done
+        id = ip->out();
+
+      CheckAndLoop:
+        // Sanity check: id is the head of its list, which must
+        // be the case if id-1 is the last of *its* list. :)
+        ABSL_DCHECK(id == 0 || prog_->inst(id-1)->last());
+        if (ShouldVisit(text_, visited, list_heads[id], p))
+          goto Loop;
+        break;
+
+      case kInstMatch: {
+        if (endmatch_ && p != end)
+          goto Next;
+
+        // We found a match.  If the caller doesn't care
+        // where the match is, no point going further.
+        if (nsubmatch_ == 0)
+          return true;
+
+        // Record best match so far.
+        // Only need to check end point, because this entire
+        // call is only considering one start position.
+        matched = true;
+        cap_[1] = p;
+        if (submatch_[0].data() == NULL ||
+            (longest_ && p > submatch_[0].data() + submatch_[0].size())) {
+          for (int i = 0; i < nsubmatch_; i++)
+            submatch_[i] = absl::string_view(
+                cap_[2 * i],
+                static_cast<size_t>(cap_[2 * i + 1] - cap_[2 * i]));
+        }
+
+        // If going for first match, we're done.
+        if (!longest_)
+          return true;
+
+        // If we used the entire text, no longer match is possible.
+        if (p == end)
+          return true;
+
+        // Otherwise, continue on in hope of a longer match.
+        // Note the absence of the ShouldVisit() check here
+        // due to execution remaining in the same list.
+      Next:
+        if (!ip->last()) {
+          id++;
+          goto Loop;
+        }
+        break;
+      }
+    }
+  }
+  return matched;
+}
+
+// Search text (within context) for prog_.
+bool BitState::Search(absl::string_view text, absl::string_view context,
+                      bool anchored, bool longest, absl::string_view* submatch,
+                      int nsubmatch) {
+  // Search parameters.
+  text_ = text;
+  context_ = context;
+  if (context_.data() == NULL)
+    context_ = text;
+  if (prog_->anchor_start() && BeginPtr(context_) != BeginPtr(text))
+    return false;
+  if (prog_->anchor_end() && EndPtr(context_) != EndPtr(text))
+    return false;
+  anchored_ = anchored || prog_->anchor_start();
+  longest_ = longest || prog_->anchor_end();
+  endmatch_ = prog_->anchor_end();
+  submatch_ = submatch;
+  nsubmatch_ = nsubmatch;
+  for (int i = 0; i < nsubmatch_; i++)
+    submatch_[i] = absl::string_view();
+
+  // Allocate scratch space.
+  int nvisited = prog_->list_count() * static_cast<int>(text.size()+1);
+  nvisited = (nvisited + kVisitedBits-1) / kVisitedBits;
+  visited_ = PODArray<uint64_t>(nvisited);
+  memset(visited_.data(), 0, nvisited*sizeof visited_[0]);
+
+  int ncap = 2*nsubmatch;
+  if (ncap < 2)
+    ncap = 2;
+  cap_ = PODArray<const char*>(ncap);
+  memset(cap_.data(), 0, ncap*sizeof cap_[0]);
+
+  // When sizeof(Job) == 16, we start with a nice round 1KiB. :)
+  job_ = PODArray<Job>(64);
+
+  // Anchored search must start at text.begin().
+  if (anchored_) {
+    cap_[0] = text.data();
+    return TrySearch(prog_->start(), text.data());
+  }
+
+  // Unanchored search, starting from each possible text position.
+  // Notice that we have to try the empty string at the end of
+  // the text, so the loop condition is p <= text.end(), not p < text.end().
+  // This looks like it's quadratic in the size of the text,
+  // but we are not clearing visited_ between calls to TrySearch,
+  // so no work is duplicated and it ends up still being linear.
+  const char* etext = text.data() + text.size();
+  for (const char* p = text.data(); p <= etext; p++) {
+    // Try to use prefix accel (e.g. memchr) to skip ahead.
+    if (p < etext && prog_->can_prefix_accel()) {
+      p = reinterpret_cast<const char*>(prog_->PrefixAccel(p, etext - p));
+      if (p == NULL)
+        p = etext;
+    }
+
+    cap_[0] = p;
+    if (TrySearch(prog_->start(), p))  // Match must be leftmost; done.
+      return true;
+    // Avoid invoking undefined behavior (arithmetic on a null pointer)
+    // by simply not continuing the loop.
+    if (p == NULL)
+      break;
+  }
+  return false;
+}
+
+// Bit-state search.
+bool Prog::SearchBitState(absl::string_view text, absl::string_view context,
+                          Anchor anchor, MatchKind kind,
+                          absl::string_view* match, int nmatch) {
+  // If full match, we ask for an anchored longest match
+  // and then check that match[0] == text.
+  // So make sure match[0] exists.
+  absl::string_view sp0;
+  if (kind == kFullMatch) {
+    anchor = kAnchored;
+    if (nmatch < 1) {
+      match = &sp0;
+      nmatch = 1;
+    }
+  }
+
+  // Run the search.
+  BitState b(this);
+  bool anchored = anchor == kAnchored;
+  bool longest = kind != kFirstMatch;
+  if (!b.Search(text, context, anchored, longest, match, nmatch))
+    return false;
+  if (kind == kFullMatch && EndPtr(match[0]) != EndPtr(text))
+    return false;
+  return true;
+}
+
+}  // namespace re2