@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/re2/re2/filtered_re2.cc

@@ -1,138 +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 "re2/filtered_re2.h"
-
-#include <stddef.h>
-
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "absl/log/absl_log.h"
-#include "absl/strings/string_view.h"
-#include "re2/prefilter.h"
-#include "re2/prefilter_tree.h"
-
-namespace re2 {
-
-FilteredRE2::FilteredRE2()
-    : compiled_(false),
-      prefilter_tree_(new PrefilterTree()) {
-}
-
-FilteredRE2::FilteredRE2(int min_atom_len)
-    : compiled_(false),
-      prefilter_tree_(new PrefilterTree(min_atom_len)) {
-}
-
-FilteredRE2::~FilteredRE2() {
-  for (size_t i = 0; i < re2_vec_.size(); i++)
-    delete re2_vec_[i];
-}
-
-FilteredRE2::FilteredRE2(FilteredRE2&& other)
-    : re2_vec_(std::move(other.re2_vec_)),
-      compiled_(other.compiled_),
-      prefilter_tree_(std::move(other.prefilter_tree_)) {
-  other.re2_vec_.clear();
-  other.re2_vec_.shrink_to_fit();
-  other.compiled_ = false;
-  other.prefilter_tree_.reset(new PrefilterTree());
-}
-
-FilteredRE2& FilteredRE2::operator=(FilteredRE2&& other) {
-  this->~FilteredRE2();
-  (void) new (this) FilteredRE2(std::move(other));
-  return *this;
-}
-
-RE2::ErrorCode FilteredRE2::Add(absl::string_view pattern,
-                                const RE2::Options& options, int* id) {
-  RE2* re = new RE2(pattern, options);
-  RE2::ErrorCode code = re->error_code();
-
-  if (!re->ok()) {
-    if (options.log_errors()) {
-      ABSL_LOG(ERROR) << "Couldn't compile regular expression, skipping: "
-                      << pattern << " due to error " << re->error();
-    }
-    delete re;
-  } else {
-    *id = static_cast<int>(re2_vec_.size());
-    re2_vec_.push_back(re);
-  }
-
-  return code;
-}
-
-void FilteredRE2::Compile(std::vector<std::string>* atoms) {
-  if (compiled_) {
-    ABSL_LOG(ERROR) << "Compile called already.";
-    return;
-  }
-
-  // Similarly to PrefilterTree::Compile(), make compiling
-  // a no-op if it's attempted before adding any patterns.
-  if (re2_vec_.empty()) {
-    return;
-  }
-
-  for (size_t i = 0; i < re2_vec_.size(); i++) {
-    Prefilter* prefilter = Prefilter::FromRE2(re2_vec_[i]);
-    prefilter_tree_->Add(prefilter);
-  }
-  atoms->clear();
-  prefilter_tree_->Compile(atoms);
-  compiled_ = true;
-}
-
-int FilteredRE2::SlowFirstMatch(absl::string_view text) const {
-  for (size_t i = 0; i < re2_vec_.size(); i++)
-    if (RE2::PartialMatch(text, *re2_vec_[i]))
-      return static_cast<int>(i);
-  return -1;
-}
-
-int FilteredRE2::FirstMatch(absl::string_view text,
-                            const std::vector<int>& atoms) const {
-  if (!compiled_) {
-    ABSL_LOG(DFATAL) << "FirstMatch called before Compile.";
-    return -1;
-  }
-  std::vector<int> regexps;
-  prefilter_tree_->RegexpsGivenStrings(atoms, &regexps);
-  for (size_t i = 0; i < regexps.size(); i++)
-    if (RE2::PartialMatch(text, *re2_vec_[regexps[i]]))
-      return regexps[i];
-  return -1;
-}
-
-bool FilteredRE2::AllMatches(absl::string_view text,
-                             const std::vector<int>& atoms,
-                             std::vector<int>* matching_regexps) const {
-  matching_regexps->clear();
-  std::vector<int> regexps;
-  prefilter_tree_->RegexpsGivenStrings(atoms, &regexps);
-  for (size_t i = 0; i < regexps.size(); i++)
-    if (RE2::PartialMatch(text, *re2_vec_[regexps[i]]))
-      matching_regexps->push_back(regexps[i]);
-  return !matching_regexps->empty();
-}
-
-void FilteredRE2::AllPotentials(const std::vector<int>& atoms,
-                                std::vector<int>* potential_regexps) const {
-  prefilter_tree_->RegexpsGivenStrings(atoms, potential_regexps);
-}
-
-void FilteredRE2::RegexpsGivenStrings(const std::vector<int>& matched_atoms,
-                                      std::vector<int>* passed_regexps) {
-  prefilter_tree_->RegexpsGivenStrings(matched_atoms, passed_regexps);
-}
-
-void FilteredRE2::PrintPrefilter(int regexpid) {
-  prefilter_tree_->PrintPrefilter(regexpid);
-}
-
-}  // namespace re2

package/deps/re2/re2/filtered_re2.h

@@ -1,115 +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 RE2_FILTERED_RE2_H_
-#define RE2_FILTERED_RE2_H_
-
-// The class FilteredRE2 is used as a wrapper to multiple RE2 regexps.
-// It provides a prefilter mechanism that helps in cutting down the
-// number of regexps that need to be actually searched.
-//
-// By design, it does not include a string matching engine. This is to
-// allow the user of the class to use their favorite string matching
-// engine. The overall flow is: Add all the regexps using Add, then
-// Compile the FilteredRE2. Compile returns strings that need to be
-// matched. Note that the returned strings are lowercased and distinct.
-// For applying regexps to a search text, the caller does the string
-// matching using the returned strings. When doing the string match,
-// note that the caller has to do that in a case-insensitive way or
-// on a lowercased version of the search text. Then call FirstMatch
-// or AllMatches with a vector of indices of strings that were found
-// in the text to get the actual regexp matches.
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "absl/strings/string_view.h"
-#include "re2/re2.h"
-
-namespace re2 {
-
-class PrefilterTree;
-
-class FilteredRE2 {
- public:
-  FilteredRE2();
-  explicit FilteredRE2(int min_atom_len);
-  ~FilteredRE2();
-
-  // Not copyable.
-  FilteredRE2(const FilteredRE2&) = delete;
-  FilteredRE2& operator=(const FilteredRE2&) = delete;
-  // Movable.
-  FilteredRE2(FilteredRE2&& other);
-  FilteredRE2& operator=(FilteredRE2&& other);
-
-  // Uses RE2 constructor to create a RE2 object (re). Returns
-  // re->error_code(). If error_code is other than NoError, then re is
-  // deleted and not added to re2_vec_.
-  RE2::ErrorCode Add(absl::string_view pattern,
-                     const RE2::Options& options,
-                     int* id);
-
-  // Prepares the regexps added by Add for filtering.  Returns a set
-  // of strings that the caller should check for in candidate texts.
-  // The returned strings are lowercased and distinct. When doing
-  // string matching, it should be performed in a case-insensitive
-  // way or the search text should be lowercased first.  Call after
-  // all Add calls are done.
-  void Compile(std::vector<std::string>* strings_to_match);
-
-  // Returns the index of the first matching regexp.
-  // Returns -1 on no match. Can be called prior to Compile.
-  // Does not do any filtering: simply tries to Match the
-  // regexps in a loop.
-  int SlowFirstMatch(absl::string_view text) const;
-
-  // Returns the index of the first matching regexp.
-  // Returns -1 on no match. Compile has to be called before
-  // calling this.
-  int FirstMatch(absl::string_view text,
-                 const std::vector<int>& atoms) const;
-
-  // Returns the indices of all matching regexps, after first clearing
-  // matched_regexps.
-  bool AllMatches(absl::string_view text,
-                  const std::vector<int>& atoms,
-                  std::vector<int>* matching_regexps) const;
-
-  // Returns the indices of all potentially matching regexps after first
-  // clearing potential_regexps.
-  // A regexp is potentially matching if it passes the filter.
-  // If a regexp passes the filter it may still not match.
-  // A regexp that does not pass the filter is guaranteed to not match.
-  void AllPotentials(const std::vector<int>& atoms,
-                     std::vector<int>* potential_regexps) const;
-
-  // The number of regexps added.
-  int NumRegexps() const { return static_cast<int>(re2_vec_.size()); }
-
-  // Get the individual RE2 objects.
-  const RE2& GetRE2(int regexpid) const { return *re2_vec_[regexpid]; }
-
- private:
-  // Print prefilter.
-  void PrintPrefilter(int regexpid);
-
-  // Useful for testing and debugging.
-  void RegexpsGivenStrings(const std::vector<int>& matched_atoms,
-                           std::vector<int>* passed_regexps);
-
-  // All the regexps in the FilteredRE2.
-  std::vector<RE2*> re2_vec_;
-
-  // Has the FilteredRE2 been compiled using Compile()
-  bool compiled_;
-
-  // An AND-OR tree of string atoms used for filtering regexps.
-  std::unique_ptr<PrefilterTree> prefilter_tree_;
-};
-
-}  // namespace re2
-
-#endif  // RE2_FILTERED_RE2_H_

package/deps/re2/re2/fuzzing/re2_fuzzer.cc

@@ -1,284 +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.
-
-#include <fuzzer/FuzzedDataProvider.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-#include "absl/strings/string_view.h"
-#include "re2/filtered_re2.h"
-#include "re2/re2.h"
-#include "re2/regexp.h"
-#include "re2/set.h"
-#include "re2/walker-inl.h"
-
-// NOT static, NOT signed.
-uint8_t dummy = 0;
-
-// Walks kRegexpConcat and kRegexpAlternate subexpressions
-// to determine their maximum length.
-class SubexpressionWalker : public re2::Regexp::Walker<int> {
- public:
-  SubexpressionWalker() = default;
-  ~SubexpressionWalker() override = default;
-
-  int PostVisit(re2::Regexp* re, int parent_arg, int pre_arg,
-                int* child_args, int nchild_args) override {
-    switch (re->op()) {
-      case re2::kRegexpConcat:
-      case re2::kRegexpAlternate: {
-        int max = nchild_args;
-        for (int i = 0; i < nchild_args; i++)
-          max = std::max(max, child_args[i]);
-        return max;
-      }
-
-      default:
-        break;
-    }
-    return -1;
-  }
-
-  // Should never be called: we use Walk(), not WalkExponential().
-  int ShortVisit(re2::Regexp* re, int parent_arg) override {
-    return parent_arg;
-  }
-
- private:
-  SubexpressionWalker(const SubexpressionWalker&) = delete;
-  SubexpressionWalker& operator=(const SubexpressionWalker&) = delete;
-};
-
-// Walks substrings (i.e. kRegexpLiteralString subexpressions)
-// to determine their maximum length... in runes, but avoiding
-// overheads due to UTF-8 encoding is worthwhile when fuzzing.
-class SubstringWalker : public re2::Regexp::Walker<int> {
- public:
-  SubstringWalker() = default;
-  ~SubstringWalker() override = default;
-
-  int PostVisit(re2::Regexp* re, int parent_arg, int pre_arg,
-                int* child_args, int nchild_args) override {
-    switch (re->op()) {
-      case re2::kRegexpConcat:
-      case re2::kRegexpAlternate:
-      case re2::kRegexpStar:
-      case re2::kRegexpPlus:
-      case re2::kRegexpQuest:
-      case re2::kRegexpRepeat:
-      case re2::kRegexpCapture: {
-        int max = -1;
-        for (int i = 0; i < nchild_args; i++)
-          max = std::max(max, child_args[i]);
-        return max;
-      }
-
-      case re2::kRegexpLiteralString:
-        return re->nrunes();
-
-      default:
-        break;
-    }
-    return -1;
-  }
-
-  // Should never be called: we use Walk(), not WalkExponential().
-  int ShortVisit(re2::Regexp* re, int parent_arg) override {
-    return parent_arg;
-  }
-
- private:
-  SubstringWalker(const SubstringWalker&) = delete;
-  SubstringWalker& operator=(const SubstringWalker&) = delete;
-};
-
-void TestOneInput(absl::string_view pattern, const RE2::Options& options,
-                  RE2::Anchor anchor, absl::string_view text) {
-  // Crudely limit the use of ., \p, \P, \d, \D, \s, \S, \w and \W.
-  // Otherwise, we will waste time on inputs that have long runs of various
-  // character classes. The fuzzer has shown itself to be easily capable of
-  // generating such patterns that fall within the other limits, but result
-  // in timeouts nonetheless. The marginal cost is high - even more so when
-  // counted repetition is involved - whereas the marginal benefit is zero.
-  // Crudely limit the use of 'k', 'K', 's' and 'S' too because they become
-  // three-element character classes when case-insensitive and using UTF-8.
-  // TODO(junyer): Handle [[:alnum:]] et al. when they start to cause pain.
-  int char_class = 0;
-  int backslash_p = 0;  // very expensive, so handle specially
-  for (size_t i = 0; i < pattern.size(); i++) {
-    if (pattern[i] == '.' ||
-        pattern[i] == 'k' || pattern[i] == 'K' ||
-        pattern[i] == 's' || pattern[i] == 'S')
-      char_class++;
-    if (pattern[i] != '\\')
-      continue;
-    i++;
-    if (i >= pattern.size())
-      break;
-    if (pattern[i] == 'p' || pattern[i] == 'P' ||
-        pattern[i] == 'd' || pattern[i] == 'D' ||
-        pattern[i] == 's' || pattern[i] == 'S' ||
-        pattern[i] == 'w' || pattern[i] == 'W')
-      char_class++;
-    if (pattern[i] == 'p' || pattern[i] == 'P')
-      backslash_p++;
-  }
-  if (char_class > 9)
-    return;
-  if (backslash_p > 1)
-    return;
-
-  // Iterate just once when fuzzing. Otherwise, we easily get bogged down
-  // and coverage is unlikely to improve despite significant expense.
-  RE2::FUZZING_ONLY_set_maximum_global_replace_count(1);
-  // The default is 1000. Even 100 turned out to be too generous
-  // for fuzzing, empirically speaking, so let's try 10 instead.
-  re2::Regexp::FUZZING_ONLY_set_maximum_repeat_count(10);
-
-  RE2 re(pattern, options);
-  if (!re.ok())
-    return;
-
-  // Don't waste time fuzzing programs with large subexpressions.
-  // They can cause bug reports due to fuzzer timeouts. And they
-  // aren't interesting for fuzzing purposes.
-  if (SubexpressionWalker().Walk(re.Regexp(), -1) > 9)
-    return;
-
-  // Don't waste time fuzzing programs with large substrings.
-  // They can cause bug reports due to fuzzer timeouts when they
-  // are repetitions (e.g. hundreds of NUL bytes) and matching is
-  // unanchored. And they aren't interesting for fuzzing purposes.
-  if (SubstringWalker().Walk(re.Regexp(), -1) > 9)
-    return;
-
-  // Don't waste time fuzzing high-size programs.
-  // They can cause bug reports due to fuzzer timeouts.
-  int size = re.ProgramSize();
-  if (size > 9999)
-    return;
-  int rsize = re.ReverseProgramSize();
-  if (rsize > 9999)
-    return;
-
-  // Don't waste time fuzzing high-fanout programs.
-  // They can cause bug reports due to fuzzer timeouts.
-  std::vector<int> histogram;
-  int fanout = re.ProgramFanout(&histogram);
-  if (fanout > 9)
-    return;
-  int rfanout = re.ReverseProgramFanout(&histogram);
-  if (rfanout > 9)
-    return;
-
-  if (re.NumberOfCapturingGroups() == 0) {
-    // Avoid early return due to too many arguments.
-    absl::string_view sp = text;
-    RE2::FullMatch(sp, re);
-    RE2::PartialMatch(sp, re);
-    RE2::Consume(&sp, re);
-    sp = text;  // Reset.
-    RE2::FindAndConsume(&sp, re);
-  } else {
-    // Okay, we have at least one capturing group...
-    // Try conversion for variously typed arguments.
-    absl::string_view sp = text;
-    short s;
-    RE2::FullMatch(sp, re, &s);
-    long l;
-    RE2::PartialMatch(sp, re, &l);
-    float f;
-    RE2::Consume(&sp, re, &f);
-    sp = text;  // Reset.
-    double d;
-    RE2::FindAndConsume(&sp, re, &d);
-  }
-
-  std::string s = std::string(text);
-  RE2::Replace(&s, re, "");
-  s = std::string(text);  // Reset.
-  RE2::GlobalReplace(&s, re, "");
-
-  std::string min, max;
-  re.PossibleMatchRange(&min, &max, /*maxlen=*/9);
-
-  // Exercise some other API functionality.
-  dummy += re.NamedCapturingGroups().size();
-  dummy += re.CapturingGroupNames().size();
-  dummy += RE2::QuoteMeta(pattern).size();
-  dummy += re.Regexp()->ToString().size();
-
-  RE2::Set set(options, anchor);
-  int index = set.Add(pattern, /*error=*/NULL);  // -1 on error
-  if (index != -1 && set.Compile()) {
-    std::vector<int> matches;
-    set.Match(text, &matches);
-  }
-
-  re2::FilteredRE2 filter;
-  index = -1;  // not clobbered on error
-  filter.Add(pattern, options, &index);
-  if (index != -1) {
-    std::vector<std::string> atoms;
-    filter.Compile(&atoms);
-    // Pretend that all atoms match, which
-    // triggers the AND-OR tree maximally.
-    std::vector<int> matched_atoms;
-    matched_atoms.reserve(atoms.size());
-    for (size_t i = 0; i < atoms.size(); ++i)
-      matched_atoms.push_back(static_cast<int>(i));
-    std::vector<int> matches;
-    filter.AllMatches(text, matched_atoms, &matches);
-  }
-}
-
-// Entry point for libFuzzer.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  // An input larger than 4 KiB probably isn't interesting. (This limit
-  // allows for fdp.ConsumeRandomLengthString()'s backslash behaviour.)
-  if (size == 0 || size > 4096)
-    return 0;
-
-  FuzzedDataProvider fdp(data, size);
-
-  // The convention here is that fdp.ConsumeBool() returning false sets
-  // the default value whereas returning true sets the alternate value:
-  // most options default to false and so can be set directly; encoding
-  // defaults to UTF-8; case_sensitive defaults to true. We do NOT want
-  // to log errors. max_mem is 64 MiB because we can afford to use more
-  // RAM in exchange for (hopefully) faster fuzzing.
-  RE2::Options options;
-  options.set_encoding(fdp.ConsumeBool() ? RE2::Options::EncodingLatin1
-                                         : RE2::Options::EncodingUTF8);
-  options.set_posix_syntax(fdp.ConsumeBool());
-  options.set_longest_match(fdp.ConsumeBool());
-  options.set_log_errors(false);
-  options.set_max_mem(64 << 20);
-  options.set_literal(fdp.ConsumeBool());
-  options.set_never_nl(fdp.ConsumeBool());
-  options.set_dot_nl(fdp.ConsumeBool());
-  options.set_never_capture(fdp.ConsumeBool());
-  options.set_case_sensitive(!fdp.ConsumeBool());
-  options.set_perl_classes(fdp.ConsumeBool());
-  options.set_word_boundary(fdp.ConsumeBool());
-  options.set_one_line(fdp.ConsumeBool());
-
-  // ConsumeEnum<RE2::Anchor>() would require RE2::Anchor to specify
-  // kMaxValue, so just use PickValueInArray<RE2::Anchor>() instead.
-  RE2::Anchor anchor = fdp.PickValueInArray<RE2::Anchor>({
-      RE2::UNANCHORED,
-      RE2::ANCHOR_START,
-      RE2::ANCHOR_BOTH,
-  });
-
-  std::string pattern = fdp.ConsumeRandomLengthString(999);
-  std::string text = fdp.ConsumeRandomLengthString(999);
-
-  TestOneInput(pattern, options, anchor, text);
-  return 0;
-}

package/deps/re2/re2/make_perl_groups.pl

@@ -1,116 +0,0 @@
-#!/usr/bin/perl
-# 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.
-
-# Generate table entries giving character ranges
-# for POSIX/Perl character classes.  Rather than
-# figure out what the definition is, it is easier to ask
-# Perl about each letter from 0-128 and write down
-# its answer.
-
-@posixclasses = (
-	"[:alnum:]",
-	"[:alpha:]",
-	"[:ascii:]",
-	"[:blank:]",
-	"[:cntrl:]",
-	"[:digit:]",
-	"[:graph:]",
-	"[:lower:]",
-	"[:print:]",
-	"[:punct:]",
-	"[:space:]",
-	"[:upper:]",
-	"[:word:]",
-	"[:xdigit:]",
-);
-
-@perlclasses = (
-	"\\d",
-	"\\s",
-	"\\w",
-);
-
-%overrides = (
-	# Prior to Perl 5.18, \s did not match vertical tab.
-	# RE2 preserves that original behaviour.
-	"\\s:11" => 0,
-);
-
-sub ComputeClass($) {
-  my ($cname) = @_;
-  my @ranges;
-  my $regexp = qr/[$cname]/;
-  my $start = -1;
-  for (my $i=0; $i<=129; $i++) {
-    if ($i == 129) { $i = 256; }
-    if ($i <= 128 && ($overrides{"$cname:$i"} // chr($i) =~ $regexp)) {
-      if ($start < 0) {
-        $start = $i;
-      }
-    } else {
-      if ($start >= 0) {
-        push @ranges, [$start, $i-1];
-      }
-      $start = -1;
-    }
-  }
-  return @ranges;
-}
-
-sub PrintClass($$@) {
-  my ($cnum, $cname, @ranges) = @_;
-  print "static const URange16 code${cnum}[] = {  /* $cname */\n";
-  for (my $i=0; $i<@ranges; $i++) {
-    my @a = @{$ranges[$i]};
-    printf "\t{ 0x%x, 0x%x },\n", $a[0], $a[1];
-  }
-  print "};\n";
-  my $n = @ranges;
-  my $escname = $cname;
-  $escname =~ s/\\/\\\\/g;
-  $negname = $escname;
-  if ($negname =~ /:/) {
-    $negname =~ s/:/:^/;
-  } else {
-    $negname =~ y/a-z/A-Z/;
-  }
-  return "{ \"$escname\", +1, code$cnum, $n, 0, 0 }", "{ \"$negname\", -1, code$cnum, $n, 0, 0 }";
-}
-
-my $cnum = 0;
-
-sub PrintClasses($@) {
-  my ($pname, @classes) = @_;
-  my @entries;
-  foreach my $cname (@classes) {
-    my @ranges = ComputeClass($cname);
-    push @entries, PrintClass(++$cnum, $cname, @ranges);
-  }
-  print "const UGroup ${pname}_groups[] = {\n";
-  foreach my $e (@entries) {
-    print "\t$e,\n";
-  }
-  print "};\n";
-  my $count = @entries;
-  print "const int num_${pname}_groups = $count;\n";
-}
-
-print <<EOF;
-// GENERATED BY make_perl_groups.pl; DO NOT EDIT.
-// make_perl_groups.pl >perl_groups.cc
-
-#include "re2/unicode_groups.h"
-
-namespace re2 {
-
-EOF
-
-PrintClasses("perl", @perlclasses);
-PrintClasses("posix", @posixclasses);
-
-print <<EOF;
-
-}  // namespace re2
-EOF