re2 1.23.0 → 1.23.2

package/vendor/abseil-cpp/absl/strings/str_cat.cc

@@ -26,7 +26,8 @@
 #include "absl/base/config.h"
 #include "absl/base/internal/raw_logging.h"
 #include "absl/base/nullability.h"
-#include "absl/strings/internal/resize_uninitialized.h"
+#include "absl/strings/internal/append_and_overwrite.h"
+#include "absl/strings/resize_and_overwrite.h"
 #include "absl/strings/string_view.h"
 
 namespace absl {
@@ -52,11 +53,6 @@ inline char* absl_nonnull Append(char* absl_nonnull out, const AlphaNum& x) {
   return after;
 }
 
-inline void STLStringAppendUninitializedAmortized(std::string* dest,
-                                                  size_t to_append) {
-  strings_internal::AppendUninitializedTraits<std::string>::Append(dest,
-                                                                   to_append);
-}
 }  // namespace
 
 std::string StrCat(const AlphaNum& a, const AlphaNum& b) {
@@ -67,13 +63,14 @@ std::string StrCat(const AlphaNum& a, const AlphaNum& b) {
   const uint64_t result_size =
       static_cast<uint64_t>(a.size()) + static_cast<uint64_t>(b.size());
   ABSL_INTERNAL_CHECK(result_size <= kMaxSize, "size_t overflow");
-  absl::strings_internal::STLStringResizeUninitialized(
-      &result, static_cast<size_t>(result_size));
-  char* const begin = &result[0];
-  char* out = begin;
-  out = Append(out, a);
-  out = Append(out, b);
-  assert(out == begin + result.size());
+  absl::StringResizeAndOverwrite(result, static_cast<size_t>(result_size),
+                                 [&a, &b](char* const begin, size_t buf_size) {
+                                   char* out = begin;
+                                   out = Append(out, a);
+                                   out = Append(out, b);
+                                   assert(out == begin + buf_size);
+                                   return buf_size;
+                                 });
   return result;
 }
 
@@ -86,14 +83,16 @@ std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c) {
                                static_cast<uint64_t>(b.size()) +
                                static_cast<uint64_t>(c.size());
   ABSL_INTERNAL_CHECK(result_size <= kMaxSize, "size_t overflow");
-  strings_internal::STLStringResizeUninitialized(
-      &result, static_cast<size_t>(result_size));
-  char* const begin = &result[0];
-  char* out = begin;
-  out = Append(out, a);
-  out = Append(out, b);
-  out = Append(out, c);
-  assert(out == begin + result.size());
+  absl::StringResizeAndOverwrite(
+      result, static_cast<size_t>(result_size),
+      [&a, &b, &c](char* const begin, size_t buf_size) {
+        char* out = begin;
+        out = Append(out, a);
+        out = Append(out, b);
+        out = Append(out, c);
+        assert(out == begin + buf_size);
+        return buf_size;
+      });
   return result;
 }
 
@@ -103,20 +102,21 @@ std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c,
   // Use uint64_t to prevent size_t overflow. We assume it is not possible for
   // in memory strings to overflow a uint64_t.
   constexpr uint64_t kMaxSize = uint64_t{std::numeric_limits<size_t>::max()};
-  const uint64_t result_size = static_cast<uint64_t>(a.size()) +
-                               static_cast<uint64_t>(b.size()) +
-                               static_cast<uint64_t>(c.size()) +
-                               static_cast<uint64_t>(d.size());
+  const uint64_t result_size =
+      static_cast<uint64_t>(a.size()) + static_cast<uint64_t>(b.size()) +
+      static_cast<uint64_t>(c.size()) + static_cast<uint64_t>(d.size());
   ABSL_INTERNAL_CHECK(result_size <= kMaxSize, "size_t overflow");
-  strings_internal::STLStringResizeUninitialized(
-      &result, static_cast<size_t>(result_size));
-  char* const begin = &result[0];
-  char* out = begin;
-  out = Append(out, a);
-  out = Append(out, b);
-  out = Append(out, c);
-  out = Append(out, d);
-  assert(out == begin + result.size());
+  absl::StringResizeAndOverwrite(
+      result, static_cast<size_t>(result_size),
+      [&a, &b, &c, &d](char* const begin, size_t buf_size) {
+        char* out = begin;
+        out = Append(out, a);
+        out = Append(out, b);
+        out = Append(out, c);
+        out = Append(out, d);
+        assert(out == begin + buf_size);
+        return buf_size;
+      });
   return result;
 }
 
@@ -133,19 +133,19 @@ std::string CatPieces(std::initializer_list<absl::string_view> pieces) {
     total_size += piece.size();
   }
   ABSL_INTERNAL_CHECK(total_size <= kMaxSize, "size_t overflow");
-  strings_internal::STLStringResizeUninitialized(
-      &result, static_cast<size_t>(total_size));
-
-  char* const begin = &result[0];
-  char* out = begin;
-  for (absl::string_view piece : pieces) {
-    const size_t this_size = piece.size();
-    if (this_size != 0) {
-      memcpy(out, piece.data(), this_size);
-      out += this_size;
-    }
-  }
-  assert(out == begin + result.size());
+  absl::StringResizeAndOverwrite(result, static_cast<size_t>(total_size),
+                                 [&pieces](char* const begin, size_t buf_size) {
+                                   char* out = begin;
+                                   for (absl::string_view piece : pieces) {
+                                     const size_t this_size = piece.size();
+                                     if (this_size != 0) {
+                                       memcpy(out, piece.data(), this_size);
+                                       out += this_size;
+                                     }
+                                   }
+                                   assert(out == begin + buf_size);
+                                   return buf_size;
+                                 });
   return result;
 }
 
@@ -160,49 +160,51 @@ std::string CatPieces(std::initializer_list<absl::string_view> pieces) {
 
 void AppendPieces(std::string* absl_nonnull dest,
                   std::initializer_list<absl::string_view> pieces) {
-  size_t old_size = dest->size();
   size_t to_append = 0;
   for (absl::string_view piece : pieces) {
     ASSERT_NO_OVERLAP(*dest, piece);
     to_append += piece.size();
   }
-  STLStringAppendUninitializedAmortized(dest, to_append);
-
-  char* const begin = &(*dest)[0];
-  char* out = begin + old_size;
-  for (absl::string_view piece : pieces) {
-    const size_t this_size = piece.size();
-    if (this_size != 0) {
-      memcpy(out, piece.data(), this_size);
-      out += this_size;
-    }
-  }
-  assert(out == begin + dest->size());
+  StringAppendAndOverwrite(*dest, to_append,
+                           [&pieces](char* const buf, size_t buf_size) {
+                             char* out = buf;
+                             for (absl::string_view piece : pieces) {
+                               const size_t this_size = piece.size();
+                               if (this_size != 0) {
+                                 memcpy(out, piece.data(), this_size);
+                                 out += this_size;
+                               }
+                             }
+                             assert(out == buf + buf_size);
+                             return buf_size;
+                           });
 }
 
 }  // namespace strings_internal
 
 void StrAppend(std::string* absl_nonnull dest, const AlphaNum& a) {
   ASSERT_NO_OVERLAP(*dest, a);
-  std::string::size_type old_size = dest->size();
-  STLStringAppendUninitializedAmortized(dest, a.size());
-  char* const begin = &(*dest)[0];
-  char* out = begin + old_size;
-  out = Append(out, a);
-  assert(out == begin + dest->size());
+  strings_internal::StringAppendAndOverwrite(
+      *dest, a.size(), [&a](char* const buf, size_t buf_size) {
+        char* out = buf;
+        out = Append(out, a);
+        assert(out == buf + buf_size);
+        return buf_size;
+      });
 }
 
 void StrAppend(std::string* absl_nonnull dest, const AlphaNum& a,
                const AlphaNum& b) {
   ASSERT_NO_OVERLAP(*dest, a);
   ASSERT_NO_OVERLAP(*dest, b);
-  std::string::size_type old_size = dest->size();
-  STLStringAppendUninitializedAmortized(dest, a.size() + b.size());
-  char* const begin = &(*dest)[0];
-  char* out = begin + old_size;
-  out = Append(out, a);
-  out = Append(out, b);
-  assert(out == begin + dest->size());
+  strings_internal::StringAppendAndOverwrite(
+      *dest, a.size() + b.size(), [&a, &b](char* const buf, size_t buf_size) {
+        char* out = buf;
+        out = Append(out, a);
+        out = Append(out, b);
+        assert(out == buf + buf_size);
+        return buf_size;
+      });
 }
 
 void StrAppend(std::string* absl_nonnull dest, const AlphaNum& a,
@@ -210,14 +212,16 @@ void StrAppend(std::string* absl_nonnull dest, const AlphaNum& a,
   ASSERT_NO_OVERLAP(*dest, a);
   ASSERT_NO_OVERLAP(*dest, b);
   ASSERT_NO_OVERLAP(*dest, c);
-  std::string::size_type old_size = dest->size();
-  STLStringAppendUninitializedAmortized(dest, a.size() + b.size() + c.size());
-  char* const begin = &(*dest)[0];
-  char* out = begin + old_size;
-  out = Append(out, a);
-  out = Append(out, b);
-  out = Append(out, c);
-  assert(out == begin + dest->size());
+  strings_internal::StringAppendAndOverwrite(
+      *dest, a.size() + b.size() + c.size(),
+      [&a, &b, &c](char* const buf, size_t buf_size) {
+        char* out = buf;
+        out = Append(out, a);
+        out = Append(out, b);
+        out = Append(out, c);
+        assert(out == buf + buf_size);
+        return buf_size;
+      });
 }
 
 void StrAppend(std::string* absl_nonnull dest, const AlphaNum& a,
@@ -226,16 +230,17 @@ void StrAppend(std::string* absl_nonnull dest, const AlphaNum& a,
   ASSERT_NO_OVERLAP(*dest, b);
   ASSERT_NO_OVERLAP(*dest, c);
   ASSERT_NO_OVERLAP(*dest, d);
-  std::string::size_type old_size = dest->size();
-  STLStringAppendUninitializedAmortized(
-      dest, a.size() + b.size() + c.size() + d.size());
-  char* const begin = &(*dest)[0];
-  char* out = begin + old_size;
-  out = Append(out, a);
-  out = Append(out, b);
-  out = Append(out, c);
-  out = Append(out, d);
-  assert(out == begin + dest->size());
+  strings_internal::StringAppendAndOverwrite(
+      *dest, a.size() + b.size() + c.size() + d.size(),
+      [&a, &b, &c, &d](char* const buf, size_t buf_size) {
+        char* out = buf;
+        out = Append(out, a);
+        out = Append(out, b);
+        out = Append(out, c);
+        out = Append(out, d);
+        assert(out == buf + buf_size);
+        return buf_size;
+      });
 }
 
 ABSL_NAMESPACE_END

package/vendor/abseil-cpp/absl/strings/str_cat.h

@@ -109,6 +109,7 @@
 #include "absl/strings/internal/resize_uninitialized.h"
 #include "absl/strings/internal/stringify_sink.h"
 #include "absl/strings/numbers.h"
+#include "absl/strings/resize_and_overwrite.h"
 #include "absl/strings/string_view.h"
 
 #if !defined(ABSL_USES_STD_STRING_VIEW)
@@ -471,23 +472,27 @@ std::string IntegerToString(Integer i) {
   // with 22 bytes (including NULL at the end).
   constexpr size_t kMaxDigits10 = 22;
   std::string result;
-  strings_internal::STLStringResizeUninitialized(&result, kMaxDigits10);
-  char* start = &result[0];
-  // note: this can be optimized to not write last zero.
-  char* end = numbers_internal::FastIntToBuffer(i, start);
-  auto size = static_cast<size_t>(end - start);
-  assert((size < result.size()) &&
-         "StrCat(Integer) does not fit into kMaxDigits10");
-  result.erase(size);
+  StringResizeAndOverwrite(
+      result, kMaxDigits10, [i](char* start, size_t buf_size) {
+        // Note: This can be optimized to not write last zero.
+        char* end = numbers_internal::FastIntToBuffer(i, start);
+        auto size = static_cast<size_t>(end - start);
+        ABSL_ASSERT(size < buf_size);
+        return size;
+      });
   return result;
 }
+
 template <typename Float>
 std::string FloatToString(Float f) {
   std::string result;
-  strings_internal::STLStringResizeUninitialized(
-      &result, numbers_internal::kSixDigitsToBufferSize);
-  char* start = &result[0];
-  result.erase(numbers_internal::SixDigitsToBuffer(f, start));
+  StringResizeAndOverwrite(result, numbers_internal::kSixDigitsToBufferSize,
+                           [f](char* start, size_t buf_size) {
+                             size_t size =
+                                 numbers_internal::SixDigitsToBuffer(f, start);
+                             ABSL_ASSERT(size < buf_size);
+                             return size;
+                           });
   return result;
 }
 

package/vendor/abseil-cpp/absl/strings/str_format_test.cc

@@ -65,8 +65,8 @@ TEST_F(FormatEntryPointTest, UntypedFormat) {
     "",
     "a",
     "%80d",
-#if !defined(_MSC_VER) && !defined(__ANDROID__) && !defined(__native_client__)
-    // MSVC, NaCL and Android don't support positional syntax.
+#if !defined(_MSC_VER) && !defined(__ANDROID__)
+    // MSVC and Android don't support positional syntax.
     "complicated multipart %% %1$d format %1$0999d",
 #endif  // _MSC_VER
   };
@@ -266,8 +266,8 @@ TEST_F(FormatEntryPointTest, Stream) {
     "a",
     "%80d",
     "%d %u %c %s %f %g",
-#if !defined(_MSC_VER) && !defined(__ANDROID__) && !defined(__native_client__)
-    // MSVC, NaCL and Android don't support positional syntax.
+#if !defined(_MSC_VER) && !defined(__ANDROID__)
+    // MSVC and Android don't support positional syntax.
     "complicated multipart %% %1$d format %1$080d",
 #endif  // _MSC_VER
   };

package/vendor/abseil-cpp/absl/strings/str_split.h

@@ -382,7 +382,7 @@ struct SkipEmpty {
 //   // v[0] == " a ", v[1] == " ", v[2] == "b"
 struct SkipWhitespace {
   bool operator()(absl::string_view sp) const {
-    sp = absl::StripAsciiWhitespace(sp);
+    sp = absl::StripLeadingAsciiWhitespace(sp);
     return !sp.empty();
   }
 };

package/vendor/abseil-cpp/absl/strings/str_split_test.cc

@@ -216,7 +216,7 @@ TEST(Split, APIExamples) {
     std::multimap<std::string, std::string> m =
         absl::StrSplit("a,1,b,2,a,3", ',');
     EXPECT_EQ(3, m.size());
-    auto it = m.find("a");
+    auto it = m.lower_bound("a");
     EXPECT_EQ("1", it->second);
     ++it;
     EXPECT_EQ("3", it->second);