grpc 1.46.3 → 1.53.1

data/third_party/re2/re2/prefilter_tree.cc

@@ -8,7 +8,6 @@
 #include <algorithm>
 #include <map>
 #include <memory>
-#include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ -36,9 +35,6 @@ PrefilterTree::PrefilterTree(int min_atom_len)
 PrefilterTree::~PrefilterTree() {
   for (size_t i = 0; i < prefilter_vec_.size(); i++)
     delete prefilter_vec_[i];
-
-  for (size_t i = 0; i < entries_.size(); i++)
-    delete entries_[i].parents;
 }
 
 void PrefilterTree::Add(Prefilter* prefilter) {
@@ -67,7 +63,6 @@ void PrefilterTree::Compile(std::vector<std::string>* atom_vec) {
 
   compiled_ = true;
 
-  // TODO(junyer): Use std::unordered_set<Prefilter*> instead?
   NodeMap nodes;
   AssignUniqueIds(&nodes, atom_vec);
 
@@ -78,25 +73,21 @@ void PrefilterTree::Compile(std::vector<std::string>* atom_vec) {
   // not miss out on any regexps triggering by getting rid of a
   // prefilter node.
   for (size_t i = 0; i < entries_.size(); i++) {
-    StdIntMap* parents = entries_[i].parents;
-    if (parents->size() > 8) {
+    std::vector<int>& parents = entries_[i].parents;
+    if (parents.size() > 8) {
       // This one triggers too many things. If all the parents are AND
       // nodes and have other things guarding them, then get rid of
       // this trigger. TODO(vsri): Adjust the threshold appropriately,
       // make it a function of total number of nodes?
       bool have_other_guard = true;
-      for (StdIntMap::iterator it = parents->begin();
-           it != parents->end(); ++it) {
+      for (int parent : parents) {
         have_other_guard = have_other_guard &&
-            (entries_[it->first].propagate_up_at_count > 1);
+            (entries_[parent].propagate_up_at_count > 1);
       }
-
       if (have_other_guard) {
-        for (StdIntMap::iterator it = parents->begin();
-             it != parents->end(); ++it)
-          entries_[it->first].propagate_up_at_count -= 1;
-
-        parents->clear();  // Forget the parents
+        for (int parent : parents)
+          entries_[parent].propagate_up_at_count -= 1;
+        parents.clear();  // Forget the parents
       }
     }
   }
@@ -217,20 +208,7 @@ void PrefilterTree::AssignUniqueIds(NodeMap* nodes,
       node->set_unique_id(canonical->unique_id());
     }
   }
-  entries_.resize(nodes->size());
-
-  // Create parent StdIntMap for the entries.
-  for (int i = static_cast<int>(v.size()) - 1; i >= 0; i--) {
-    Prefilter* prefilter = v[i];
-    if (prefilter == NULL)
-      continue;
-
-    if (CanonicalNode(nodes, prefilter) != prefilter)
-      continue;
-
-    Entry* entry = &entries_[prefilter->unique_id()];
-    entry->parents = new StdIntMap();
-  }
+  entries_.resize(unique_id);
 
   // Fill the entries.
   for (int i = static_cast<int>(v.size()) - 1; i >= 0; i--) {
@@ -241,41 +219,34 @@ void PrefilterTree::AssignUniqueIds(NodeMap* nodes,
     if (CanonicalNode(nodes, prefilter) != prefilter)
       continue;
 
-    Entry* entry = &entries_[prefilter->unique_id()];
+    int id = prefilter->unique_id();
 
     switch (prefilter->op()) {
       default:
-      case Prefilter::ALL:
         LOG(DFATAL) << "Unexpected op: " << prefilter->op();
         return;
 
       case Prefilter::ATOM:
-        entry->propagate_up_at_count = 1;
+        entries_[id].propagate_up_at_count = 1;
         break;
 
       case Prefilter::OR:
       case Prefilter::AND: {
-        std::set<int> uniq_child;
+        // For each child, we append our id to the child's list of
+        // parent ids... unless we happen to have done so already.
+        // The number of appends is the number of unique children,
+        // which allows correct upward propagation from AND nodes.
+        int up_count = 0;
         for (size_t j = 0; j < prefilter->subs()->size(); j++) {
-          Prefilter* child = (*prefilter->subs())[j];
-          Prefilter* canonical = CanonicalNode(nodes, child);
-          if (canonical == NULL) {
-            LOG(DFATAL) << "Null canonical node";
-            return;
-          }
-          int child_id = canonical->unique_id();
-          uniq_child.insert(child_id);
-          // To the child, we want to add to parent indices.
-          Entry* child_entry = &entries_[child_id];
-          if (child_entry->parents->find(prefilter->unique_id()) ==
-              child_entry->parents->end()) {
-            (*child_entry->parents)[prefilter->unique_id()] = 1;
+          int child_id = (*prefilter->subs())[j]->unique_id();
+          std::vector<int>& parents = entries_[child_id].parents;
+          if (parents.empty() || parents.back() != id) {
+            parents.push_back(id);
+            up_count++;
           }
         }
-        entry->propagate_up_at_count = prefilter->op() == Prefilter::AND
-                                           ? static_cast<int>(uniq_child.size())
-                                           : 1;
-
+        entries_[id].propagate_up_at_count =
+            prefilter->op() == Prefilter::AND ? up_count : 1;
         break;
       }
     }
@@ -336,10 +307,7 @@ void PrefilterTree::PropagateMatch(const std::vector<int>& atom_ids,
       regexps->set(entry.regexps[i], 1);
     int c;
     // Pass trigger up to parents.
-    for (StdIntMap::iterator it = entry.parents->begin();
-         it != entry.parents->end();
-         ++it) {
-      int j = it->first;
+    for (int j : entry.parents) {
       const Entry& parent = entries_[j];
       // Delay until all the children have succeeded.
       if (parent.propagate_up_at_count > 1) {
@@ -369,12 +337,12 @@ void PrefilterTree::PrintDebugInfo(NodeMap* nodes) {
   LOG(ERROR) << "#Unique Nodes: " << entries_.size();
 
   for (size_t i = 0; i < entries_.size(); i++) {
-    StdIntMap* parents = entries_[i].parents;
+    const std::vector<int>& parents = entries_[i].parents;
     const std::vector<int>& regexps = entries_[i].regexps;
     LOG(ERROR) << "EntryId: " << i
-               << " N: " << parents->size() << " R: " << regexps.size();
-    for (StdIntMap::iterator it = parents->begin(); it != parents->end(); ++it)
-      LOG(ERROR) << it->first;
+               << " N: " << parents.size() << " R: " << regexps.size();
+    for (int parent : parents)
+      LOG(ERROR) << parent;
   }
   LOG(ERROR) << "Map:";
   for (NodeMap::const_iterator iter = nodes->begin();

data/third_party/re2/re2/prefilter_tree.h

@@ -59,7 +59,8 @@ class PrefilterTree {
 
  private:
   typedef SparseArray<int> IntMap;
-  typedef std::map<int, int> StdIntMap;
+  // TODO(junyer): Use std::unordered_set<Prefilter*> instead?
+  // It should be trivial to get rid of the stringification...
   typedef std::map<std::string, Prefilter*> NodeMap;
 
   // Each unique node has a corresponding Entry that helps in
@@ -77,7 +78,7 @@ class PrefilterTree {
     // are two different nodes, but they share the atom 'def'. So when
     // 'def' matches, it triggers two parents, corresponding to the two
     // different OR nodes.
-    StdIntMap* parents;
+    std::vector<int> parents;
 
     // When this node is ready to trigger the parent, what are the
     // regexps that are triggered.

data/third_party/re2/re2/prog.cc

@@ -118,6 +118,7 @@ Prog::Prog()
     prefix_foldcase_(false),
     prefix_size_(0),
     list_count_(0),
+    bit_state_text_max_size_(0),
     dfa_mem_(0),
     dfa_first_(NULL),
     dfa_longest_(NULL) {
@@ -610,10 +611,13 @@ void Prog::Flatten() {
     inst_count_[ip->opcode()]++;
   }
 
-  int total = 0;
+#if !defined(NDEBUG)
+  // Address a `-Wunused-but-set-variable' warning from Clang 13.x.
+  size_t total = 0;
   for (int i = 0; i < kNumInst; i++)
     total += inst_count_[i];
-  DCHECK_EQ(total, static_cast<int>(flat.size()));
+  CHECK_EQ(total, flat.size());
+#endif
 
   // Remap start_unanchored and start.
   if (start_unanchored() == 0) {
@@ -640,6 +644,11 @@ void Prog::Flatten() {
     for (int i = 0; i < list_count_; ++i)
       list_heads_[flatmap[i]] = i;
   }
+
+  // BitState allocates a bitmap of size list_count_ * (text.size()+1)
+  // for tracking pairs of possibilities that it has already explored.
+  const size_t kBitStateBitmapMaxSize = 256*1024;  // max size in bits
+  bit_state_text_max_size_ = kBitStateBitmapMaxSize / list_count_ - 1;
 }
 
 void Prog::MarkSuccessors(SparseArray<int>* rootmap,

data/third_party/re2/re2/prog.h

@@ -207,6 +207,7 @@ class Prog {
   int list_count() { return list_count_; }
   int inst_count(InstOp op) { return inst_count_[op]; }
   uint16_t* list_heads() { return list_heads_.data(); }
+  size_t bit_state_text_max_size() { return bit_state_text_max_size_; }
   int64_t dfa_mem() { return dfa_mem_; }
   void set_dfa_mem(int64_t dfa_mem) { dfa_mem_ = dfa_mem; }
   bool anchor_start() { return anchor_start_; }
@@ -360,7 +361,6 @@ class Prog {
   // Returns true on success, false on error.
   bool PossibleMatchRange(std::string* min, std::string* max, int maxlen);
 
-  // EXPERIMENTAL! SUBJECT TO CHANGE!
   // Outputs the program fanout into the given sparse array.
   void Fanout(SparseArray<int>* fanout);
 
@@ -429,10 +429,11 @@ class Prog {
     };
   };
 
-  int list_count_;                 // count of lists (see above)
-  int inst_count_[kNumInst];       // count of instructions by opcode
-  PODArray<uint16_t> list_heads_;  // sparse array enumerating list heads
-                                   // not populated if size_ is overly large
+  int list_count_;                  // count of lists (see above)
+  int inst_count_[kNumInst];        // count of instructions by opcode
+  PODArray<uint16_t> list_heads_;   // sparse array enumerating list heads
+                                    // not populated if size_ is overly large
+  size_t bit_state_text_max_size_;  // upper bound (inclusive) on text.size()
 
   PODArray<Inst> inst_;              // pointer to instruction array
   PODArray<uint8_t> onepass_nodes_;  // data for OnePass nodes
@@ -450,6 +451,17 @@ class Prog {
   Prog& operator=(const Prog&) = delete;
 };
 
+// std::string_view in MSVC has iterators that aren't just pointers and
+// that don't allow comparisons between different objects - not even if
+// those objects are views into the same string! Thus, we provide these
+// conversion functions for convenience.
+static inline const char* BeginPtr(const StringPiece& s) {
+  return s.data();
+}
+static inline const char* EndPtr(const StringPiece& s) {
+  return s.data() + s.size();
+}
+
 }  // namespace re2
 
 #endif  // RE2_PROG_H_

data/third_party/re2/re2/re2.cc

@@ -690,15 +690,9 @@ bool RE2::Match(const StringPiece& text,
   if (options_.longest_match())
     kind = Prog::kLongestMatch;
 
-  bool can_one_pass = (is_one_pass_ && ncap <= Prog::kMaxOnePassCapture);
-
-  // BitState allocates a bitmap of size prog_->list_count() * text.size().
-  // It also allocates a stack of 3-word structures which could potentially
-  // grow as large as prog_->list_count() * text.size(), but in practice is
-  // much smaller.
-  const int kMaxBitStateBitmapSize = 256*1024;  // bitmap size <= max (bits)
+  bool can_one_pass = is_one_pass_ && ncap <= Prog::kMaxOnePassCapture;
   bool can_bit_state = prog_->CanBitState();
-  size_t bit_state_text_max = kMaxBitStateBitmapSize / prog_->list_count();
+  size_t bit_state_text_max_size = prog_->bit_state_text_max_size();
 
 #ifdef RE2_HAVE_THREAD_LOCAL
   hooks::context = this;
@@ -805,7 +799,8 @@ bool RE2::Match(const StringPiece& text,
         skipped_test = true;
         break;
       }
-      if (can_bit_state && text.size() <= bit_state_text_max && ncap > 1) {
+      if (can_bit_state && text.size() <= bit_state_text_max_size &&
+          ncap > 1) {
         skipped_test = true;
         break;
       }
@@ -852,7 +847,7 @@ bool RE2::Match(const StringPiece& text,
           LOG(ERROR) << "SearchOnePass inconsistency";
         return false;
       }
-    } else if (can_bit_state && subtext1.size() <= bit_state_text_max) {
+    } else if (can_bit_state && subtext1.size() <= bit_state_text_max_size) {
       if (!prog_->SearchBitState(subtext1, text, anchor,
                                  kind, submatch, ncap)) {
         if (!skipped_test && options_.log_errors())
@@ -920,7 +915,7 @@ bool RE2::DoMatch(const StringPiece& text,
   }
 
   if (consumed != NULL)
-    *consumed = static_cast<size_t>(vec[0].end() - text.begin());
+    *consumed = static_cast<size_t>(EndPtr(vec[0]) - BeginPtr(text));
 
   if (n == 0 || args == NULL) {
     // We are not interested in results

data/third_party/re2/re2/re2.h

@@ -971,7 +971,7 @@ namespace hooks {
 // As per https://github.com/google/re2/issues/325, thread_local support in
 // MinGW seems to be buggy. (FWIW, Abseil folks also avoid it.)
 #define RE2_HAVE_THREAD_LOCAL
-#if (defined(__APPLE__) && !TARGET_OS_OSX) || defined(__MINGW32__)
+#if (defined(__APPLE__) && !(defined(TARGET_OS_OSX) && TARGET_OS_OSX)) || defined(__MINGW32__)
 #undef RE2_HAVE_THREAD_LOCAL
 #endif
 

data/third_party/re2/re2/regexp.cc

@@ -585,8 +585,7 @@ class NamedCapturesWalker : public Regexp::Walker<Ignored> {
       // Record first occurrence of each name.
       // (The rule is that if you have the same name
       // multiple times, only the leftmost one counts.)
-      if (map_->find(*re->name()) == map_->end())
-        (*map_)[*re->name()] = re->cap();
+      map_->insert({*re->name(), re->cap()});
     }
     return ignored;
   }

data/third_party/re2/re2/stringpiece.h

@@ -19,18 +19,13 @@
 //
 // Arghh!  I wish C++ literals were "string".
 
-// Doing this simplifies the logic below.
-#ifndef __has_include
-#define __has_include(x) 0
-#endif
-
 #include <stddef.h>
 #include <string.h>
 #include <algorithm>
 #include <iosfwd>
 #include <iterator>
 #include <string>
-#if __has_include(<string_view>) && __cplusplus >= 201703L
+#ifdef __cpp_lib_string_view
 #include <string_view>
 #endif
 
@@ -57,7 +52,7 @@ class StringPiece {
   // expected.
   StringPiece()
       : data_(NULL), size_(0) {}
-#if __has_include(<string_view>) && __cplusplus >= 201703L
+#ifdef __cpp_lib_string_view
   StringPiece(const std::string_view& str)
       : data_(str.data()), size_(str.size()) {}
 #endif
@@ -103,6 +98,14 @@ class StringPiece {
     size_ = len;
   }
 
+#ifdef __cpp_lib_string_view
+  // Converts to `std::basic_string_view`.
+  operator std::basic_string_view<char, traits_type>() const {
+    if (!data_) return {};
+    return std::basic_string_view<char, traits_type>(data_, size_);
+  }
+#endif
+
   // Converts to `std::basic_string`.
   template <typename A>
   explicit operator std::basic_string<char, traits_type, A>() const {

data/third_party/re2/re2/unicode_casefold.cc

@@ -7,7 +7,7 @@
 namespace re2 {
 
 
-// 1384 groups, 2798 pairs, 358 ranges
+// 1424 groups, 2878 pairs, 367 ranges
 const CaseFold unicode_casefold[] = {
 	{ 65, 90, 32 },
 	{ 97, 106, -32 },
@@ -299,8 +299,8 @@ const CaseFold unicode_casefold[] = {
 	{ 8579, 8580, OddEven },
 	{ 9398, 9423, 26 },
 	{ 9424, 9449, -26 },
-	{ 11264, 11310, 48 },
-	{ 11312, 11358, -48 },
+	{ 11264, 11311, 48 },
+	{ 11312, 11359, -48 },
 	{ 11360, 11361, EvenOdd },
 	{ 11362, 11362, -10743 },
 	{ 11363, 11363, -3814 },
@@ -344,12 +344,13 @@ const CaseFold unicode_casefold[] = {
 	{ 42929, 42929, -42282 },
 	{ 42930, 42930, -42261 },
 	{ 42931, 42931, 928 },
-	{ 42932, 42943, EvenOdd },
-	{ 42946, 42947, EvenOdd },
+	{ 42932, 42947, EvenOdd },
 	{ 42948, 42948, -48 },
 	{ 42949, 42949, -42307 },
 	{ 42950, 42950, -35384 },
 	{ 42951, 42954, OddEven },
+	{ 42960, 42961, EvenOdd },
+	{ 42966, 42969, EvenOdd },
 	{ 42997, 42998, OddEven },
 	{ 43859, 43859, -928 },
 	{ 43888, 43967, -38864 },
@@ -359,6 +360,14 @@ const CaseFold unicode_casefold[] = {
 	{ 66600, 66639, -40 },
 	{ 66736, 66771, 40 },
 	{ 66776, 66811, -40 },
+	{ 66928, 66938, 39 },
+	{ 66940, 66954, 39 },
+	{ 66956, 66962, 39 },
+	{ 66964, 66965, 39 },
+	{ 66967, 66977, -39 },
+	{ 66979, 66993, -39 },
+	{ 66995, 67001, -39 },
+	{ 67003, 67004, -39 },
 	{ 68736, 68786, 64 },
 	{ 68800, 68850, -64 },
 	{ 71840, 71871, 32 },
@@ -368,9 +377,9 @@ const CaseFold unicode_casefold[] = {
 	{ 125184, 125217, 34 },
 	{ 125218, 125251, -34 },
 };
-const int num_unicode_casefold = 358;
+const int num_unicode_casefold = 367;
 
-// 1384 groups, 1414 pairs, 200 ranges
+// 1424 groups, 1454 pairs, 205 ranges
 const CaseFold unicode_tolower[] = {
 	{ 65, 90, 32 },
 	{ 181, 181, 775 },
@@ -521,7 +530,7 @@ const CaseFold unicode_tolower[] = {
 	{ 8544, 8559, 16 },
 	{ 8579, 8579, OddEven },
 	{ 9398, 9423, 26 },
-	{ 11264, 11310, 48 },
+	{ 11264, 11311, 48 },
 	{ 11360, 11360, EvenOdd },
 	{ 11362, 11362, -10743 },
 	{ 11363, 11363, -3814 },
@@ -557,23 +566,28 @@ const CaseFold unicode_tolower[] = {
 	{ 42929, 42929, -42282 },
 	{ 42930, 42930, -42261 },
 	{ 42931, 42931, 928 },
-	{ 42932, 42942, EvenOddSkip },
-	{ 42946, 42946, EvenOdd },
+	{ 42932, 42946, EvenOddSkip },
 	{ 42948, 42948, -48 },
 	{ 42949, 42949, -42307 },
 	{ 42950, 42950, -35384 },
 	{ 42951, 42953, OddEvenSkip },
+	{ 42960, 42960, EvenOdd },
+	{ 42966, 42968, EvenOddSkip },
 	{ 42997, 42997, OddEven },
 	{ 43888, 43967, -38864 },
 	{ 65313, 65338, 32 },
 	{ 66560, 66599, 40 },
 	{ 66736, 66771, 40 },
+	{ 66928, 66938, 39 },
+	{ 66940, 66954, 39 },
+	{ 66956, 66962, 39 },
+	{ 66964, 66965, 39 },
 	{ 68736, 68786, 64 },
 	{ 71840, 71871, 32 },
 	{ 93760, 93791, 32 },
 	{ 125184, 125217, 34 },
 };
-const int num_unicode_tolower = 200;
+const int num_unicode_tolower = 205;