@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/re2/re2/testing/backtrack.cc

@@ -1,274 +0,0 @@
-// 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::UnsafeSearchBacktrack is a backtracking regular expression search,
-// except that it remembers where it has been, trading a lot of
-// memory for a lot of time. It exists only for testing purposes.
-//
-// Let me repeat that.
-//
-// THIS CODE SHOULD NEVER BE USED IN PRODUCTION:
-//   - It uses a ton of memory.
-//   - It uses a ton of stack.
-//   - It uses ABSL_CHECK() and ABSL_LOG(FATAL).
-//   - It implements unanchored search by repeated anchored search.
-//
-// On the other hand, it is very simple and a good reference
-// implementation for the more complicated regexp packages.
-//
-// In BUILD, this file is linked into the ":testing" library,
-// not the main library, in order to make it harder to pick up
-// accidentally.
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "absl/base/macros.h"
-#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 {
-
-// Backtracker holds the state for a backtracking search.
-//
-// Excluding the search parameters, the main search state
-// is just the "capture registers", which record, for the
-// current execution, the string position at which each
-// parenthesis was passed.  cap_[0] and cap_[1] are the
-// left and right parenthesis in $0, cap_[2] and cap_[3] in $1, etc.
-//
-// To avoid infinite loops during backtracking on expressions
-// like (a*)*, the visited_[] bitmap marks the (state, string-position)
-// pairs that have already been explored and are thus not worth
-// re-exploring if we get there via another path.  Modern backtracking
-// libraries engineer their program representation differently, to make
-// such infinite loops possible to avoid without keeping a giant visited_
-// bitmap, but visited_ works fine for a reference implementation
-// and it has the nice benefit of making the search run in linear time.
-class Backtracker {
- public:
-  explicit Backtracker(Prog* prog);
-
-  bool Search(absl::string_view text, absl::string_view context, bool anchored,
-              bool longest, absl::string_view* submatch, int nsubmatch);
-
- private:
-  // Explores from instruction id at string position p looking for a match.
-  // Returns true if found (so that caller can stop trying other possibilities).
-  bool Visit(int id, const char* p);
-
-  // Tries instruction id at string position p.
-  // Returns true if a match is found.
-  bool Try(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 search must end at text.end()
-  absl::string_view* submatch_;  // submatches to fill in
-  int nsubmatch_;                // # of submatches to fill in
-
-  // Search state
-  const char* cap_[64];         // capture registers
-  PODArray<uint32_t> visited_;  // bitmap: (Inst*, char*) pairs visited
-
-  Backtracker(const Backtracker&) = delete;
-  Backtracker& operator=(const Backtracker&) = delete;
-};
-
-Backtracker::Backtracker(Prog* prog)
-  : prog_(prog),
-    anchored_(false),
-    longest_(false),
-    endmatch_(false),
-    submatch_(NULL),
-    nsubmatch_(0) {
-}
-
-// Runs a backtracking search.
-bool Backtracker::Search(absl::string_view text, absl::string_view context,
-                         bool anchored, bool longest,
-                         absl::string_view* submatch, int nsubmatch) {
-  text_ = text;
-  context_ = context;
-  if (context_.data() == NULL)
-    context_ = text;
-  if (prog_->anchor_start() && BeginPtr(text) > BeginPtr(context_))
-    return false;
-  if (prog_->anchor_end() && EndPtr(text) < EndPtr(context_))
-    return false;
-  anchored_ = anchored | prog_->anchor_start();
-  longest_ = longest | prog_->anchor_end();
-  endmatch_ = prog_->anchor_end();
-  submatch_ = submatch;
-  nsubmatch_ = nsubmatch;
-  ABSL_CHECK_LT(2*nsubmatch_, static_cast<int>(ABSL_ARRAYSIZE(cap_)));
-  memset(cap_, 0, sizeof cap_);
-
-  // We use submatch_[0] for our own bookkeeping,
-  // so it had better exist.
-  absl::string_view sp0;
-  if (nsubmatch < 1) {
-    submatch_ = &sp0;
-    nsubmatch_ = 1;
-  }
-  submatch_[0] = absl::string_view();
-
-  // Allocate new visited_ bitmap -- size is proportional
-  // to text, so have to reallocate on each call to Search.
-  int nvisited = prog_->size() * static_cast<int>(text.size()+1);
-  nvisited = (nvisited + 31) / 32;
-  visited_ = PODArray<uint32_t>(nvisited);
-  memset(visited_.data(), 0, nvisited*sizeof visited_[0]);
-
-  // Anchored search must start at text.begin().
-  if (anchored_) {
-    cap_[0] = text.data();
-    return Visit(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().
-  for (const char* p = text.data(); p <= text.data() + text.size(); p++) {
-    cap_[0] = p;
-    if (Visit(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;
-}
-
-// Explores from instruction id at string position p looking for a match.
-// Return true if found (so that caller can stop trying other possibilities).
-bool Backtracker::Visit(int id, const char* p) {
-  // Check bitmap.  If we've already explored from here,
-  // either it didn't match or it did but we're hoping for a better match.
-  // Either way, don't go down that road again.
-  ABSL_CHECK(p <= text_.data() + text_.size());
-  int n = id * static_cast<int>(text_.size()+1) +
-          static_cast<int>(p-text_.data());
-  ABSL_CHECK_LT(n/32, visited_.size());
-  if (visited_[n/32] & (1 << (n&31)))
-    return false;
-  visited_[n/32] |= 1 << (n&31);
-
-  Prog::Inst* ip = prog_->inst(id);
-  if (Try(id, p)) {
-    if (longest_ && !ip->last())
-      Visit(id+1, p);
-    return true;
-  }
-  if (!ip->last())
-    return Visit(id+1, p);
-  return false;
-}
-
-// Tries instruction id at string position p.
-// Returns true if a match is found.
-bool Backtracker::Try(int id, const char* p) {
-  // Pick out byte at current position.  If at end of string,
-  // have to explore in hope of finishing a match.  Use impossible byte -1.
-  int c = -1;
-  if (p < text_.data() + text_.size())
-    c = *p & 0xFF;
-
-  Prog::Inst* ip = prog_->inst(id);
-  switch (ip->opcode()) {
-    default:
-      ABSL_LOG(FATAL) << "Unexpected opcode: " << ip->opcode();
-      return false;  // not reached
-
-    case kInstAltMatch:
-      // Ignored.
-      return false;
-
-    case kInstByteRange:
-      if (ip->Matches(c))
-        return Visit(ip->out(), p+1);
-      return false;
-
-    case kInstCapture:
-      if (0 <= ip->cap() &&
-          ip->cap() < static_cast<int>(ABSL_ARRAYSIZE(cap_))) {
-        // Capture p to register, but save old value.
-        const char* q = cap_[ip->cap()];
-        cap_[ip->cap()] = p;
-        bool ret = Visit(ip->out(), p);
-        // Restore old value as we backtrack.
-        cap_[ip->cap()] = q;
-        return ret;
-      }
-      return Visit(ip->out(), p);
-
-    case kInstEmptyWidth:
-      if (ip->empty() & ~Prog::EmptyFlags(context_, p))
-        return false;
-      return Visit(ip->out(), p);
-
-    case kInstNop:
-      return Visit(ip->out(), p);
-
-    case kInstMatch:
-      // We found a match.  If it's the best so far, record the
-      // parameters in the caller's submatch_ array.
-      if (endmatch_ && p != context_.data() + context_.size())
-        return false;
-      cap_[1] = p;
-      if (submatch_[0].data() == NULL ||
-          (longest_ && p > submatch_[0].data() + submatch_[0].size())) {
-        // First match so far - or better match.
-        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]));
-      }
-      return true;
-
-    case kInstFail:
-      return false;
-  }
-}
-
-// Runs a backtracking search.
-bool Prog::UnsafeSearchBacktrack(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.
-  Backtracker 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

package/deps/re2/re2/testing/charclass_test.cc

@@ -1,228 +0,0 @@
-// Copyright 2006 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.
-
-// Test character class manipulations.
-
-#include <stdio.h>
-
-#include "absl/base/macros.h"
-#include "absl/strings/str_format.h"
-#include "gtest/gtest.h"
-#include "re2/regexp.h"
-#include "util/utf.h"
-
-namespace re2 {
-
-struct CCTest {
-  struct {
-    Rune lo;
-    Rune hi;
-  } add[10];
-  int remove;
-  struct {
-    Rune lo;
-    Rune hi;
-  } final[10];
-};
-
-static CCTest tests[] = {
-  { { { 10, 20 }, {-1} }, -1,
-    { { 10, 20 }, {-1} } },
-
-  { { { 10, 20 }, { 20, 30 }, {-1} }, -1,
-    { { 10, 30 }, {-1} } },
-
-  { { { 10, 20 }, { 30, 40 }, { 20, 30 }, {-1} }, -1,
-    { { 10, 40 }, {-1} } },
-
-  { { { 0, 50 }, { 20, 30 }, {-1} }, -1,
-    { { 0, 50 }, {-1} } },
-
-  { { { 10, 11 }, { 13, 14 }, { 16, 17 }, { 19, 20 }, { 22, 23 }, {-1} }, -1,
-    { { 10, 11 }, { 13, 14 }, { 16, 17 }, { 19, 20 }, { 22, 23 }, {-1} } },
-
-  { { { 13, 14 }, { 10, 11 }, { 22, 23 }, { 19, 20 }, { 16, 17 }, {-1} }, -1,
-    { { 10, 11 }, { 13, 14 }, { 16, 17 }, { 19, 20 }, { 22, 23 }, {-1} } },
-
-  { { { 13, 14 }, { 10, 11 }, { 22, 23 }, { 19, 20 }, { 16, 17 }, {-1} }, -1,
-    { { 10, 11 }, { 13, 14 }, { 16, 17 }, { 19, 20 }, { 22, 23 }, {-1} } },
-
-  { { { 13, 14 }, { 10, 11 }, { 22, 23 }, { 19, 20 }, { 16, 17 }, { 5, 25 }, {-1} }, -1,
-    { { 5, 25 }, {-1} } },
-
-  { { { 13, 14 }, { 10, 11 }, { 22, 23 }, { 19, 20 }, { 16, 17 }, { 12, 21 }, {-1} }, -1,
-    { { 10, 23 }, {-1} } },
-
-  // These check boundary cases during negation.
-  { { { 0, Runemax }, {-1} }, -1,
-    { { 0, Runemax }, {-1} } },
-
-  { { { 0, 50 }, {-1} }, -1,
-    { { 0, 50 }, {-1} } },
-
-  { { { 50, Runemax }, {-1} }, -1,
-    { { 50, Runemax }, {-1} } },
-
-  // Check RemoveAbove.
-  { { { 50, Runemax }, {-1} }, 255,
-    { { 50, 255 }, {-1} } },
-
-  { { { 50, Runemax }, {-1} }, 65535,
-    { { 50, 65535 }, {-1} } },
-
-  { { { 50, Runemax }, {-1} }, Runemax,
-    { { 50, Runemax }, {-1} } },
-
-  { { { 50, 60 }, { 250, 260 }, { 350, 360 }, {-1} }, 255,
-    { { 50, 60 }, { 250, 255 }, {-1} } },
-
-  { { { 50, 60 }, {-1} }, 255,
-    { { 50, 60 }, {-1} } },
-
-  { { { 350, 360 }, {-1} }, 255,
-    { {-1} } },
-
-  { { {-1} }, 255,
-    { {-1} } },
-};
-
-template <typename CharClass>
-static void Broke(const char *desc, const CCTest* t, CharClass* cc) {
-  if (t == NULL) {
-    absl::PrintF("\t%s:", desc);
-  } else {
-    absl::PrintF("\n");
-    absl::PrintF("CharClass added: [%s]", desc);
-    for (int k = 0; t->add[k].lo >= 0; k++)
-      absl::PrintF(" %d-%d", t->add[k].lo, t->add[k].hi);
-    absl::PrintF("\n");
-    if (t->remove >= 0)
-      absl::PrintF("Removed > %d\n", t->remove);
-    absl::PrintF("\twant:");
-    for (int k = 0; t->final[k].lo >= 0; k++)
-      absl::PrintF(" %d-%d", t->final[k].lo, t->final[k].hi);
-    absl::PrintF("\n");
-    absl::PrintF("\thave:");
-  }
-
-  for (typename CharClass::iterator it = cc->begin(); it != cc->end(); ++it)
-    absl::PrintF(" %d-%d", it->lo, it->hi);
-  absl::PrintF("\n");
-}
-
-bool ShouldContain(CCTest *t, int x) {
-  for (int j = 0; t->final[j].lo >= 0; j++)
-    if (t->final[j].lo <= x && x <= t->final[j].hi)
-      return true;
-  return false;
-}
-
-// Helpers to make templated CorrectCC work with both CharClass and CharClassBuilder.
-
-CharClass* Negate(CharClass *cc) {
-  return cc->Negate();
-}
-
-void Delete(CharClass* cc) {
-  cc->Delete();
-}
-
-CharClassBuilder* Negate(CharClassBuilder* cc) {
-  CharClassBuilder* ncc = cc->Copy();
-  ncc->Negate();
-  return ncc;
-}
-
-void Delete(CharClassBuilder* cc) {
-  delete cc;
-}
-
-template <typename CharClass>
-bool CorrectCC(CharClass *cc, CCTest *t, const char *desc) {
-  typename CharClass::iterator it = cc->begin();
-  int size = 0;
-  for (int j = 0; t->final[j].lo >= 0; j++, ++it) {
-    if (it == cc->end() ||
-        it->lo != t->final[j].lo ||
-        it->hi != t->final[j].hi) {
-      Broke(desc, t, cc);
-      return false;
-    }
-    size += it->hi - it->lo + 1;
-  }
-  if (it != cc->end()) {
-    Broke(desc, t, cc);
-    return false;
-  }
-  if (cc->size() != size) {
-    Broke(desc, t, cc);
-    absl::PrintF("wrong size: want %d have %d\n", size, cc->size());
-    return false;
-  }
-
-  for (int j = 0; j < 101; j++) {
-    if (j == 100)
-      j = Runemax;
-    if (ShouldContain(t, j) != cc->Contains(j)) {
-      Broke(desc, t, cc);
-      absl::PrintF("want contains(%d)=%d, got %d\n",
-                   j, ShouldContain(t, j), cc->Contains(j));
-      return false;
-    }
-  }
-
-  CharClass* ncc = Negate(cc);
-  for (int j = 0; j < 101; j++) {
-    if (j == 100)
-      j = Runemax;
-    if (ShouldContain(t, j) == ncc->Contains(j)) {
-      Broke(desc, t, cc);
-      Broke("ncc", NULL, ncc);
-      absl::PrintF("want ncc contains(%d)!=%d, got %d\n",
-                   j, ShouldContain(t, j), ncc->Contains(j));
-      Delete(ncc);
-      return false;
-    }
-    if (ncc->size() != Runemax+1 - cc->size()) {
-      Broke(desc, t, cc);
-      Broke("ncc", NULL, ncc);
-      absl::PrintF("ncc size should be %d is %d\n",
-                   Runemax+1 - cc->size(), ncc->size());
-      Delete(ncc);
-      return false;
-    }
-  }
-  Delete(ncc);
-  return true;
-}
-
-TEST(TestCharClassBuilder, Adds) {
-  int nfail = 0;
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(tests); i++) {
-    CharClassBuilder ccb;
-    CCTest* t = &tests[i];
-    for (int j = 0; t->add[j].lo >= 0; j++)
-      ccb.AddRange(t->add[j].lo, t->add[j].hi);
-    if (t->remove >= 0)
-      ccb.RemoveAbove(t->remove);
-    if (!CorrectCC(&ccb, t, "before copy (CharClassBuilder)"))
-      nfail++;
-    CharClass* cc = ccb.GetCharClass();
-    if (!CorrectCC(cc, t, "before copy (CharClass)"))
-      nfail++;
-    cc->Delete();
-
-    CharClassBuilder *ccb1 = ccb.Copy();
-    if (!CorrectCC(ccb1, t, "after copy (CharClassBuilder)"))
-      nfail++;
-    cc = ccb.GetCharClass();
-    if (!CorrectCC(cc, t, "after copy (CharClass)"))
-      nfail++;
-    cc->Delete();
-    delete ccb1;
-  }
-  EXPECT_EQ(nfail, 0);
-}
-
-}  // namespace re2