re2 1.23.0 → 1.23.2

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

@@ -28,13 +28,15 @@
 #include "absl/base/internal/endian.h"
 #include "absl/base/internal/raw_logging.h"
 #include "absl/base/internal/unaligned_access.h"
+#include "absl/base/macros.h"
 #include "absl/base/nullability.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/charset.h"
+#include "absl/strings/internal/append_and_overwrite.h"
 #include "absl/strings/internal/escaping.h"
-#include "absl/strings/internal/resize_uninitialized.h"
 #include "absl/strings/internal/utf8.h"
 #include "absl/strings/numbers.h"
+#include "absl/strings/resize_and_overwrite.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
@@ -76,30 +78,31 @@ inline bool IsSurrogate(char32_t c, absl::string_view src,
 //
 //    Unescapes C escape sequences and is the reverse of CEscape().
 //
-//    If `src` is valid, stores the unescaped string `dst`, and returns
-//    true. Otherwise returns false and optionally stores the error
-//    description in `error`. Set `error` to nullptr to disable error
-//    reporting.
+//    If `src` is valid, stores the unescaped string in `dst` and the length of
+//    unescaped string in `dst_size`, and returns true. Otherwise returns false
+//    and optionally stores the error description in `error`. Set `error` to
+//    nullptr to disable error reporting.
 //
-//    `src` and `dst` may use the same underlying buffer.
+//    `src` and `dst` may use the same underlying buffer (but keep in mind
+//    that if this returns an error, it will leave both `src` and `dst` in
+//    an unspecified state because they are using the same underlying buffer.)
+//    `dst` must have at least as much space as `src`.
 // ----------------------------------------------------------------------
 
 bool CUnescapeInternal(absl::string_view src, bool leave_nulls_escaped,
-                       std::string* absl_nonnull dst,
+                       char* absl_nonnull dst, size_t* absl_nonnull dst_size,
                        std::string* absl_nullable error) {
-  strings_internal::STLStringResizeUninitialized(dst, src.size());
-
   absl::string_view::size_type p = 0;  // Current src position.
-  std::string::size_type d = 0;        // Current dst position.
+  size_t d = 0;                        // Current dst position.
 
   // When unescaping in-place, skip any prefix that does not have escaping.
-  if (src.data() == dst->data()) {
+  if (src.data() == dst) {
     while (p < src.size() && src[p] != '\\') p++, d++;
   }
 
   while (p < src.size()) {
     if (src[p] != '\\') {
-      (*dst)[d++] = src[p++];
+      dst[d++] = src[p++];
     } else {
       if (++p >= src.size()) {  // skip past the '\\'
         if (error != nullptr) {
@@ -108,17 +111,19 @@ bool CUnescapeInternal(absl::string_view src, bool leave_nulls_escaped,
         return false;
       }
       switch (src[p]) {
-        case 'a':  (*dst)[d++] = '\a';  break;
-        case 'b':  (*dst)[d++] = '\b';  break;
-        case 'f':  (*dst)[d++] = '\f';  break;
-        case 'n':  (*dst)[d++] = '\n';  break;
-        case 'r':  (*dst)[d++] = '\r';  break;
-        case 't':  (*dst)[d++] = '\t';  break;
-        case 'v':  (*dst)[d++] = '\v';  break;
-        case '\\': (*dst)[d++] = '\\';  break;
-        case '?':  (*dst)[d++] = '\?';  break;
-        case '\'': (*dst)[d++] = '\'';  break;
-        case '"':  (*dst)[d++] = '\"';  break;
+          // clang-format off
+        case 'a':  dst[d++] = '\a';  break;
+        case 'b':  dst[d++] = '\b';  break;
+        case 'f':  dst[d++] = '\f';  break;
+        case 'n':  dst[d++] = '\n';  break;
+        case 'r':  dst[d++] = '\r';  break;
+        case 't':  dst[d++] = '\t';  break;
+        case 'v':  dst[d++] = '\v';  break;
+        case '\\': dst[d++] = '\\';  break;
+        case '?':  dst[d++] = '\?';  break;
+        case '\'': dst[d++] = '\'';  break;
+        case '"':  dst[d++] = '\"';  break;
+        // clang-format on
         case '0':
         case '1':
         case '2':
@@ -145,13 +150,13 @@ bool CUnescapeInternal(absl::string_view src, bool leave_nulls_escaped,
           }
           if ((ch == 0) && leave_nulls_escaped) {
             // Copy the escape sequence for the null character
-            (*dst)[d++] = '\\';
+            dst[d++] = '\\';
             while (octal_start <= p) {
-              (*dst)[d++] = src[octal_start++];
+              dst[d++] = src[octal_start++];
             }
             break;
           }
-          (*dst)[d++] = static_cast<char>(ch);
+          dst[d++] = static_cast<char>(ch);
           break;
         }
         case 'x':
@@ -185,13 +190,13 @@ bool CUnescapeInternal(absl::string_view src, bool leave_nulls_escaped,
           }
           if ((ch == 0) && leave_nulls_escaped) {
             // Copy the escape sequence for the null character
-            (*dst)[d++] = '\\';
+            dst[d++] = '\\';
             while (hex_start <= p) {
-              (*dst)[d++] = src[hex_start++];
+              dst[d++] = src[hex_start++];
             }
             break;
           }
-          (*dst)[d++] = static_cast<char>(ch);
+          dst[d++] = static_cast<char>(ch);
           break;
         }
         case 'u': {
@@ -218,16 +223,16 @@ bool CUnescapeInternal(absl::string_view src, bool leave_nulls_escaped,
           }
           if ((rune == 0) && leave_nulls_escaped) {
             // Copy the escape sequence for the null character
-            (*dst)[d++] = '\\';
+            dst[d++] = '\\';
             while (hex_start <= p) {
-              (*dst)[d++] = src[hex_start++];
+              dst[d++] = src[hex_start++];
             }
             break;
           }
           if (IsSurrogate(rune, src.substr(hex_start, 5), error)) {
             return false;
           }
-          d += strings_internal::EncodeUTF8Char(dst->data() + d, rune);
+          d += strings_internal::EncodeUTF8Char(dst + d, rune);
           break;
         }
         case 'U': {
@@ -267,17 +272,17 @@ bool CUnescapeInternal(absl::string_view src, bool leave_nulls_escaped,
           }
           if ((rune == 0) && leave_nulls_escaped) {
             // Copy the escape sequence for the null character
-            (*dst)[d++] = '\\';
+            dst[d++] = '\\';
             // U00000000
             while (hex_start <= p) {
-              (*dst)[d++] = src[hex_start++];
+              dst[d++] = src[hex_start++];
             }
             break;
           }
           if (IsSurrogate(rune, src.substr(hex_start, 9), error)) {
             return false;
           }
-          d += strings_internal::EncodeUTF8Char(dst->data() + d, rune);
+          d += strings_internal::EncodeUTF8Char(dst + d, rune);
           break;
         }
         default: {
@@ -291,7 +296,7 @@ bool CUnescapeInternal(absl::string_view src, bool leave_nulls_escaped,
     }
   }
 
-  dst->erase(d);
+  *dst_size = d;
   return true;
 }
 
@@ -441,22 +446,22 @@ void CEscapeAndAppendInternal(absl::string_view src,
 
   // We keep 3 slop bytes so that we can call `little_endian::Store32`
   // invariably regardless of the length of the escaped character.
-  constexpr size_t slop_bytes = 3;
+  constexpr size_t kSlopBytes = 3;
   size_t cur_dest_len = dest->size();
-  size_t new_dest_len = cur_dest_len + escaped_len + slop_bytes;
-  ABSL_INTERNAL_CHECK(new_dest_len > cur_dest_len, "std::string size overflow");
-  strings_internal::AppendUninitializedTraits<std::string>::Append(
-      dest, escaped_len + slop_bytes);
-  char* append_ptr = &(*dest)[cur_dest_len];
-
-  for (char c : src) {
-    unsigned char uc = static_cast<unsigned char>(c);
-    size_t char_len = kCEscapedLen[uc];
-    uint32_t little_endian_uint32 = kCEscapedLittleEndianUint32Array[uc];
-    little_endian::Store32(append_ptr, little_endian_uint32);
-    append_ptr += char_len;
-  }
-  dest->resize(new_dest_len - slop_bytes);
+  size_t append_buf_len = cur_dest_len + escaped_len + kSlopBytes;
+  ABSL_INTERNAL_CHECK(append_buf_len > cur_dest_len,
+                      "std::string size overflow");
+  strings_internal::StringAppendAndOverwrite(
+      *dest, append_buf_len, [src, escaped_len](char* append_ptr, size_t) {
+        for (char c : src) {
+          unsigned char uc = static_cast<unsigned char>(c);
+          size_t char_len = kCEscapedLen[uc];
+          uint32_t little_endian_uint32 = kCEscapedLittleEndianUint32Array[uc];
+          little_endian::Store32(append_ptr, little_endian_uint32);
+          append_ptr += char_len;
+        }
+        return escaped_len;
+      });
 }
 
 // Reverses the mapping in Base64EscapeInternal; see that method's
@@ -807,23 +812,18 @@ bool Base64UnescapeInternal(const char* absl_nullable src, size_t slen,
   // 4 characters.  Any leftover chars are added directly for good measure.
   const size_t dest_len = 3 * (slen / 4) + (slen % 4);
 
-  strings_internal::STLStringResizeUninitialized(dest, dest_len);
-
-  // We are getting the destination buffer by getting the beginning of the
-  // string and converting it into a char *.
-  size_t len;
-  const bool ok =
-      Base64UnescapeInternal(src, slen, &(*dest)[0], dest_len, unbase64, &len);
-  if (!ok) {
-    dest->clear();
-    return false;
-  }
-
-  // could be shorter if there was padding
-  assert(len <= dest_len);
-  dest->erase(len);
-
-  return true;
+  bool ok;
+  StringResizeAndOverwrite(
+      *dest, dest_len, [src, slen, unbase64, &ok](char* buf, size_t buf_size) {
+        size_t len;
+        ok = Base64UnescapeInternal(src, slen, buf, buf_size, unbase64, &len);
+        if (!ok) {
+          len = 0;
+        }
+        assert(len <= buf_size);  // Could be shorter if there was padding.
+        return len;
+      });
+  return ok;
 }
 
 /* clang-format off */
@@ -878,15 +878,11 @@ void HexStringToBytesInternal(const char* absl_nullable from, T to,
   }
 }
 
-// This is a templated function so that T can be either a char* or a
-// std::string.
-template <typename T>
-void BytesToHexStringInternal(const unsigned char* absl_nullable src, T dest,
-                              size_t num) {
-  auto dest_ptr = &dest[0];
-  for (auto src_ptr = src; src_ptr != (src + num); ++src_ptr, dest_ptr += 2) {
+void BytesToHexStringInternal(const unsigned char* absl_nullable src,
+                              char* dest, size_t num) {
+  for (auto src_ptr = src; src_ptr != (src + num); ++src_ptr, dest += 2) {
     const char* hex_p = &numbers_internal::kHexTable[*src_ptr * 2];
-    std::copy(hex_p, hex_p + 2, dest_ptr);
+    std::copy(hex_p, hex_p + 2, dest);
   }
 }
 
@@ -897,9 +893,35 @@ void BytesToHexStringInternal(const unsigned char* absl_nullable src, T dest,
 //
 // See CUnescapeInternal() for implementation details.
 // ----------------------------------------------------------------------
+
 bool CUnescape(absl::string_view source, std::string* absl_nonnull dest,
                std::string* absl_nullable error) {
-  return CUnescapeInternal(source, kUnescapeNulls, dest, error);
+  bool success;
+
+  // `CUnescape()` allows for in-place unescaping, which means `source` may
+  // alias `*dest`.  However, absl::StringResizeAndOverwrite() invalidates all
+  // iterators, pointers, and references into the string, regardless whether
+  // reallocation occurs. Therefore we need to avoid calling
+  // absl::StringResizeAndOverwrite() when `source.data() ==
+  // dest->data()`. Comparing the sizes is sufficient to cover this case.
+  if (dest->size() >= source.size()) {
+    size_t dest_size = 0;
+    success = CUnescapeInternal(source, kUnescapeNulls, dest->data(),
+                                &dest_size, error);
+    ABSL_ASSERT(dest_size <= dest->size());
+    dest->erase(dest_size);
+  } else {
+    StringResizeAndOverwrite(
+        *dest, source.size(),
+        [source, error, &success](char* buf, size_t buf_size) {
+          size_t dest_size = 0;
+          success =
+              CUnescapeInternal(source, kUnescapeNulls, buf, &dest_size, error);
+          ABSL_ASSERT(dest_size <= buf_size);
+          return dest_size;
+        });
+  }
+  return success;
 }
 
 std::string CEscape(absl::string_view src) {
@@ -966,19 +988,23 @@ bool HexStringToBytes(absl::string_view hex, std::string* absl_nonnull bytes) {
     return false;
   }
 
-  absl::strings_internal::STLStringResizeUninitialized(&output, num_bytes);
-  auto hex_p = hex.cbegin();
-  for (std::string::iterator bin_p = output.begin(); bin_p != output.end();
-       ++bin_p) {
-    int h1 = absl::kHexValueStrict[static_cast<size_t>(*hex_p++)];
-    int h2 = absl::kHexValueStrict[static_cast<size_t>(*hex_p++)];
-    if (h1 == -1 || h2 == -1) {
-      output.resize(static_cast<size_t>(bin_p - output.begin()));
-      return false;
-    }
-    *bin_p = static_cast<char>((h1 << 4) + h2);
-  }
+  StringResizeAndOverwrite(
+      output, num_bytes, [hex](char* buf, size_t buf_size) {
+        auto hex_p = hex.cbegin();
+        for (size_t i = 0; i < buf_size; ++i) {
+          int h1 = absl::kHexValueStrict[static_cast<size_t>(*hex_p++)];
+          int h2 = absl::kHexValueStrict[static_cast<size_t>(*hex_p++)];
+          if (h1 == -1 || h2 == -1) {
+            return size_t{0};
+          }
+          buf[i] = static_cast<char>((h1 << 4) + h2);
+        }
+        return buf_size;
+      });
 
+  if (output.size() != num_bytes) {
+    return false;
+  }
   *bytes = std::move(output);
   return true;
 }
@@ -986,16 +1012,22 @@ bool HexStringToBytes(absl::string_view hex, std::string* absl_nonnull bytes) {
 std::string HexStringToBytes(absl::string_view from) {
   std::string result;
   const auto num = from.size() / 2;
-  strings_internal::STLStringResizeUninitialized(&result, num);
-  absl::HexStringToBytesInternal<std::string&>(from.data(), result, num);
+  StringResizeAndOverwrite(result, num, [from](char* buf, size_t buf_size) {
+    absl::HexStringToBytesInternal<char*>(from.data(), buf, buf_size);
+    return buf_size;
+  });
   return result;
 }
 
 std::string BytesToHexString(absl::string_view from) {
   std::string result;
-  strings_internal::STLStringResizeUninitialized(&result, 2 * from.size());
-  absl::BytesToHexStringInternal<std::string&>(
-      reinterpret_cast<const unsigned char*>(from.data()), result, from.size());
+  StringResizeAndOverwrite(
+      result, 2 * from.size(), [from](char* buf, size_t buf_size) {
+        absl::BytesToHexStringInternal(
+            reinterpret_cast<const unsigned char*>(from.data()), buf,
+            from.size());
+        return buf_size;
+      });
   return result;
 }
 

package/vendor/abseil-cpp/absl/strings/internal/append_and_overwrite.h

@@ -0,0 +1,93 @@
+// Copyright 2025 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_INTERNAL_APPEND_AND_OVERWRITE_H_
+#define ABSL_STRINGS_INTERNAL_APPEND_AND_OVERWRITE_H_
+
+#include "absl/base/config.h"
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/macros.h"
+#include "absl/base/optimization.h"
+#include "absl/strings/resize_and_overwrite.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+// An internal-only variant similar to `absl::StringResizeAndOverwrite()`
+// optimized for repeated appends to a string that uses exponential growth so
+// that the amortized complexity of increasing the string size by a small amount
+// is O(1), in contrast to O(str.size()) in the case of precise growth. Use of
+// this function is subtle; see https://reviews.llvm.org/D102727 to understand
+// the tradeoffs.
+//
+// Appends at most `append_n` characters to `str`, using the user-provided
+// operation `append_op` to modify the possibly indeterminate
+// contents. `append_op` must return the length of the buffer appended to `str`.
+//
+// Invalidates all iterators, pointers, and references into `str`, regardless
+// of whether reallocation occurs.
+//
+// `append_op(value_type* buf, size_t buf_size)` is allowed to write
+// `value_type{}` to `buf[buf_size]`, which facilitiates interoperation with
+// functions that write a trailing NUL.
+template <typename T, typename Op>
+void StringAppendAndOverwrite(T& str, typename T::size_type append_n,
+                              Op append_op) {
+  if (ABSL_PREDICT_FALSE(append_n > str.max_size() - str.size())) {
+    absl::base_internal::ThrowStdLengthError(
+        "absl::strings_internal::StringAppendAndOverwrite");
+  }
+
+  auto old_size = str.size();
+  auto resize = old_size + append_n;
+
+  if (resize > str.capacity()) {
+    // Make sure to always grow by at least a factor of 2x.
+    const auto min_growth = str.capacity();
+    if (ABSL_PREDICT_FALSE(str.capacity() > str.max_size() - min_growth)) {
+      resize = str.max_size();
+    } else if (resize < str.capacity() + min_growth) {
+      resize = str.capacity() + min_growth;
+    }
+  } else {
+    resize = str.capacity();
+  }
+
+  // Avoid calling StringResizeAndOverwrite() here since it does an MSAN
+  // verification on the entire string. StringResizeAndOverwriteImpl() is
+  // StringResizeAndOverwrite() without the MSAN verification.
+  StringResizeAndOverwriteImpl(
+      str, resize,
+      [old_size, append_n, do_append = std::move(append_op)](
+          typename T::value_type* data_ptr, typename T::size_type) mutable {
+        auto num_appended =
+            std::move(do_append)(data_ptr + old_size, append_n);
+        ABSL_HARDENING_ASSERT(num_appended >= 0 && num_appended <= append_n);
+        return old_size + num_appended;
+      });
+
+#if defined(ABSL_HAVE_MEMORY_SANITIZER)
+  // Only check the region appended to. Checking the entire string would cause
+  // pathological quadratic verfication on repeated small appends.
+  __msan_check_mem_is_initialized(str.data() + old_size, str.size() - old_size);
+#endif
+}
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+
+#endif  // ABSL_STRINGS_INTERNAL_APPEND_AND_OVERWRITE_H_

package/vendor/abseil-cpp/absl/strings/internal/append_and_overwrite_test.cc

@@ -0,0 +1,95 @@
+// Copyright 2025 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/internal/append_and_overwrite.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <string>
+
+#include "gtest/gtest.h"
+#include "absl/log/absl_check.h"
+
+namespace {
+
+struct AppendAndOverwriteParam {
+  size_t initial_size;
+  size_t append_capacity;
+  size_t append_size;
+};
+
+using StringAppendAndOverwriteTest =
+    ::testing::TestWithParam<AppendAndOverwriteParam>;
+
+TEST_P(StringAppendAndOverwriteTest, StringAppendAndOverwrite) {
+  const auto& param = GetParam();
+  std::string s(param.initial_size, 'a');
+  absl::strings_internal::StringAppendAndOverwrite(
+      s, param.append_capacity, [&](char* p, size_t n) {
+        ABSL_CHECK_EQ(n, param.append_capacity);
+        std::fill_n(p, param.append_size, 'b');
+        p[param.append_size] = '\0';
+        return param.append_size;
+      });
+
+  std::string expected =
+      std::string(param.initial_size, 'a') +
+      std::string(param.append_size,
+                  'b');
+
+  EXPECT_EQ(s, expected);
+  EXPECT_EQ(s.c_str()[s.size()], '\0');
+}
+
+// clang-format off
+INSTANTIATE_TEST_SUITE_P(StringAppendAndOverwriteTestSuite,
+                         StringAppendAndOverwriteTest,
+                         ::testing::ValuesIn<AppendAndOverwriteParam>({
+                             {0,  10,  5},
+                             {10, 10, 10},
+                             {10, 15, 15},
+                             {10, 20, 15},
+                             {10, 40, 40},
+                             {10, 50, 40},
+                             {30, 35, 35},
+                             {30, 45, 35},
+                             {10, 30, 15},
+                         }));
+// clang-format on
+
+TEST(StringAppendAndOverwrite, AmortizedComplexity) {
+  std::string str;
+  std::string expected;
+  size_t prev_cap = str.capacity();
+  int cap_increase_count = 0;
+  for (int i = 0; i < 1000; ++i) {
+    char c = static_cast<char>('a' + (i % 26));
+    absl::strings_internal::StringAppendAndOverwrite(
+        str, 1, [c](char* buf, size_t buf_size) {
+          ABSL_CHECK_EQ(buf_size, 1);
+          buf[0] = c;
+          return size_t{1};
+        });
+    expected.push_back(c);
+    EXPECT_EQ(str, expected);
+    size_t new_cap = str.capacity();
+    if (new_cap > prev_cap) {
+      ++cap_increase_count;
+    }
+    prev_cap = new_cap;
+  }
+  EXPECT_LT(cap_increase_count, 50);
+}
+
+}  // namespace

package/vendor/abseil-cpp/absl/strings/internal/cord_internal.h

@@ -381,6 +381,8 @@ struct CordRepExternalImpl
     this->releaser_invoker = &Release;
   }
 
+  const Releaser* releaser() const { return &this->template get<0>(); }
+
   ~CordRepExternalImpl() {
     InvokeReleaser(Rank1{}, std::move(this->template get<0>()),
                    absl::string_view(base, length));

package/vendor/abseil-cpp/absl/strings/internal/cord_rep_btree_test.cc

@@ -1230,16 +1230,16 @@ TEST(CordRepBtreeTest, Dump) {
 
     if (api != 3) {
       // Does not contain contents
-      EXPECT_THAT(str, Not(AnyOf((HasSubstr("data = \"Hello world\""),
-                                  HasSubstr("data = \"Hello external\""),
-                                  HasSubstr("data = \"ello w\""),
-                                  HasSubstr("data = \"llo ext\"")))));
+      EXPECT_THAT(str, Not(AnyOf(HasSubstr("data = \"Hello world\""),
+                                 HasSubstr("data = \"Hello external\""),
+                                 HasSubstr("data = \"ello w\""),
+                                 HasSubstr("data = \"llo ext\""))));
     } else {
       // Contains contents
-      EXPECT_THAT(str, AllOf((HasSubstr("data = \"Hello world\""),
-                              HasSubstr("data = \"Hello external\""),
-                              HasSubstr("data = \"ello w\""),
-                              HasSubstr("data = \"llo ext\""))));
+      EXPECT_THAT(str, AllOf(HasSubstr("data = \"Hello world\""),
+                             HasSubstr("data = \"Hello external\""),
+                             HasSubstr("data = \"ello w\""),
+                             HasSubstr("data = \"llo ext\"")));
     }
   }