grpc 1.72.0 → 1.74.0.pre2

data/third_party/abseil-cpp/absl/strings/internal/utf8.cc

@@ -16,11 +16,17 @@
 
 #include "absl/strings/internal/utf8.h"
 
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+
+#include "absl/base/config.h"
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
-size_t EncodeUTF8Char(char *buffer, char32_t utf8_char) {
+size_t EncodeUTF8Char(char* buffer, char32_t utf8_char) {
   if (utf8_char <= 0x7F) {
     *buffer = static_cast<char>(utf8_char);
     return 1;
@@ -48,6 +54,95 @@ size_t EncodeUTF8Char(char *buffer, char32_t utf8_char) {
   }
 }
 
+size_t WideToUtf8(wchar_t wc, char* buf, ShiftState& s) {
+  // Reinterpret the output buffer `buf` as `unsigned char*` for subsequent
+  // bitwise operations. This ensures well-defined behavior for bit
+  // manipulations (avoiding issues with signed `char`) and is safe under C++
+  // aliasing rules, as `unsigned char` can alias any type.
+  auto* ubuf = reinterpret_cast<unsigned char*>(buf);
+  const uint32_t v = static_cast<uint32_t>(wc);
+  constexpr size_t kError = static_cast<size_t>(-1);
+
+  if (v <= 0x007F) {
+    // 1-byte sequence (U+0000 to U+007F).
+    // 0xxxxxxx.
+    ubuf[0] = (0b0111'1111 & v);
+    s = {};  // Reset surrogate state.
+    return 1;
+  } else if (0x0080 <= v && v <= 0x07FF) {
+    // 2-byte sequence (U+0080 to U+07FF).
+    // 110xxxxx 10xxxxxx.
+    ubuf[0] = 0b1100'0000 | (0b0001'1111 & (v >> 6));
+    ubuf[1] = 0b1000'0000 | (0b0011'1111 & v);
+    s = {};  // Reset surrogate state.
+    return 2;
+  } else if ((0x0800 <= v && v <= 0xD7FF) || (0xE000 <= v && v <= 0xFFFF)) {
+    // 3-byte sequence (U+0800 to U+D7FF or U+E000 to U+FFFF).
+    // Excludes surrogate code points U+D800-U+DFFF.
+    // 1110xxxx 10xxxxxx 10xxxxxx.
+    ubuf[0] = 0b1110'0000 | (0b0000'1111 & (v >> 12));
+    ubuf[1] = 0b1000'0000 | (0b0011'1111 & (v >> 6));
+    ubuf[2] = 0b1000'0000 | (0b0011'1111 & v);
+    s = {};  // Reset surrogate state.
+    return 3;
+  } else if (0xD800 <= v && v <= 0xDBFF) {
+    // High Surrogate (U+D800 to U+DBFF).
+    // This part forms the first two bytes of an eventual 4-byte UTF-8 sequence.
+    const unsigned char high_bits_val = (0b0000'1111 & (v >> 6)) + 1;
+
+    // First byte of the 4-byte UTF-8 sequence (11110xxx).
+    ubuf[0] = 0b1111'0000 | (0b0000'0111 & (high_bits_val >> 2));
+    // Second byte of the 4-byte UTF-8 sequence (10xxxxxx).
+    ubuf[1] = 0b1000'0000 |                           //
+              (0b0011'0000 & (high_bits_val << 4)) |  //
+              (0b0000'1111 & (v >> 2));
+    // Set state for high surrogate after writing to buffer.
+    s = {true, static_cast<unsigned char>(0b0000'0011 & v)};
+    return 2;  // Wrote 2 bytes, expecting 2 more from a low surrogate.
+  } else if (0xDC00 <= v && v <= 0xDFFF) {
+    // Low Surrogate (U+DC00 to U+DFFF).
+    // This part forms the last two bytes of a 4-byte UTF-8 sequence,
+    // using state from a preceding high surrogate.
+    if (!s.saw_high_surrogate) {
+      // Error: Isolated low surrogate without a preceding high surrogate.
+      // s remains in its current (problematic) state.
+      // Caller should handle error.
+      return kError;
+    }
+
+    // Third byte of the 4-byte UTF-8 sequence (10xxxxxx).
+    ubuf[0] = 0b1000'0000 |                    //
+              (0b0011'0000 & (s.bits << 4)) |  //
+              (0b0000'1111 & (v >> 6));
+    // Fourth byte of the 4-byte UTF-8 sequence (10xxxxxx).
+    ubuf[1] = 0b1000'0000 | (0b0011'1111 & v);
+
+    s = {};    // Reset surrogate state, pair complete.
+    return 2;  // Wrote 2 more bytes, completing the 4-byte sequence.
+  } else if constexpr (0xFFFF < std::numeric_limits<wchar_t>::max()) {
+    // Conditionally compile the 4-byte direct conversion branch.
+    // This block is compiled only if wchar_t can represent values > 0xFFFF.
+    // It's placed after surrogate checks to ensure surrogates are handled by
+    // their specific logic. This inner 'if' is the runtime check for the 4-byte
+    // range. At this point, v is known not to be in the 1, 2, or 3-byte BMP
+    // ranges, nor is it a surrogate code point.
+    if (0x10000 <= v && v <= 0x10FFFF) {
+      // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx.
+      ubuf[0] = 0b1111'0000 | (0b0000'0111 & (v >> 18));
+      ubuf[1] = 0b1000'0000 | (0b0011'1111 & (v >> 12));
+      ubuf[2] = 0b1000'0000 | (0b0011'1111 & (v >> 6));
+      ubuf[3] = 0b1000'0000 | (0b0011'1111 & v);
+      s = {};  // Reset surrogate state.
+      return 4;
+    }
+  }
+
+  // Invalid wchar_t value (e.g., out of Unicode range, or unhandled after all
+  // checks).
+  s = {};  // Reset surrogate state.
+  return kError;
+}
+
 }  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

data/third_party/abseil-cpp/absl/strings/internal/utf8.h

@@ -41,7 +41,21 @@ namespace strings_internal {
 // characters into buffer, however never will more than kMaxEncodedUTF8Size
 // bytes be written, regardless of the value of utf8_char.
 enum { kMaxEncodedUTF8Size = 4 };
-size_t EncodeUTF8Char(char *buffer, char32_t utf8_char);
+size_t EncodeUTF8Char(char* buffer, char32_t utf8_char);
+
+struct ShiftState {
+  bool saw_high_surrogate = false;
+  unsigned char bits = 0;
+};
+
+// Converts `wc` from UTF-16 or UTF-32 to UTF-8 and writes to `buf`. `buf` is
+// assumed to have enough space for the output. `s` is used to carry state
+// between successive calls with a UTF-16 surrogate pair. Returns the number of
+// chars written, or `static_cast<size_t>(-1)` on failure.
+//
+// This is basically std::wcrtomb(), but always outputting UTF-8 instead of
+// respecting the current locale.
+size_t WideToUtf8(wchar_t wc, char* buf, ShiftState& s);
 
 }  // namespace strings_internal
 ABSL_NAMESPACE_END

data/third_party/abseil-cpp/absl/strings/match.h

@@ -55,22 +55,32 @@ inline bool StrContains(absl::string_view haystack, char needle) noexcept {
 // StartsWith()
 //
 // Returns whether a given string `text` begins with `prefix`.
-inline bool StartsWith(absl::string_view text,
-                       absl::string_view prefix) noexcept {
-  return prefix.empty() ||
-         (text.size() >= prefix.size() &&
-          memcmp(text.data(), prefix.data(), prefix.size()) == 0);
+inline constexpr bool StartsWith(absl::string_view text,
+                                 absl::string_view prefix) noexcept {
+  if (prefix.empty()) {
+    return true;
+  }
+  if (text.size() < prefix.size()) {
+    return false;
+  }
+  absl::string_view possible_match = text.substr(0, prefix.size());
+
+  return possible_match == prefix;
 }
 
 // EndsWith()
 //
 // Returns whether a given string `text` ends with `suffix`.
-inline bool EndsWith(absl::string_view text,
-                     absl::string_view suffix) noexcept {
-  return suffix.empty() ||
-         (text.size() >= suffix.size() &&
-          memcmp(text.data() + (text.size() - suffix.size()), suffix.data(),
-                 suffix.size()) == 0);
+inline constexpr bool EndsWith(absl::string_view text,
+                               absl::string_view suffix) noexcept {
+  if (suffix.empty()) {
+    return true;
+  }
+  if (text.size() < suffix.size()) {
+    return false;
+  }
+  absl::string_view possible_match = text.substr(text.size() - suffix.size());
+  return possible_match == suffix;
 }
 // StrContainsIgnoreCase()
 //

data/third_party/abseil-cpp/absl/strings/numbers.cc

@@ -18,6 +18,7 @@
 #include "absl/strings/numbers.h"
 
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <cfloat>  // for DBL_DIG and FLT_DIG
 #include <cmath>   // for HUGE_VAL
@@ -46,7 +47,7 @@
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
-bool SimpleAtof(absl::string_view str, absl::Nonnull<float*> out) {
+bool SimpleAtof(absl::string_view str, float* absl_nonnull out) {
   *out = 0.0;
   str = StripAsciiWhitespace(str);
   // std::from_chars doesn't accept an initial +, but SimpleAtof does, so if one
@@ -77,7 +78,7 @@ bool SimpleAtof(absl::string_view str, absl::Nonnull<float*> out) {
   return true;
 }
 
-bool SimpleAtod(absl::string_view str, absl::Nonnull<double*> out) {
+bool SimpleAtod(absl::string_view str, double* absl_nonnull out) {
   *out = 0.0;
   str = StripAsciiWhitespace(str);
   // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one
@@ -108,7 +109,7 @@ bool SimpleAtod(absl::string_view str, absl::Nonnull<double*> out) {
   return true;
 }
 
-bool SimpleAtob(absl::string_view str, absl::Nonnull<bool*> out) {
+bool SimpleAtob(absl::string_view str, bool* absl_nonnull out) {
   ABSL_RAW_CHECK(out != nullptr, "Output pointer must not be nullptr.");
   if (EqualsIgnoreCase(str, "true") || EqualsIgnoreCase(str, "t") ||
       EqualsIgnoreCase(str, "yes") || EqualsIgnoreCase(str, "y") ||
@@ -167,7 +168,7 @@ constexpr uint64_t kDivisionBy100Mul = 10486u;
 constexpr uint64_t kDivisionBy100Div = 1 << 20;
 
 // Encode functions write the ASCII output of input `n` to `out_str`.
-inline char* EncodeHundred(uint32_t n, absl::Nonnull<char*> out_str) {
+inline char* EncodeHundred(uint32_t n, char* absl_nonnull out_str) {
   int num_digits = static_cast<int>(n - 10) >> 8;
   uint32_t div10 = (n * kDivisionBy10Mul) / kDivisionBy10Div;
   uint32_t mod10 = n - 10u * div10;
@@ -177,7 +178,7 @@ inline char* EncodeHundred(uint32_t n, absl::Nonnull<char*> out_str) {
   return out_str + 2 + num_digits;
 }
 
-inline char* EncodeTenThousand(uint32_t n, absl::Nonnull<char*> out_str) {
+inline char* EncodeTenThousand(uint32_t n, char* absl_nonnull out_str) {
   // We split lower 2 digits and upper 2 digits of n into 2 byte consecutive
   // blocks. 123 ->  [\0\1][\0\23]. We divide by 10 both blocks
   // (it's 1 division + zeroing upper bits), and compute modulo 10 as well "in
@@ -233,8 +234,8 @@ inline uint64_t PrepareEightDigits(uint32_t i) {
   return tens;
 }
 
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE absl::Nonnull<char*> EncodeFullU32(
-    uint32_t n, absl::Nonnull<char*> out_str) {
+inline ABSL_ATTRIBUTE_ALWAYS_INLINE char* absl_nonnull EncodeFullU32(
+    uint32_t n, char* absl_nonnull out_str) {
   if (n < 10) {
     *out_str = static_cast<char>('0' + n);
     return out_str + 1;
@@ -283,7 +284,7 @@ inline ABSL_ATTRIBUTE_ALWAYS_INLINE char* EncodeFullU64(uint64_t i,
 
 }  // namespace
 
-void numbers_internal::PutTwoDigits(uint32_t i, absl::Nonnull<char*> buf) {
+void numbers_internal::PutTwoDigits(uint32_t i, char* absl_nonnull buf) {
   assert(i < 100);
   uint32_t base = kTwoZeroBytes;
   uint32_t div10 = (i * kDivisionBy10Mul) / kDivisionBy10Div;
@@ -292,15 +293,15 @@ void numbers_internal::PutTwoDigits(uint32_t i, absl::Nonnull<char*> buf) {
   little_endian::Store16(buf, static_cast<uint16_t>(base));
 }
 
-absl::Nonnull<char*> numbers_internal::FastIntToBuffer(
-    uint32_t n, absl::Nonnull<char*> out_str) {
+char* absl_nonnull numbers_internal::FastIntToBuffer(
+    uint32_t n, char* absl_nonnull out_str) {
   out_str = EncodeFullU32(n, out_str);
   *out_str = '\0';
   return out_str;
 }
 
-absl::Nonnull<char*> numbers_internal::FastIntToBuffer(
-    int32_t i, absl::Nonnull<char*> buffer) {
+char* absl_nonnull numbers_internal::FastIntToBuffer(
+    int32_t i, char* absl_nonnull buffer) {
   uint32_t u = static_cast<uint32_t>(i);
   if (i < 0) {
     *buffer++ = '-';
@@ -314,15 +315,15 @@ absl::Nonnull<char*> numbers_internal::FastIntToBuffer(
   return buffer;
 }
 
-absl::Nonnull<char*> numbers_internal::FastIntToBuffer(
-    uint64_t i, absl::Nonnull<char*> buffer) {
+char* absl_nonnull numbers_internal::FastIntToBuffer(
+    uint64_t i, char* absl_nonnull buffer) {
   buffer = EncodeFullU64(i, buffer);
   *buffer = '\0';
   return buffer;
 }
 
-absl::Nonnull<char*> numbers_internal::FastIntToBuffer(
-    int64_t i, absl::Nonnull<char*> buffer) {
+char* absl_nonnull numbers_internal::FastIntToBuffer(
+    int64_t i, char* absl_nonnull buffer) {
   uint64_t u = static_cast<uint64_t>(i);
   if (i < 0) {
     *buffer++ = '-';
@@ -463,7 +464,7 @@ static ExpDigits SplitToSix(const double value) {
   // Since we'd like to know if the fractional part of d is close to a half,
   // we multiply it by 65536 and see if the fractional part is close to 32768.
   // (The number doesn't have to be a power of two,but powers of two are faster)
-  uint64_t d64k = d * 65536;
+  uint64_t d64k = static_cast<uint64_t>(d * 65536);
   uint32_t dddddd;  // A 6-digit decimal integer.
   if ((d64k % 65536) == 32767 || (d64k % 65536) == 32768) {
     // OK, it's fairly likely that precision was lost above, which is
@@ -477,7 +478,8 @@ static ExpDigits SplitToSix(const double value) {
     // value we're representing, of course, is M.mmm... * 2^exp2.
     int exp2;
     double m = std::frexp(value, &exp2);
-    uint64_t mantissa = m * (32768.0 * 65536.0 * 65536.0 * 65536.0);
+    uint64_t mantissa =
+        static_cast<uint64_t>(m * (32768.0 * 65536.0 * 65536.0 * 65536.0));
     // std::frexp returns an m value in the range [0.5, 1.0), however we
     // can't multiply it by 2^64 and convert to an integer because some FPUs
     // throw an exception when converting an number higher than 2^63 into an
@@ -544,7 +546,7 @@ static ExpDigits SplitToSix(const double value) {
 // Helper function for fast formatting of floating-point.
 // The result is the same as "%g", a.k.a. "%.6g".
 size_t numbers_internal::SixDigitsToBuffer(double d,
-                                           absl::Nonnull<char*> const buffer) {
+                                           char* absl_nonnull const buffer) {
   static_assert(std::numeric_limits<float>::is_iec559,
                 "IEEE-754/IEC-559 support only");
 
@@ -674,7 +676,7 @@ namespace {
 // Represents integer values of digits.
 // Uses 36 to indicate an invalid character since we support
 // bases up to 36.
-static const int8_t kAsciiToInt[256] = {
+static constexpr std::array<int8_t, 256> kAsciiToInt = {
     36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,  // 16 36s.
     36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
     36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 0,  1,  2,  3,  4,  5,
@@ -692,9 +694,9 @@ static const int8_t kAsciiToInt[256] = {
 
 // Parse the sign and optional hex or oct prefix in text.
 inline bool safe_parse_sign_and_base(
-    absl::Nonnull<absl::string_view*> text /*inout*/,
-    absl::Nonnull<int*> base_ptr /*inout*/,
-    absl::Nonnull<bool*> negative_ptr /*output*/) {
+    absl::string_view* absl_nonnull text /*inout*/,
+    int* absl_nonnull base_ptr /*inout*/,
+    bool* absl_nonnull negative_ptr /*output*/) {
   if (text->data() == nullptr) {
     return false;
   }
@@ -979,7 +981,7 @@ ABSL_CONST_INIT const IntType LookupTables<IntType>::kVminOverBase[] =
 
 template <typename IntType>
 inline bool safe_parse_positive_int(absl::string_view text, int base,
-                                    absl::Nonnull<IntType*> value_p) {
+                                    IntType* absl_nonnull value_p) {
   IntType value = 0;
   const IntType vmax = std::numeric_limits<IntType>::max();
   assert(vmax > 0);
@@ -1016,7 +1018,7 @@ inline bool safe_parse_positive_int(absl::string_view text, int base,
 
 template <typename IntType>
 inline bool safe_parse_negative_int(absl::string_view text, int base,
-                                    absl::Nonnull<IntType*> value_p) {
+                                    IntType* absl_nonnull value_p) {
   IntType value = 0;
   const IntType vmin = std::numeric_limits<IntType>::min();
   assert(vmin < 0);
@@ -1061,7 +1063,7 @@ inline bool safe_parse_negative_int(absl::string_view text, int base,
 // http://pubs.opengroup.org/onlinepubs/9699919799/functions/strtol.html
 template <typename IntType>
 inline bool safe_int_internal(absl::string_view text,
-                              absl::Nonnull<IntType*> value_p, int base) {
+                              IntType* absl_nonnull value_p, int base) {
   *value_p = 0;
   bool negative;
   if (!safe_parse_sign_and_base(&text, &base, &negative)) {
@@ -1076,7 +1078,7 @@ inline bool safe_int_internal(absl::string_view text,
 
 template <typename IntType>
 inline bool safe_uint_internal(absl::string_view text,
-                               absl::Nonnull<IntType*> value_p, int base) {
+                               IntType* absl_nonnull value_p, int base) {
   *value_p = 0;
   bool negative;
   if (!safe_parse_sign_and_base(&text, &base, &negative) || negative) {
@@ -1110,32 +1112,52 @@ ABSL_CONST_INIT ABSL_DLL const char kHexTable[513] =
     "e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
     "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
 
-bool safe_strto32_base(absl::string_view text, absl::Nonnull<int32_t*> value,
+bool safe_strto8_base(absl::string_view text, int8_t* absl_nonnull value,
+                      int base) {
+  return safe_int_internal<int8_t>(text, value, base);
+}
+
+bool safe_strto16_base(absl::string_view text, int16_t* absl_nonnull value,
+                       int base) {
+  return safe_int_internal<int16_t>(text, value, base);
+}
+
+bool safe_strto32_base(absl::string_view text, int32_t* absl_nonnull value,
                        int base) {
   return safe_int_internal<int32_t>(text, value, base);
 }
 
-bool safe_strto64_base(absl::string_view text, absl::Nonnull<int64_t*> value,
+bool safe_strto64_base(absl::string_view text, int64_t* absl_nonnull value,
                        int base) {
   return safe_int_internal<int64_t>(text, value, base);
 }
 
-bool safe_strto128_base(absl::string_view text, absl::Nonnull<int128*> value,
+bool safe_strto128_base(absl::string_view text, int128* absl_nonnull value,
                         int base) {
   return safe_int_internal<absl::int128>(text, value, base);
 }
 
-bool safe_strtou32_base(absl::string_view text, absl::Nonnull<uint32_t*> value,
+bool safe_strtou8_base(absl::string_view text, uint8_t* absl_nonnull value,
+                       int base) {
+  return safe_uint_internal<uint8_t>(text, value, base);
+}
+
+bool safe_strtou16_base(absl::string_view text, uint16_t* absl_nonnull value,
+                        int base) {
+  return safe_uint_internal<uint16_t>(text, value, base);
+}
+
+bool safe_strtou32_base(absl::string_view text, uint32_t* absl_nonnull value,
                         int base) {
   return safe_uint_internal<uint32_t>(text, value, base);
 }
 
-bool safe_strtou64_base(absl::string_view text, absl::Nonnull<uint64_t*> value,
+bool safe_strtou64_base(absl::string_view text, uint64_t* absl_nonnull value,
                         int base) {
   return safe_uint_internal<uint64_t>(text, value, base);
 }
 
-bool safe_strtou128_base(absl::string_view text, absl::Nonnull<uint128*> value,
+bool safe_strtou128_base(absl::string_view text, uint128* absl_nonnull value,
                          int base) {
   return safe_uint_internal<absl::uint128>(text, value, base);
 }