grpc 1.41.0.pre2 → 1.42.0

data/third_party/re2/re2/dfa.cc

@@ -56,6 +56,10 @@ namespace re2 {
 // Controls whether the DFA should bail out early if the NFA would be faster.
 static bool dfa_should_bail_when_slow = true;
 
+void Prog::TESTING_ONLY_set_dfa_should_bail_when_slow(bool b) {
+  dfa_should_bail_when_slow = b;
+}
+
 // Changing this to true compiles in prints that trace execution of the DFA.
 // Generates a lot of output -- only useful for debugging.
 static const bool ExtraDebug = false;
@@ -167,6 +171,9 @@ class DFA {
   typedef std::unordered_set<State*, StateHash, StateEqual> StateSet;
 
  private:
+  // Make it easier to swap in a scalable reader-writer mutex.
+  using CacheMutex = Mutex;
+
   enum {
     // Indices into start_ for unanchored searches.
     // Add kStartAnchored for anchored searches.
@@ -280,10 +287,10 @@ class DFA {
   // The generic search loop, inlined to create specialized versions.
   // cache_mutex_.r <= L < mutex_
   // Might unlock and relock cache_mutex_ via params->cache_lock.
-  inline bool InlinedSearchLoop(SearchParams* params,
-                                bool can_prefix_accel,
-                                bool want_earliest_match,
-                                bool run_forward);
+  template <bool can_prefix_accel,
+            bool want_earliest_match,
+            bool run_forward>
+  inline bool InlinedSearchLoop(SearchParams* params);
 
   // The specialized versions of InlinedSearchLoop.  The three letters
   // at the ends of the name denote the true/false values used as the
@@ -305,13 +312,6 @@ class DFA {
   // Might unlock and relock cache_mutex_ via params->cache_lock.
   bool FastSearchLoop(SearchParams* params);
 
-  // For debugging, a slow search loop that calls InlinedSearchLoop
-  // directly -- because the booleans passed are not constants, the
-  // loop is not specialized like the SearchFFF etc. versions, so it
-  // runs much more slowly.  Useful only for debugging.
-  // cache_mutex_.r <= L < mutex_
-  // Might unlock and relock cache_mutex_ via params->cache_lock.
-  bool SlowSearchLoop(SearchParams* params);
 
   // Looks up bytes in bytemap_ but handles case c == kByteEndText too.
   int ByteMap(int c) {
@@ -338,7 +338,7 @@ class DFA {
   // while holding cache_mutex_ for writing, to avoid interrupting other
   // readers.  Any State* pointers are only valid while cache_mutex_
   // is held.
-  Mutex cache_mutex_;
+  CacheMutex cache_mutex_;
   int64_t mem_budget_;     // Total memory budget for all States.
   int64_t state_budget_;   // Amount of memory remaining for new States.
   StateSet state_cache_;   // All States computed so far.
@@ -1113,7 +1113,7 @@ DFA::State* DFA::RunStateOnByte(State* state, int c) {
 
 class DFA::RWLocker {
  public:
-  explicit RWLocker(Mutex* mu);
+  explicit RWLocker(CacheMutex* mu);
   ~RWLocker();
 
   // If the lock is only held for reading right now,
@@ -1123,14 +1123,14 @@ class DFA::RWLocker {
   void LockForWriting();
 
  private:
-  Mutex* mu_;
+  CacheMutex* mu_;
   bool writing_;
 
   RWLocker(const RWLocker&) = delete;
   RWLocker& operator=(const RWLocker&) = delete;
 };
 
-DFA::RWLocker::RWLocker(Mutex* mu) : mu_(mu), writing_(false) {
+DFA::RWLocker::RWLocker(CacheMutex* mu) : mu_(mu), writing_(false) {
   mu_->ReaderLock();
 }
 
@@ -1321,10 +1321,10 @@ DFA::State* DFA::StateSaver::Restore() {
 // The bools are equal to the same-named variables in params, but
 // making them function arguments lets the inliner specialize
 // this function to each combination (see two paragraphs above).
-inline bool DFA::InlinedSearchLoop(SearchParams* params,
-                                   bool can_prefix_accel,
-                                   bool want_earliest_match,
-                                   bool run_forward) {
+template <bool can_prefix_accel,
+          bool want_earliest_match,
+          bool run_forward>
+inline bool DFA::InlinedSearchLoop(SearchParams* params) {
   State* start = params->start;
   const uint8_t* bp = BytePtr(params->text.data());  // start of text
   const uint8_t* p = bp;                             // text scanning point
@@ -1549,36 +1549,28 @@ inline bool DFA::InlinedSearchLoop(SearchParams* params,
 
 // Inline specializations of the general loop.
 bool DFA::SearchFFF(SearchParams* params) {
-  return InlinedSearchLoop(params, 0, 0, 0);
+  return InlinedSearchLoop<false, false, false>(params);
 }
 bool DFA::SearchFFT(SearchParams* params) {
-  return InlinedSearchLoop(params, 0, 0, 1);
+  return InlinedSearchLoop<false, false, true>(params);
 }
 bool DFA::SearchFTF(SearchParams* params) {
-  return InlinedSearchLoop(params, 0, 1, 0);
+  return InlinedSearchLoop<false, true, false>(params);
 }
 bool DFA::SearchFTT(SearchParams* params) {
-  return InlinedSearchLoop(params, 0, 1, 1);
+  return InlinedSearchLoop<false, true, true>(params);
 }
 bool DFA::SearchTFF(SearchParams* params) {
-  return InlinedSearchLoop(params, 1, 0, 0);
+  return InlinedSearchLoop<true, false, false>(params);
 }
 bool DFA::SearchTFT(SearchParams* params) {
-  return InlinedSearchLoop(params, 1, 0, 1);
+  return InlinedSearchLoop<true, false, true>(params);
 }
 bool DFA::SearchTTF(SearchParams* params) {
-  return InlinedSearchLoop(params, 1, 1, 0);
+  return InlinedSearchLoop<true, true, false>(params);
 }
 bool DFA::SearchTTT(SearchParams* params) {
-  return InlinedSearchLoop(params, 1, 1, 1);
-}
-
-// For debugging, calls the general code directly.
-bool DFA::SlowSearchLoop(SearchParams* params) {
-  return InlinedSearchLoop(params,
-                           params->can_prefix_accel,
-                           params->want_earliest_match,
-                           params->run_forward);
+  return InlinedSearchLoop<true, true, true>(params);
 }
 
 // For performance, calls the appropriate specialized version
@@ -1978,10 +1970,6 @@ int Prog::BuildEntireDFA(MatchKind kind, const DFAStateCallback& cb) {
   return GetDFA(kind)->BuildAllStates(cb);
 }
 
-void Prog::TEST_dfa_should_bail_when_slow(bool b) {
-  dfa_should_bail_when_slow = b;
-}
-
 // Computes min and max for matching string.
 // Won't return strings bigger than maxlen.
 bool DFA::PossibleMatchRange(std::string* min, std::string* max, int maxlen) {

data/third_party/re2/re2/filtered_re2.cc

@@ -6,6 +6,7 @@
 
 #include <stddef.h>
 #include <string>
+#include <utility>
 
 #include "util/util.h"
 #include "util/logging.h"
@@ -27,7 +28,22 @@ FilteredRE2::FilteredRE2(int min_atom_len)
 FilteredRE2::~FilteredRE2() {
   for (size_t i = 0; i < re2_vec_.size(); i++)
     delete re2_vec_[i];
-  delete prefilter_tree_;
+}
+
+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(const StringPiece& pattern,
@@ -38,7 +54,7 @@ RE2::ErrorCode FilteredRE2::Add(const StringPiece& pattern,
   if (!re->ok()) {
     if (options.log_errors()) {
       LOG(ERROR) << "Couldn't compile regular expression, skipping: "
-                 << re << " due to error " << re->error();
+                 << pattern << " due to error " << re->error();
     }
     delete re;
   } else {

data/third_party/re2/re2/filtered_re2.h

@@ -21,6 +21,7 @@
 // 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>
 
@@ -36,12 +37,19 @@ class 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(const StringPiece& pattern,
                      const RE2::Options& options,
-                     int *id);
+                     int* id);
 
   // Prepares the regexps added by Add for filtering.  Returns a set
   // of strings that the caller should check for in candidate texts.
@@ -98,10 +106,7 @@ class FilteredRE2 {
   bool compiled_;
 
   // An AND-OR tree of string atoms used for filtering regexps.
-  PrefilterTree* prefilter_tree_;
-
-  FilteredRE2(const FilteredRE2&) = delete;
-  FilteredRE2& operator=(const FilteredRE2&) = delete;
+  std::unique_ptr<PrefilterTree> prefilter_tree_;
 };
 
 }  // namespace re2

data/third_party/re2/re2/nfa.cc

@@ -600,7 +600,7 @@ bool NFA::Search(const StringPiece& text, const StringPiece& const_context,
     // by simply not continuing the loop.
     // This complements the special case in NFA::Step().
     if (p == NULL) {
-      (void)Step(runq, nextq, p < etext_ ? p[0] & 0xFF : -1, context, p);
+      (void) Step(runq, nextq, -1, context, p);
       DCHECK_EQ(runq->size(), 0);
       using std::swap;
       swap(nextq, runq);

data/third_party/re2/re2/parse.cc

@@ -44,12 +44,12 @@
 
 namespace re2 {
 
-// Reduce the maximum repeat count by an order of magnitude when fuzzing.
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-static const int kMaxRepeat = 100;
-#else
-static const int kMaxRepeat = 1000;
-#endif
+// Controls the maximum repeat count permitted by the parser.
+static int maximum_repeat_count = 1000;
+
+void Regexp::FUZZING_ONLY_set_maximum_repeat_count(int i) {
+  maximum_repeat_count = i;
+}
 
 // Regular expression parse state.
 // The list of parsed regexps so far is maintained as a vector of
@@ -568,7 +568,9 @@ int RepetitionWalker::ShortVisit(Regexp* re, int parent_arg) {
 bool Regexp::ParseState::PushRepetition(int min, int max,
                                         const StringPiece& s,
                                         bool nongreedy) {
-  if ((max != -1 && max < min) || min > kMaxRepeat || max > kMaxRepeat) {
+  if ((max != -1 && max < min) ||
+      min > maximum_repeat_count ||
+      max > maximum_repeat_count) {
     status_->set_code(kRegexpRepeatSize);
     status_->set_error_arg(s);
     return false;
@@ -591,7 +593,7 @@ bool Regexp::ParseState::PushRepetition(int min, int max,
   stacktop_ = re;
   if (min >= 2 || max >= 2) {
     RepetitionWalker w;
-    if (w.Walk(stacktop_, kMaxRepeat) == 0) {
+    if (w.Walk(stacktop_, maximum_repeat_count) == 0) {
       status_->set_code(kRegexpRepeatSize);
       status_->set_error_arg(s);
       return false;
@@ -685,7 +687,7 @@ bool Regexp::ParseState::DoRightParen() {
   if ((r1 = stacktop_) == NULL ||
       (r2 = r1->down_) == NULL ||
       r2->op() != kLeftParen) {
-    status_->set_code(kRegexpMissingParen);
+    status_->set_code(kRegexpUnexpectedParen);
     status_->set_error_arg(whole_regexp_);
     return false;
   }
@@ -1407,13 +1409,15 @@ static int StringPieceToRune(Rune *r, StringPiece *sp, RegexpStatus* status) {
     }
   }
 
-  status->set_code(kRegexpBadUTF8);
-  status->set_error_arg(StringPiece());
+  if (status != NULL) {
+    status->set_code(kRegexpBadUTF8);
+    status->set_error_arg(StringPiece());
+  }
   return -1;
 }
 
-// Return whether name is valid UTF-8.
-// If not, set status to kRegexpBadUTF8.
+// Returns whether name is valid UTF-8.
+// If not, sets status to kRegexpBadUTF8.
 static bool IsValidUTF8(const StringPiece& s, RegexpStatus* status) {
   StringPiece t = s;
   Rune r;
@@ -2011,19 +2015,34 @@ bool Regexp::ParseState::ParseCharClass(StringPiece* s,
   return true;
 }
 
-// Is this a valid capture name?  [A-Za-z0-9_]+
-// PCRE limits names to 32 bytes.
-// Python rejects names starting with digits.
-// We don't enforce either of those.
+// Returns whether name is a valid capture name.
 static bool IsValidCaptureName(const StringPiece& name) {
   if (name.empty())
     return false;
-  for (size_t i = 0; i < name.size(); i++) {
-    int c = name[i];
-    if (('0' <= c && c <= '9') ||
-        ('a' <= c && c <= 'z') ||
-        ('A' <= c && c <= 'Z') ||
-        c == '_')
+
+  // Historically, we effectively used [0-9A-Za-z_]+ to validate; that
+  // followed Python 2 except for not restricting the first character.
+  // As of Python 3, Unicode characters beyond ASCII are also allowed;
+  // accordingly, we permit the Lu, Ll, Lt, Lm, Lo, Nl, Mn, Mc, Nd and
+  // Pc categories, but again without restricting the first character.
+  // Also, Unicode normalization (e.g. NFKC) isn't performed: Python 3
+  // performs it for identifiers, but seemingly not for capture names;
+  // if they start doing that for capture names, we won't follow suit.
+  static const CharClass* const cc = []() {
+    CharClassBuilder ccb;
+    for (StringPiece group :
+         {"Lu", "Ll", "Lt", "Lm", "Lo", "Nl", "Mn", "Mc", "Nd", "Pc"})
+      AddUGroup(&ccb, LookupGroup(group, unicode_groups, num_unicode_groups),
+                +1, Regexp::NoParseFlags);
+    return ccb.GetCharClass();
+  }();
+
+  StringPiece t = name;
+  Rune r;
+  while (!t.empty()) {
+    if (StringPieceToRune(&r, &t, NULL) < 0)
+      return false;
+    if (cc->Contains(r))
       continue;
     return false;
   }

data/third_party/re2/re2/perl_groups.cc

@@ -20,12 +20,12 @@ static const URange16 code3[] = {  /* \w */
 	{ 0x61, 0x7a },
 };
 const UGroup perl_groups[] = {
-	{ "\\d", +1, code1, 1 },
-	{ "\\D", -1, code1, 1 },
-	{ "\\s", +1, code2, 3 },
-	{ "\\S", -1, code2, 3 },
-	{ "\\w", +1, code3, 4 },
-	{ "\\W", -1, code3, 4 },
+	{ "\\d", +1, code1, 1, 0, 0 },
+	{ "\\D", -1, code1, 1, 0, 0 },
+	{ "\\s", +1, code2, 3, 0, 0 },
+	{ "\\S", -1, code2, 3, 0, 0 },
+	{ "\\w", +1, code3, 4, 0, 0 },
+	{ "\\W", -1, code3, 4, 0, 0 },
 };
 const int num_perl_groups = 6;
 static const URange16 code4[] = {  /* [:alnum:] */
@@ -85,34 +85,34 @@ static const URange16 code17[] = {  /* [:xdigit:] */
 	{ 0x61, 0x66 },
 };
 const UGroup posix_groups[] = {
-	{ "[:alnum:]", +1, code4, 3 },
-	{ "[:^alnum:]", -1, code4, 3 },
-	{ "[:alpha:]", +1, code5, 2 },
-	{ "[:^alpha:]", -1, code5, 2 },
-	{ "[:ascii:]", +1, code6, 1 },
-	{ "[:^ascii:]", -1, code6, 1 },
-	{ "[:blank:]", +1, code7, 2 },
-	{ "[:^blank:]", -1, code7, 2 },
-	{ "[:cntrl:]", +1, code8, 2 },
-	{ "[:^cntrl:]", -1, code8, 2 },
-	{ "[:digit:]", +1, code9, 1 },
-	{ "[:^digit:]", -1, code9, 1 },
-	{ "[:graph:]", +1, code10, 1 },
-	{ "[:^graph:]", -1, code10, 1 },
-	{ "[:lower:]", +1, code11, 1 },
-	{ "[:^lower:]", -1, code11, 1 },
-	{ "[:print:]", +1, code12, 1 },
-	{ "[:^print:]", -1, code12, 1 },
-	{ "[:punct:]", +1, code13, 4 },
-	{ "[:^punct:]", -1, code13, 4 },
-	{ "[:space:]", +1, code14, 2 },
-	{ "[:^space:]", -1, code14, 2 },
-	{ "[:upper:]", +1, code15, 1 },
-	{ "[:^upper:]", -1, code15, 1 },
-	{ "[:word:]", +1, code16, 4 },
-	{ "[:^word:]", -1, code16, 4 },
-	{ "[:xdigit:]", +1, code17, 3 },
-	{ "[:^xdigit:]", -1, code17, 3 },
+	{ "[:alnum:]", +1, code4, 3, 0, 0 },
+	{ "[:^alnum:]", -1, code4, 3, 0, 0 },
+	{ "[:alpha:]", +1, code5, 2, 0, 0 },
+	{ "[:^alpha:]", -1, code5, 2, 0, 0 },
+	{ "[:ascii:]", +1, code6, 1, 0, 0 },
+	{ "[:^ascii:]", -1, code6, 1, 0, 0 },
+	{ "[:blank:]", +1, code7, 2, 0, 0 },
+	{ "[:^blank:]", -1, code7, 2, 0, 0 },
+	{ "[:cntrl:]", +1, code8, 2, 0, 0 },
+	{ "[:^cntrl:]", -1, code8, 2, 0, 0 },
+	{ "[:digit:]", +1, code9, 1, 0, 0 },
+	{ "[:^digit:]", -1, code9, 1, 0, 0 },
+	{ "[:graph:]", +1, code10, 1, 0, 0 },
+	{ "[:^graph:]", -1, code10, 1, 0, 0 },
+	{ "[:lower:]", +1, code11, 1, 0, 0 },
+	{ "[:^lower:]", -1, code11, 1, 0, 0 },
+	{ "[:print:]", +1, code12, 1, 0, 0 },
+	{ "[:^print:]", -1, code12, 1, 0, 0 },
+	{ "[:punct:]", +1, code13, 4, 0, 0 },
+	{ "[:^punct:]", -1, code13, 4, 0, 0 },
+	{ "[:space:]", +1, code14, 2, 0, 0 },
+	{ "[:^space:]", -1, code14, 2, 0, 0 },
+	{ "[:upper:]", +1, code15, 1, 0, 0 },
+	{ "[:^upper:]", -1, code15, 1, 0, 0 },
+	{ "[:word:]", +1, code16, 4, 0, 0 },
+	{ "[:^word:]", -1, code16, 4, 0, 0 },
+	{ "[:xdigit:]", +1, code17, 3, 0, 0 },
+	{ "[:^xdigit:]", -1, code17, 3, 0, 0 },
 };
 const int num_posix_groups = 28;
 

data/third_party/re2/re2/prefilter.cc

@@ -648,14 +648,15 @@ Prefilter* Prefilter::FromRegexp(Regexp* re) {
     return NULL;
 
   Regexp* simple = re->Simplify();
-  Prefilter::Info *info = BuildInfo(simple);
+  if (simple == NULL)
+    return NULL;
 
+  Prefilter::Info* info = BuildInfo(simple);
   simple->Decref();
   if (info == NULL)
     return NULL;
 
   Prefilter* m = info->TakeMatch();
-
   delete info;
   return m;
 }