@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/debugging/internal/bounded_utf8_length_sequence.h

@@ -1,126 +0,0 @@
-// Copyright 2024 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_DEBUGGING_INTERNAL_BOUNDED_UTF8_LENGTH_SEQUENCE_H_
-#define ABSL_DEBUGGING_INTERNAL_BOUNDED_UTF8_LENGTH_SEQUENCE_H_
-
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/numeric/bits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-// A sequence of up to max_elements integers between 1 and 4 inclusive, whose
-// insertion operation computes the sum of all the elements before the insertion
-// point.  This is useful in decoding Punycode, where one needs to know where in
-// a UTF-8 byte stream the n-th code point begins.
-//
-// BoundedUtf8LengthSequence is async-signal-safe and suitable for use in
-// symbolizing stack traces in a signal handler, provided max_elements is not
-// improvidently large.  For inputs of lengths accepted by the Rust demangler,
-// up to a couple hundred code points, InsertAndReturnSumOfPredecessors should
-// run in a few dozen clock cycles, on par with the other arithmetic required
-// for Punycode decoding.
-template <uint32_t max_elements>
-class BoundedUtf8LengthSequence {
- public:
-  // Constructs an empty sequence.
-  BoundedUtf8LengthSequence() = default;
-
-  // Inserts `utf_length` at position `index`, shifting any existing elements at
-  // or beyond `index` one position to the right.  If the sequence is already
-  // full, the rightmost element is discarded.
-  //
-  // Returns the sum of the elements at positions 0 to `index - 1` inclusive.
-  // If `index` is greater than the number of elements already inserted, the
-  // excess positions in the range count 1 apiece.
-  //
-  // REQUIRES: index < max_elements and 1 <= utf8_length <= 4.
-  uint32_t InsertAndReturnSumOfPredecessors(
-      uint32_t index, uint32_t utf8_length) {
-    // The caller shouldn't pass out-of-bounds inputs, but if it does happen,
-    // clamp the values and try to continue.  If we're being called from a
-    // signal handler, the last thing we want to do is crash.  Emitting
-    // malformed UTF-8 is a lesser evil.
-    if (index >= max_elements) index = max_elements - 1;
-    if (utf8_length == 0 || utf8_length > 4) utf8_length = 1;
-
-    const uint32_t word_index = index/32;
-    const uint32_t bit_index = 2 * (index % 32);
-    const uint64_t ones_bit = uint64_t{1} << bit_index;
-
-    // Compute the sum of predecessors.
-    //   - Each value from 1 to 4 is represented by a bit field with value from
-    //     0 to 3, so the desired sum is index plus the sum of the
-    //     representations actually stored.
-    //   - For each bit field, a set low bit should contribute 1 to the sum, and
-    //     a set high bit should contribute 2.
-    //   - Another way to say the same thing is that each set bit contributes 1,
-    //     and each set high bit contributes an additional 1.
-    //   - So the sum we want is index + popcount(everything) + popcount(bits in
-    //     odd positions).
-    const uint64_t odd_bits_mask = 0xaaaaaaaaaaaaaaaa;
-    const uint64_t lower_seminibbles_mask = ones_bit - 1;
-    const uint64_t higher_seminibbles_mask = ~lower_seminibbles_mask;
-    const uint64_t same_word_bits_below_insertion =
-        rep_[word_index] & lower_seminibbles_mask;
-    int full_popcount = absl::popcount(same_word_bits_below_insertion);
-    int odd_popcount =
-        absl::popcount(same_word_bits_below_insertion & odd_bits_mask);
-    for (uint32_t j = word_index; j > 0; --j) {
-      const uint64_t word_below_insertion = rep_[j - 1];
-      full_popcount += absl::popcount(word_below_insertion);
-      odd_popcount += absl::popcount(word_below_insertion & odd_bits_mask);
-    }
-    const uint32_t sum_of_predecessors =
-        index + static_cast<uint32_t>(full_popcount + odd_popcount);
-
-    // Now insert utf8_length's representation, shifting successors up one
-    // place.
-    for (uint32_t j = max_elements/32 - 1; j > word_index; --j) {
-      rep_[j] = (rep_[j] << 2) | (rep_[j - 1] >> 62);
-    }
-    rep_[word_index] =
-        (rep_[word_index] & lower_seminibbles_mask) |
-        (uint64_t{utf8_length - 1} << bit_index) |
-        ((rep_[word_index] & higher_seminibbles_mask) << 2);
-
-    return sum_of_predecessors;
-  }
-
- private:
-  // If the (32 * i + j)-th element of the represented sequence has the value k
-  // (0 <= j < 32, 1 <= k <= 4), then bits 2 * j and 2 * j + 1 of rep_[i]
-  // contain the seminibble (k - 1).
-  //
-  // In particular, the zero-initialization of rep_ makes positions not holding
-  // any inserted element count as 1 in InsertAndReturnSumOfPredecessors.
-  //
-  // Example: rep_ = {0xb1, ... the rest zeroes ...} represents the sequence
-  // (2, 1, 4, 3, ... the rest 1's ...).  Constructing the sequence of Unicode
-  // code points "Àa🂻中" = {U+00C0, U+0061, U+1F0BB, U+4E2D} (among many
-  // other examples) would yield this value of rep_.
-  static_assert(max_elements > 0 && max_elements % 32 == 0,
-                "max_elements must be a positive multiple of 32");
-  uint64_t rep_[max_elements/32] = {};
-};
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_DEBUGGING_INTERNAL_BOUNDED_UTF8_LENGTH_SEQUENCE_H_

package/deps/abseil-cpp/absl/debugging/internal/bounded_utf8_length_sequence_test.cc

@@ -1,126 +0,0 @@
-// Copyright 2024 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/debugging/internal/bounded_utf8_length_sequence.h"
-
-#include <cstdint>
-
-#include "gtest/gtest.h"
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-namespace {
-
-TEST(BoundedUtf8LengthSequenceTest, RemembersAValueOfOneCorrectly) {
-  BoundedUtf8LengthSequence<32> seq;
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 1), 0);
-  EXPECT_EQ(seq.InsertAndReturnSumOfPredecessors(1, 1), 1);
-}
-
-TEST(BoundedUtf8LengthSequenceTest, RemembersAValueOfTwoCorrectly) {
-  BoundedUtf8LengthSequence<32> seq;
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 2), 0);
-  EXPECT_EQ(seq.InsertAndReturnSumOfPredecessors(1, 1), 2);
-}
-
-TEST(BoundedUtf8LengthSequenceTest, RemembersAValueOfThreeCorrectly) {
-  BoundedUtf8LengthSequence<32> seq;
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 3), 0);
-  EXPECT_EQ(seq.InsertAndReturnSumOfPredecessors(1, 1), 3);
-}
-
-TEST(BoundedUtf8LengthSequenceTest, RemembersAValueOfFourCorrectly) {
-  BoundedUtf8LengthSequence<32> seq;
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 4), 0);
-  EXPECT_EQ(seq.InsertAndReturnSumOfPredecessors(1, 1), 4);
-}
-
-TEST(BoundedUtf8LengthSequenceTest, RemembersSeveralAppendedValues) {
-  BoundedUtf8LengthSequence<32> seq;
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 1), 0);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(1, 4), 1);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(2, 2), 5);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(3, 3), 7);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(4, 1), 10);
-}
-
-TEST(BoundedUtf8LengthSequenceTest, RemembersSeveralPrependedValues) {
-  BoundedUtf8LengthSequence<32> seq;
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 4), 0);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 3), 0);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 2), 0);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 1), 0);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(4, 1), 10);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(3, 1), 6);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(2, 1), 3);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(1, 1), 1);
-}
-
-TEST(BoundedUtf8LengthSequenceTest, RepeatedInsertsShiftValuesOutTheRightEnd) {
-  BoundedUtf8LengthSequence<32> seq;
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 2), 0);
-  for (uint32_t i = 1; i < 31; ++i) {
-    ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 1), 0)
-        << "while moving the 2 into position " << i;
-    ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(31, 1), 32)
-        << "after moving the 2 into position " << i;
-  }
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 1), 0)
-      << "while moving the 2 into position 31";
-  EXPECT_EQ(seq.InsertAndReturnSumOfPredecessors(31, 1), 31)
-      << "after moving the 2 into position 31";
-}
-
-TEST(BoundedUtf8LengthSequenceTest, InsertsIntoWord1LeaveWord0Untouched) {
-  BoundedUtf8LengthSequence<64> seq;
-  for (uint32_t i = 0; i < 32; ++i) {
-    ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(i, 2), 2 * i)
-        << "at index " << i;
-  }
-  EXPECT_EQ(seq.InsertAndReturnSumOfPredecessors(32, 1), 64);
-  EXPECT_EQ(seq.InsertAndReturnSumOfPredecessors(32, 1), 64);
-}
-
-TEST(BoundedUtf8LengthSequenceTest, InsertsIntoWord0ShiftValuesIntoWord1) {
-  BoundedUtf8LengthSequence<64> seq;
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(29, 2), 29);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(30, 3), 31);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(31, 4), 34);
-
-  // Pushing two 1's on the front moves the 3 and 4 into the high word.
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 1), 0);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 1), 0);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(34, 1), 31 + 2 + 3 + 4);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(32, 1), 31 + 2);
-}
-
-TEST(BoundedUtf8LengthSequenceTest, ValuesAreShiftedCorrectlyAmongThreeWords) {
-  BoundedUtf8LengthSequence<96> seq;
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(31, 3), 31);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(63, 4), 62 + 3);
-
-  // This insertion moves both the 3 and the 4 up a word.
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(0, 1), 0);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(65, 1), 63 + 3 + 4);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(64, 1), 63 + 3);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(33, 1), 32 + 3);
-  ASSERT_EQ(seq.InsertAndReturnSumOfPredecessors(32, 1), 32);
-}
-
-}  // namespace
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/debugging/internal/decode_rust_punycode.cc

@@ -1,258 +0,0 @@
-// Copyright 2024 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/debugging/internal/decode_rust_punycode.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-
-#include "absl/base/config.h"
-#include "absl/base/nullability.h"
-#include "absl/debugging/internal/bounded_utf8_length_sequence.h"
-#include "absl/debugging/internal/utf8_for_code_point.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-namespace {
-
-// Decoding Punycode requires repeated random-access insertion into a stream of
-// variable-length UTF-8 code-point encodings.  We need this to be tolerably
-// fast (no N^2 slowdown for unfortunate inputs), and we can't allocate any data
-// structures on the heap (async-signal-safety).
-//
-// It is pragmatic to impose a moderately low limit on the identifier length and
-// bail out if we ever hit it.  Then BoundedUtf8LengthSequence efficiently
-// determines where to insert the next code point, and memmove efficiently makes
-// room for it.
-//
-// The chosen limit is a round number several times larger than identifiers
-// expected in practice, yet still small enough that a memmove of this many
-// UTF-8 characters is not much more expensive than the division and modulus
-// operations that Punycode decoding requires.
-constexpr uint32_t kMaxChars = 256;
-
-// Constants from RFC 3492 section 5.
-constexpr uint32_t kBase = 36, kTMin = 1, kTMax = 26, kSkew = 38, kDamp = 700;
-
-constexpr uint32_t kMaxCodePoint = 0x10ffff;
-
-// Overflow threshold in DecodeRustPunycode's inner loop; see comments there.
-constexpr uint32_t kMaxI = 1 << 30;
-
-// If punycode_begin .. punycode_end begins with a prefix matching the regular
-// expression [0-9a-zA-Z_]+_, removes that prefix, copies all but the final
-// underscore into out_begin .. out_end, sets num_ascii_chars to the number of
-// bytes copied, and returns true.  (A prefix of this sort represents the
-// nonempty subsequence of ASCII characters in the corresponding plaintext.)
-//
-// If punycode_begin .. punycode_end does not contain an underscore, sets
-// num_ascii_chars to zero and returns true.  (The encoding of a plaintext
-// without any ASCII characters does not carry such a prefix.)
-//
-// Returns false and zeroes num_ascii_chars on failure (either parse error or
-// not enough space in the output buffer).
-bool ConsumeOptionalAsciiPrefix(const char*& punycode_begin,
-                                const char* const punycode_end,
-                                char* const out_begin,
-                                char* const out_end,
-                                uint32_t& num_ascii_chars) {
-  num_ascii_chars = 0;
-
-  // Remember the last underscore if any.  Also use the same string scan to
-  // reject any ASCII bytes that do not belong in an identifier, including NUL,
-  // as well as non-ASCII bytes, which should have been delta-encoded instead.
-  int last_underscore = -1;
-  for (int i = 0; i < punycode_end - punycode_begin; ++i) {
-    const char c = punycode_begin[i];
-    if (c == '_') {
-      last_underscore = i;
-      continue;
-    }
-    // We write out the meaning of absl::ascii_isalnum rather than call that
-    // function because its documentation does not promise it will remain
-    // async-signal-safe under future development.
-    if ('a' <= c && c <= 'z') continue;
-    if ('A' <= c && c <= 'Z') continue;
-    if ('0' <= c && c <= '9') continue;
-    return false;
-  }
-
-  // If there was no underscore, that means there were no ASCII characters in
-  // the plaintext, so there is no prefix to consume.  Our work is done.
-  if (last_underscore < 0) return true;
-
-  // Otherwise there will be an underscore delimiter somewhere.  It can't be
-  // initial because then there would be no ASCII characters to its left, and no
-  // delimiter would have been added in that case.
-  if (last_underscore == 0) return false;
-
-  // Any other position is reasonable.  Make sure there's room in the buffer.
-  if (last_underscore + 1 > out_end - out_begin) return false;
-
-  // Consume and write out the ASCII characters.
-  num_ascii_chars = static_cast<uint32_t>(last_underscore);
-  std::memcpy(out_begin, punycode_begin, num_ascii_chars);
-  out_begin[num_ascii_chars] = '\0';
-  punycode_begin += num_ascii_chars + 1;
-  return true;
-}
-
-// Returns the value of `c` as a base-36 digit according to RFC 3492 section 5,
-// or -1 if `c` is not such a digit.
-int DigitValue(char c) {
-  if ('0' <= c && c <= '9') return c - '0' + 26;
-  if ('a' <= c && c <= 'z') return c - 'a';
-  if ('A' <= c && c <= 'Z') return c - 'A';
-  return -1;
-}
-
-// Consumes the next delta encoding from punycode_begin .. punycode_end,
-// updating i accordingly.  Returns true on success.  Returns false on parse
-// failure or arithmetic overflow.
-bool ScanNextDelta(const char*& punycode_begin, const char* const punycode_end,
-                   uint32_t bias, uint32_t& i) {
-  uint64_t w = 1;  // 64 bits to prevent overflow in w *= kBase - t
-
-  // "for k = base to infinity in steps of base do begin ... end" in RFC 3492
-  // section 6.2.  Each loop iteration scans one digit of the delta.
-  for (uint32_t k = kBase; punycode_begin != punycode_end; k += kBase) {
-    const int digit_value = DigitValue(*punycode_begin++);
-    if (digit_value < 0) return false;
-
-    // Compute this in 64-bit arithmetic so we can check for overflow afterward.
-    const uint64_t new_i = i + static_cast<uint64_t>(digit_value) * w;
-
-    // Valid deltas are bounded by (#chars already emitted) * kMaxCodePoint, but
-    // invalid input could encode an arbitrarily large delta.  Nip that in the
-    // bud here.
-    static_assert(
-        kMaxI >= kMaxChars * kMaxCodePoint,
-        "kMaxI is too small to prevent spurious failures on good input");
-    if (new_i > kMaxI) return false;
-
-    static_assert(
-        kMaxI < (uint64_t{1} << 32),
-        "Make kMaxI smaller or i 64 bits wide to prevent silent wraparound");
-    i = static_cast<uint32_t>(new_i);
-
-    // Compute the threshold that determines whether this is the last digit and
-    // (if not) what the next digit's place value will be.  This logic from RFC
-    // 3492 section 6.2 is explained in section 3.3.
-    uint32_t t;
-    if (k <= bias + kTMin) {
-      t = kTMin;
-    } else if (k >= bias + kTMax) {
-      t = kTMax;
-    } else {
-      t = k - bias;
-    }
-    if (static_cast<uint32_t>(digit_value) < t) return true;
-
-    // If this gets too large, the range check on new_i in the next iteration
-    // will catch it.  We know this multiplication will not overwrap because w
-    // is 64 bits wide.
-    w *= kBase - t;
-  }
-  return false;
-}
-
-}  // namespace
-
-char* absl_nullable DecodeRustPunycode(DecodeRustPunycodeOptions options) {
-  const char* punycode_begin = options.punycode_begin;
-  const char* const punycode_end = options.punycode_end;
-  char* const out_begin = options.out_begin;
-  char* const out_end = options.out_end;
-
-  // Write a NUL terminator first.  Later memcpy calls will keep bumping it
-  // along to its new right place.
-  const size_t out_size = static_cast<size_t>(out_end - out_begin);
-  if (out_size == 0) return nullptr;
-  *out_begin = '\0';
-
-  // RFC 3492 section 6.2 begins here.  We retain the names of integer variables
-  // appearing in that text.
-  uint32_t n = 128, i = 0, bias = 72, num_chars = 0;
-
-  // If there are any ASCII characters, consume them and their trailing
-  // underscore delimiter.
-  if (!ConsumeOptionalAsciiPrefix(punycode_begin, punycode_end,
-                                  out_begin, out_end, num_chars)) {
-    return nullptr;
-  }
-  uint32_t total_utf8_bytes = num_chars;
-
-  BoundedUtf8LengthSequence<kMaxChars> utf8_lengths;
-
-  // "while the input is not exhausted do begin ... end"
-  while (punycode_begin != punycode_end) {
-    if (num_chars >= kMaxChars) return nullptr;
-
-    const uint32_t old_i = i;
-
-    if (!ScanNextDelta(punycode_begin, punycode_end, bias, i)) return nullptr;
-
-    // Update bias as in RFC 3492 section 6.1.  (We have inlined adapt.)
-    uint32_t delta = i - old_i;
-    delta /= (old_i == 0 ? kDamp : 2);
-    delta += delta/(num_chars + 1);
-    bias = 0;
-    while (delta > ((kBase - kTMin) * kTMax)/2) {
-      delta /= kBase - kTMin;
-      bias += kBase;
-    }
-    bias += ((kBase - kTMin + 1) * delta)/(delta + kSkew);
-
-    // Back in section 6.2, compute the new code point and insertion index.
-    static_assert(
-        kMaxI + kMaxCodePoint < (uint64_t{1} << 32),
-        "Make kMaxI smaller or n 64 bits wide to prevent silent wraparound");
-    n += i/(num_chars + 1);
-    i %= num_chars + 1;
-
-    // To actually insert, we need to convert the code point n to UTF-8 and the
-    // character index i to an index into the byte stream emitted so far.  First
-    // prepare the UTF-8 encoding for n, rejecting surrogates, overlarge values,
-    // and anything that won't fit into the remaining output storage.
-    Utf8ForCodePoint utf8_for_code_point(n);
-    if (!utf8_for_code_point.ok()) return nullptr;
-    if (total_utf8_bytes + utf8_for_code_point.length + 1 > out_size) {
-      return nullptr;
-    }
-
-    // Now insert the new character into both our length map and the output.
-    uint32_t n_index =
-        utf8_lengths.InsertAndReturnSumOfPredecessors(
-            i, utf8_for_code_point.length);
-    std::memmove(
-        out_begin + n_index + utf8_for_code_point.length, out_begin + n_index,
-        total_utf8_bytes + 1 - n_index);
-    std::memcpy(out_begin + n_index, utf8_for_code_point.bytes,
-                utf8_for_code_point.length);
-    total_utf8_bytes += utf8_for_code_point.length;
-    ++num_chars;
-
-    // Finally, advance to the next state before continuing.
-    ++i;
-  }
-
-  return out_begin + total_utf8_bytes;
-}
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/debugging/internal/decode_rust_punycode.h

@@ -1,55 +0,0 @@
-// Copyright 2024 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_DEBUGGING_INTERNAL_DECODE_RUST_PUNYCODE_H_
-#define ABSL_DEBUGGING_INTERNAL_DECODE_RUST_PUNYCODE_H_
-
-#include "absl/base/config.h"
-#include "absl/base/nullability.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-struct DecodeRustPunycodeOptions {
-  const char* absl_nonnull punycode_begin;
-  const char* absl_nonnull punycode_end;
-  char* absl_nonnull out_begin;
-  char* absl_nonnull out_end;
-};
-
-// Given Rust Punycode in `punycode_begin .. punycode_end`, writes the
-// corresponding UTF-8 plaintext into `out_begin .. out_end`, followed by a NUL
-// character, and returns a pointer to that final NUL on success.  On failure
-// returns a null pointer, and the contents of `out_begin .. out_end` are
-// unspecified.
-//
-// Failure occurs in precisely these cases:
-//   - Any input byte does not match [0-9a-zA-Z_].
-//   - The first input byte is an underscore, but no other underscore appears in
-//     the input.
-//   - The delta sequence does not represent a valid sequence of code-point
-//     insertions.
-//   - The plaintext would contain more than 256 code points.
-//
-// DecodeRustPunycode is async-signal-safe with bounded runtime and a small
-// stack footprint, making it suitable for use in demangling Rust symbol names
-// from a signal handler.
-char* absl_nullable DecodeRustPunycode(DecodeRustPunycodeOptions options);
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_DEBUGGING_INTERNAL_DECODE_RUST_PUNYCODE_H_