blame: source/misc/embedded_libs/fmt-11.0.2/include/fmt/format.h

/*

  Formatting library for C++

  Copyright (c) 2012 - present, Victor Zverovich

  Permission is hereby granted, free of charge, to any person obtaining

  a copy of this software and associated documentation files (the

  "Software"), to deal in the Software without restriction, including

  without limitation the rights to use, copy, modify, merge, publish,

  distribute, sublicense, and/or sell copies of the Software, and to

  permit persons to whom the Software is furnished to do so, subject to

  the following conditions:

  The above copyright notice and this permission notice shall be

  included in all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

  --- Optional exception to the license ---

  As an exception, if, as a result of your compiling your source code, portions

  of this Software are embedded into a machine-executable object form of such

  source code, you may redistribute such embedded portions in such object form

  without including the above copyright and permission notices.

 */

#ifndef FMT_FORMAT_H_

#define FMT_FORMAT_H_

#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES

#  define _LIBCPP_REMOVE_TRANSITIVE_INCLUDES

#  define FMT_REMOVE_TRANSITIVE_INCLUDES

#endif

#include "base.h"

#ifndef FMT_MODULE

#  include <cmath>             // std::signbit

#  include <cstdint>           // uint32_t

#  include <cstring>           // std::memcpy

#  include <initializer_list>  // std::initializer_list

#  include <limits>            // std::numeric_limits

#  if defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI)

// Workaround for pre gcc 5 libstdc++.

#    include <memory>  // std::allocator_traits

#  endif

#  include <stdexcept>     // std::runtime_error

#  include <string>        // std::string

#  include <system_error>  // std::system_error

// Checking FMT_CPLUSPLUS for warning suppression in MSVC.

#  if FMT_HAS_INCLUDE(<bit>) && FMT_CPLUSPLUS > 201703L

#    include <bit>  // std::bit_cast

#  endif

// libc++ supports string_view in pre-c++17.

#  if FMT_HAS_INCLUDE(<string_view>) && \

      (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION))

#    include <string_view>

#    define FMT_USE_STRING_VIEW

#  endif

#endif  // FMT_MODULE

#if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L

#  define FMT_INLINE_VARIABLE inline

#else

#  define FMT_INLINE_VARIABLE

#endif

#ifndef FMT_NO_UNIQUE_ADDRESS

#  if FMT_CPLUSPLUS >= 202002L

#    if FMT_HAS_CPP_ATTRIBUTE(no_unique_address)

#      define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]]

// VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485).

#    elif (FMT_MSC_VERSION >= 1929) && !FMT_CLANG_VERSION

#      define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]

#    endif

#  endif

#endif

#ifndef FMT_NO_UNIQUE_ADDRESS

#  define FMT_NO_UNIQUE_ADDRESS

#endif

// Visibility when compiled as a shared library/object.

#if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)

#  define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value)

#else

#  define FMT_SO_VISIBILITY(value)

#endif

#ifdef __has_builtin

#  define FMT_HAS_BUILTIN(x) __has_builtin(x)

#else

#  define FMT_HAS_BUILTIN(x) 0

#endif

#if FMT_GCC_VERSION || FMT_CLANG_VERSION

#  define FMT_NOINLINE __attribute__((noinline))

#else

#  define FMT_NOINLINE

#endif

namespace std {

template <> struct iterator_traits<fmt::appender> {

  using iterator_category = output_iterator_tag;

  using value_type = char;

};

}  // namespace std

#ifndef FMT_THROW

#  if FMT_EXCEPTIONS

#    if FMT_MSC_VERSION || defined(__NVCC__)

FMT_BEGIN_NAMESPACE

namespace detail {

template <typename Exception> inline void do_throw(const Exception& x) {

  // Silence unreachable code warnings in MSVC and NVCC because these

  // are nearly impossible to fix in a generic code.

  volatile bool b = true;

  if (b) throw x;

}

}  // namespace detail

FMT_END_NAMESPACE

#      define FMT_THROW(x) detail::do_throw(x)

#    else

#      define FMT_THROW(x) throw x

#    endif

#  else

#    define FMT_THROW(x) \

      ::fmt::detail::assert_fail(__FILE__, __LINE__, (x).what())

#  endif

#endif

#ifndef FMT_MAYBE_UNUSED

#  if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused)

#    define FMT_MAYBE_UNUSED [[maybe_unused]]

#  else

#    define FMT_MAYBE_UNUSED

#  endif

#endif

#ifndef FMT_USE_USER_DEFINED_LITERALS

// EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs.

//

// GCC before 4.9 requires a space in `operator"" _a` which is invalid in later

// compiler versions.

#  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 409 || \

       FMT_MSC_VERSION >= 1900) &&                                     \

      (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480)

#    define FMT_USE_USER_DEFINED_LITERALS 1

#  else

#    define FMT_USE_USER_DEFINED_LITERALS 0

#  endif

#endif

// Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of

// integer formatter template instantiations to just one by only using the

// largest integer type. This results in a reduction in binary size but will

// cause a decrease in integer formatting performance.

#if !defined(FMT_REDUCE_INT_INSTANTIATIONS)

#  define FMT_REDUCE_INT_INSTANTIATIONS 0

#endif

// __builtin_clz is broken in clang with Microsoft CodeGen:

// https://github.com/fmtlib/fmt/issues/519.

#if !FMT_MSC_VERSION

#  if FMT_HAS_BUILTIN(__builtin_clz) || FMT_GCC_VERSION || FMT_ICC_VERSION

#    define FMT_BUILTIN_CLZ(n) __builtin_clz(n)

#  endif

#  if FMT_HAS_BUILTIN(__builtin_clzll) || FMT_GCC_VERSION || FMT_ICC_VERSION

#    define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)

#  endif

#endif

// __builtin_ctz is broken in Intel Compiler Classic on Windows:

// https://github.com/fmtlib/fmt/issues/2510.

#ifndef __ICL

#  if FMT_HAS_BUILTIN(__builtin_ctz) || FMT_GCC_VERSION || FMT_ICC_VERSION || \

      defined(__NVCOMPILER)

#    define FMT_BUILTIN_CTZ(n) __builtin_ctz(n)

#  endif

#  if FMT_HAS_BUILTIN(__builtin_ctzll) || FMT_GCC_VERSION || \

      FMT_ICC_VERSION || defined(__NVCOMPILER)

#    define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n)

#  endif

#endif

#if FMT_MSC_VERSION

#  include <intrin.h>  // _BitScanReverse[64], _BitScanForward[64], _umul128

#endif

// Some compilers masquerade as both MSVC and GCC-likes or otherwise support

// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the

// MSVC intrinsics if the clz and clzll builtins are not available.

#if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) && \

    !defined(FMT_BUILTIN_CTZLL)

FMT_BEGIN_NAMESPACE

namespace detail {

// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.

#  if !defined(__clang__)

#    pragma intrinsic(_BitScanForward)

#    pragma intrinsic(_BitScanReverse)

#    if defined(_WIN64)

#      pragma intrinsic(_BitScanForward64)

#      pragma intrinsic(_BitScanReverse64)

#    endif

#  endif

inline auto clz(uint32_t x) -> int {

  unsigned long r = 0;

  _BitScanReverse(&r, x);

  FMT_ASSERT(x != 0, "");

  // Static analysis complains about using uninitialized data

  // "r", but the only way that can happen is if "x" is 0,

  // which the callers guarantee to not happen.

  FMT_MSC_WARNING(suppress : 6102)

  return 31 ^ static_cast<int>(r);

}

#  define FMT_BUILTIN_CLZ(n) detail::clz(n)

inline auto clzll(uint64_t x) -> int {

  unsigned long r = 0;

#  ifdef _WIN64

  _BitScanReverse64(&r, x);

#  else

  // Scan the high 32 bits.

  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))

    return 63 ^ static_cast<int>(r + 32);

  // Scan the low 32 bits.

  _BitScanReverse(&r, static_cast<uint32_t>(x));

#  endif

  FMT_ASSERT(x != 0, "");

  FMT_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.

  return 63 ^ static_cast<int>(r);

}

#  define FMT_BUILTIN_CLZLL(n) detail::clzll(n)

inline auto ctz(uint32_t x) -> int {

  unsigned long r = 0;

  _BitScanForward(&r, x);

  FMT_ASSERT(x != 0, "");

  FMT_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.

  return static_cast<int>(r);

}

#  define FMT_BUILTIN_CTZ(n) detail::ctz(n)

inline auto ctzll(uint64_t x) -> int {

  unsigned long r = 0;

  FMT_ASSERT(x != 0, "");

  FMT_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.

#  ifdef _WIN64

  _BitScanForward64(&r, x);

#  else

  // Scan the low 32 bits.

  if (_BitScanForward(&r, static_cast<uint32_t>(x))) return static_cast<int>(r);

  // Scan the high 32 bits.

  _BitScanForward(&r, static_cast<uint32_t>(x >> 32));

  r += 32;

#  endif

  return static_cast<int>(r);

}

#  define FMT_BUILTIN_CTZLL(n) detail::ctzll(n)

}  // namespace detail

FMT_END_NAMESPACE

#endif

FMT_BEGIN_NAMESPACE

template <typename Char, typename Traits, typename Allocator>

struct is_contiguous<std::basic_string<Char, Traits, Allocator>>

    : std::true_type {};

namespace detail {

FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {

  ignore_unused(condition);

#ifdef FMT_FUZZ

  if (condition) throw std::runtime_error("fuzzing limit reached");

#endif

}

#if defined(FMT_USE_STRING_VIEW)

template <typename Char> using std_string_view = std::basic_string_view<Char>;

#else

template <typename T> struct std_string_view {};

#endif

// Implementation of std::bit_cast for pre-C++20.

template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) == sizeof(From))>

FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To {

#ifdef __cpp_lib_bit_cast

  if (is_constant_evaluated()) return std::bit_cast<To>(from);

#endif

  auto to = To();

  // The cast suppresses a bogus -Wclass-memaccess on GCC.

  std::memcpy(static_cast<void*>(&to), &from, sizeof(to));

  return to;

}

inline auto is_big_endian() -> bool {

#ifdef _WIN32

  return false;

#elif defined(__BIG_ENDIAN__)

  return true;

#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__)

  return __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__;

#else

  struct bytes {

    char data[sizeof(int)];

  };

  return bit_cast<bytes>(1).data[0] == 0;

#endif

}

class uint128_fallback {

 private:

  uint64_t lo_, hi_;

 public:

  constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {}

  constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {}

  constexpr auto high() const noexcept -> uint64_t { return hi_; }

  constexpr auto low() const noexcept -> uint64_t { return lo_; }

  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>

  constexpr explicit operator T() const {

    return static_cast<T>(lo_);

  }

  friend constexpr auto operator==(const uint128_fallback& lhs,

                                   const uint128_fallback& rhs) -> bool {

    return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_;

  }

  friend constexpr auto operator!=(const uint128_fallback& lhs,

                                   const uint128_fallback& rhs) -> bool {

    return !(lhs == rhs);

  }

  friend constexpr auto operator>(const uint128_fallback& lhs,

                                  const uint128_fallback& rhs) -> bool {

    return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_;

  }

  friend constexpr auto operator|(const uint128_fallback& lhs,

                                  const uint128_fallback& rhs)

      -> uint128_fallback {

    return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_};

  }

  friend constexpr auto operator&(const uint128_fallback& lhs,

                                  const uint128_fallback& rhs)

      -> uint128_fallback {

    return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_};

  }

  friend constexpr auto operator~(const uint128_fallback& n)

      -> uint128_fallback {

    return {~n.hi_, ~n.lo_};

  }

  friend auto operator+(const uint128_fallback& lhs,

                        const uint128_fallback& rhs) -> uint128_fallback {

    auto result = uint128_fallback(lhs);

    result += rhs;

    return result;

  }

  friend auto operator*(const uint128_fallback& lhs, uint32_t rhs)

      -> uint128_fallback {

    FMT_ASSERT(lhs.hi_ == 0, "");

    uint64_t hi = (lhs.lo_ >> 32) * rhs;

    uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs;

    uint64_t new_lo = (hi << 32) + lo;

    return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo};

  }

  friend auto operator-(const uint128_fallback& lhs, uint64_t rhs)

      -> uint128_fallback {

    return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs};

  }

  FMT_CONSTEXPR auto operator>>(int shift) const -> uint128_fallback {

    if (shift == 64) return {0, hi_};

    if (shift > 64) return uint128_fallback(0, hi_) >> (shift - 64);

    return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)};

  }

  FMT_CONSTEXPR auto operator<<(int shift) const -> uint128_fallback {

    if (shift == 64) return {lo_, 0};

    if (shift > 64) return uint128_fallback(lo_, 0) << (shift - 64);

    return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)};

  }

  FMT_CONSTEXPR auto operator>>=(int shift) -> uint128_fallback& {

    return *this = *this >> shift;

  }

  FMT_CONSTEXPR void operator+=(uint128_fallback n) {

    uint64_t new_lo = lo_ + n.lo_;

    uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0);

    FMT_ASSERT(new_hi >= hi_, "");

    lo_ = new_lo;

    hi_ = new_hi;

  }

  FMT_CONSTEXPR void operator&=(uint128_fallback n) {

    lo_ &= n.lo_;

    hi_ &= n.hi_;

  }

  FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& {

    if (is_constant_evaluated()) {

      lo_ += n;

      hi_ += (lo_ < n ? 1 : 0);

      return *this;

    }

#if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__)

    unsigned long long carry;

    lo_ = __builtin_addcll(lo_, n, 0, &carry);

    hi_ += carry;

#elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__)

    unsigned long long result;

    auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result);

    lo_ = result;

    hi_ += carry;

#elif defined(_MSC_VER) && defined(_M_X64)

    auto carry = _addcarry_u64(0, lo_, n, &lo_);

    _addcarry_u64(carry, hi_, 0, &hi_);

#else

    lo_ += n;

    hi_ += (lo_ < n ? 1 : 0);

#endif

    return *this;

  }

};

using uint128_t = conditional_t<FMT_USE_INT128, uint128_opt, uint128_fallback>;

#ifdef UINTPTR_MAX

using uintptr_t = ::uintptr_t;

#else

using uintptr_t = uint128_t;

#endif

// Returns the largest possible value for type T. Same as

// std::numeric_limits<T>::max() but shorter and not affected by the max macro.

template <typename T> constexpr auto max_value() -> T {

  return (std::numeric_limits<T>::max)();

}

template <typename T> constexpr auto num_bits() -> int {

  return std::numeric_limits<T>::digits;

}

// std::numeric_limits<T>::digits may return 0 for 128-bit ints.

template <> constexpr auto num_bits<int128_opt>() -> int { return 128; }

template <> constexpr auto num_bits<uint128_opt>() -> int { return 128; }

template <> constexpr auto num_bits<uint128_fallback>() -> int { return 128; }

// A heterogeneous bit_cast used for converting 96-bit long double to uint128_t

// and 128-bit pointers to uint128_fallback.

template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) > sizeof(From))>

inline auto bit_cast(const From& from) -> To {

  constexpr auto size = static_cast<int>(sizeof(From) / sizeof(unsigned));

  struct data_t {

    unsigned value[static_cast<unsigned>(size)];

  } data = bit_cast<data_t>(from);

  auto result = To();

  if (const_check(is_big_endian())) {

    for (int i = 0; i < size; ++i)

      result = (result << num_bits<unsigned>()) | data.value[i];

  } else {

    for (int i = size - 1; i >= 0; --i)

      result = (result << num_bits<unsigned>()) | data.value[i];

  }

  return result;

}

template <typename UInt>

FMT_CONSTEXPR20 inline auto countl_zero_fallback(UInt n) -> int {

  int lz = 0;

  constexpr UInt msb_mask = static_cast<UInt>(1) << (num_bits<UInt>() - 1);

  for (; (n & msb_mask) == 0; n <<= 1) lz++;

  return lz;

}

FMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int {

#ifdef FMT_BUILTIN_CLZ

  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZ(n);

#endif

  return countl_zero_fallback(n);

}

FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int {

#ifdef FMT_BUILTIN_CLZLL

  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n);

#endif

  return countl_zero_fallback(n);

}

FMT_INLINE void assume(bool condition) {

  (void)condition;

#if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION

  __builtin_assume(condition);

#elif FMT_GCC_VERSION

  if (!condition) __builtin_unreachable();

#endif

}

// An approximation of iterator_t for pre-C++20 systems.

template <typename T>

using iterator_t = decltype(std::begin(std::declval<T&>()));

template <typename T> using sentinel_t = decltype(std::end(std::declval<T&>()));

// A workaround for std::string not having mutable data() until C++17.

template <typename Char>

inline auto get_data(std::basic_string<Char>& s) -> Char* {

  return &s[0];

}

template <typename Container>

inline auto get_data(Container& c) -> typename Container::value_type* {

  return c.data();

}

// Attempts to reserve space for n extra characters in the output range.

// Returns a pointer to the reserved range or a reference to it.

template <typename OutputIt,

          FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value&&

                            is_contiguous<typename OutputIt::container>::value)>

#if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION

__attribute__((no_sanitize("undefined")))

#endif

inline auto

reserve(OutputIt it, size_t n) -> typename OutputIt::value_type* {

  auto& c = get_container(it);

  size_t size = c.size();

  c.resize(size + n);

  return get_data(c) + size;

}

template <typename T>

inline auto reserve(basic_appender<T> it, size_t n) -> basic_appender<T> {

  buffer<T>& buf = get_container(it);

  buf.try_reserve(buf.size() + n);

  return it;

}

template <typename Iterator>

constexpr auto reserve(Iterator& it, size_t) -> Iterator& {

  return it;

}

template <typename OutputIt>

using reserve_iterator =

    remove_reference_t<decltype(reserve(std::declval<OutputIt&>(), 0))>;

template <typename T, typename OutputIt>

constexpr auto to_pointer(OutputIt, size_t) -> T* {

  return nullptr;

}

template <typename T> auto to_pointer(basic_appender<T> it, size_t n) -> T* {

  buffer<T>& buf = get_container(it);

  auto size = buf.size();

  buf.try_reserve(size + n);

  if (buf.capacity() < size + n) return nullptr;

  buf.try_resize(size + n);

  return buf.data() + size;

}

template <typename OutputIt,

          FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value&&

                            is_contiguous<typename OutputIt::container>::value)>

inline auto base_iterator(OutputIt it,

                          typename OutputIt::container_type::value_type*)

    -> OutputIt {

  return it;

}

template <typename Iterator>

constexpr auto base_iterator(Iterator, Iterator it) -> Iterator {

  return it;

}

// <algorithm> is spectacularly slow to compile in C++20 so use a simple fill_n

// instead (#1998).

template <typename OutputIt, typename Size, typename T>

FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value)

    -> OutputIt {

  for (Size i = 0; i < count; ++i) *out++ = value;

  return out;

}

template <typename T, typename Size>

FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* {

  if (is_constant_evaluated()) {

    return fill_n<T*, Size, T>(out, count, value);

  }

  std::memset(out, value, to_unsigned(count));

  return out + count;

}

template <typename OutChar, typename InputIt, typename OutputIt>

FMT_CONSTEXPR FMT_NOINLINE auto copy_noinline(InputIt begin, InputIt end,

                                              OutputIt out) -> OutputIt {

  return copy<OutChar>(begin, end, out);

}

// A public domain branchless UTF-8 decoder by Christopher Wellons:

// https://github.com/skeeto/branchless-utf8

/* Decode the next character, c, from s, reporting errors in e.

 *

 * Since this is a branchless decoder, four bytes will be read from the

 * buffer regardless of the actual length of the next character. This

 * means the buffer _must_ have at least three bytes of zero padding

 * following the end of the data stream.

 *

 * Errors are reported in e, which will be non-zero if the parsed

 * character was somehow invalid: invalid byte sequence, non-canonical

 * encoding, or a surrogate half.

 *

 * The function returns a pointer to the next character. When an error

 * occurs, this pointer will be a guess that depends on the particular

 * error, but it will always advance at least one byte.

 */

FMT_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e)

    -> const char* {

  constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};

  constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};

  constexpr const int shiftc[] = {0, 18, 12, 6, 0};

  constexpr const int shifte[] = {0, 6, 4, 2, 0};

  int len = "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\0\0\2\2\2\2\3\3\4"

      [static_cast<unsigned char>(*s) >> 3];

  // Compute the pointer to the next character early so that the next

  // iteration can start working on the next character. Neither Clang

  // nor GCC figure out this reordering on their own.

  const char* next = s + len + !len;

  using uchar = unsigned char;

  // Assume a four-byte character and load four bytes. Unused bits are

  // shifted out.

  *c = uint32_t(uchar(s[0]) & masks[len]) << 18;

  *c |= uint32_t(uchar(s[1]) & 0x3f) << 12;

  *c |= uint32_t(uchar(s[2]) & 0x3f) << 6;

  *c |= uint32_t(uchar(s[3]) & 0x3f) << 0;

  *c >>= shiftc[len];

  // Accumulate the various error conditions.

  *e = (*c < mins[len]) << 6;       // non-canonical encoding

  *e |= ((*c >> 11) == 0x1b) << 7;  // surrogate half?

  *e |= (*c > 0x10FFFF) << 8;       // out of range?

  *e |= (uchar(s[1]) & 0xc0) >> 2;

  *e |= (uchar(s[2]) & 0xc0) >> 4;

  *e |= uchar(s[3]) >> 6;

  *e ^= 0x2a;  // top two bits of each tail byte correct?

  *e >>= shifte[len];

  return next;

}

constexpr FMT_INLINE_VARIABLE uint32_t invalid_code_point = ~uint32_t();

// Invokes f(cp, sv) for every code point cp in s with sv being the string view

// corresponding to the code point. cp is invalid_code_point on error.

template <typename F>

FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) {

  auto decode = [f](const char* buf_ptr, const char* ptr) {

    auto cp = uint32_t();

    auto error = 0;

    auto end = utf8_decode(buf_ptr, &cp, &error);

    bool result = f(error ? invalid_code_point : cp,

                    string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr)));

    return result ? (error ? buf_ptr + 1 : end) : nullptr;

  };

  auto p = s.data();

  const size_t block_size = 4;  // utf8_decode always reads blocks of 4 chars.

  if (s.size() >= block_size) {

    for (auto end = p + s.size() - block_size + 1; p < end;) {

      p = decode(p, p);

      if (!p) return;

    }

  }

  if (auto num_chars_left = s.data() + s.size() - p) {

    char buf[2 * block_size - 1] = {};

    copy<char>(p, p + num_chars_left, buf);

    const char* buf_ptr = buf;

    do {

      auto end = decode(buf_ptr, p);

      if (!end) return;

      p += end - buf_ptr;

      buf_ptr = end;

    } while (buf_ptr - buf < num_chars_left);

  }

}

template <typename Char>

inline auto compute_width(basic_string_view<Char> s) -> size_t {

  return s.size();

}

// Computes approximate display width of a UTF-8 string.

FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t {

  size_t num_code_points = 0;

  // It is not a lambda for compatibility with C++14.

  struct count_code_points {

    size_t* count;

    FMT_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool {

      *count += detail::to_unsigned(

          1 +

          (cp >= 0x1100 &&

           (cp <= 0x115f ||  // Hangul Jamo init. consonants

            cp == 0x2329 ||  // LEFT-POINTING ANGLE BRACKET

            cp == 0x232a ||  // RIGHT-POINTING ANGLE BRACKET

            // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE:

            (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) ||

            (cp >= 0xac00 && cp <= 0xd7a3) ||    // Hangul Syllables

            (cp >= 0xf900 && cp <= 0xfaff) ||    // CJK Compatibility Ideographs

            (cp >= 0xfe10 && cp <= 0xfe19) ||    // Vertical Forms

            (cp >= 0xfe30 && cp <= 0xfe6f) ||    // CJK Compatibility Forms

            (cp >= 0xff00 && cp <= 0xff60) ||    // Fullwidth Forms

            (cp >= 0xffe0 && cp <= 0xffe6) ||    // Fullwidth Forms

            (cp >= 0x20000 && cp <= 0x2fffd) ||  // CJK

            (cp >= 0x30000 && cp <= 0x3fffd) ||

            // Miscellaneous Symbols and Pictographs + Emoticons:

            (cp >= 0x1f300 && cp <= 0x1f64f) ||

            // Supplemental Symbols and Pictographs:

            (cp >= 0x1f900 && cp <= 0x1f9ff))));

      return true;

    }

  };

  // We could avoid branches by using utf8_decode directly.

  for_each_codepoint(s, count_code_points{&num_code_points});

  return num_code_points;

}

template <typename Char>

inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t {

  size_t size = s.size();

  return n < size ? n : size;

}

// Calculates the index of the nth code point in a UTF-8 string.

inline auto code_point_index(string_view s, size_t n) -> size_t {

  size_t result = s.size();

  const char* begin = s.begin();

  for_each_codepoint(s, [begin, &n, &result](uint32_t, string_view sv) {

    if (n != 0) {

      --n;

      return true;

    }

    result = to_unsigned(sv.begin() - begin);

    return false;

  });

  return result;

}

template <typename T> struct is_integral : std::is_integral<T> {};

template <> struct is_integral<int128_opt> : std::true_type {};

template <> struct is_integral<uint128_t> : std::true_type {};

template <typename T>

using is_signed =

    std::integral_constant<bool, std::numeric_limits<T>::is_signed ||

                                     std::is_same<T, int128_opt>::value>;

template <typename T>

using is_integer =

    bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&

                  !std::is_same<T, char>::value &&

                  !std::is_same<T, wchar_t>::value>;

#ifndef FMT_USE_FLOAT

#  define FMT_USE_FLOAT 1

#endif

#ifndef FMT_USE_DOUBLE

#  define FMT_USE_DOUBLE 1

#endif

#ifndef FMT_USE_LONG_DOUBLE

#  define FMT_USE_LONG_DOUBLE 1

#endif

#if defined(FMT_USE_FLOAT128)

// Use the provided definition.

#elif FMT_CLANG_VERSION && FMT_HAS_INCLUDE(<quadmath.h>)

#  define FMT_USE_FLOAT128 1

#elif FMT_GCC_VERSION && defined(_GLIBCXX_USE_FLOAT128) && \

    !defined(__STRICT_ANSI__)

#  define FMT_USE_FLOAT128 1

#else

#  define FMT_USE_FLOAT128 0

#endif

#if FMT_USE_FLOAT128

using float128 = __float128;

#else

using float128 = void;

#endif

template <typename T> using is_float128 = std::is_same<T, float128>;

template <typename T>

using is_floating_point =

    bool_constant<std::is_floating_point<T>::value || is_float128<T>::value>;

template <typename T, bool = std::is_floating_point<T>::value>

struct is_fast_float : bool_constant<std::numeric_limits<T>::is_iec559 &&

                                     sizeof(T) <= sizeof(double)> {};

template <typename T> struct is_fast_float<T, false> : std::false_type {};

template <typename T>

using is_double_double = bool_constant<std::numeric_limits<T>::digits == 106>;

#ifndef FMT_USE_FULL_CACHE_DRAGONBOX

#  define FMT_USE_FULL_CACHE_DRAGONBOX 0

#endif

template <typename T, typename Enable = void>

struct is_locale : std::false_type {};

template <typename T>

struct is_locale<T, void_t<decltype(T::classic())>> : std::true_type {};

}  // namespace detail

FMT_BEGIN_EXPORT

// The number of characters to store in the basic_memory_buffer object itself

// to avoid dynamic memory allocation.

enum { inline_buffer_size = 500 };

/**

 * A dynamically growing memory buffer for trivially copyable/constructible

 * types with the first `SIZE` elements stored in the object itself. Most

 * commonly used via the `memory_buffer` alias for `char`.

 *

 * **Example**:

 *

 *     auto out = fmt::memory_buffer();

 *     fmt::format_to(std::back_inserter(out), "The answer is {}.", 42);

 *

 * This will append "The answer is 42." to `out`. The buffer content can be

 * converted to `std::string` with `to_string(out)`.

 */

template <typename T, size_t SIZE = inline_buffer_size,

          typename Allocator = std::allocator<T>>

class basic_memory_buffer : public detail::buffer<T> {

 private:

  T store_[SIZE];

  // Don't inherit from Allocator to avoid generating type_info for it.

  FMT_NO_UNIQUE_ADDRESS Allocator alloc_;

  // Deallocate memory allocated by the buffer.

  FMT_CONSTEXPR20 void deallocate() {

    T* data = this->data();

    if (data != store_) alloc_.deallocate(data, this->capacity());

  }

  static FMT_CONSTEXPR20 void grow(detail::buffer<T>& buf, size_t size) {

    detail::abort_fuzzing_if(size > 5000);

    auto& self = static_cast<basic_memory_buffer&>(buf);

    const size_t max_size =

        std::allocator_traits<Allocator>::max_size(self.alloc_);

    size_t old_capacity = buf.capacity();

    size_t new_capacity = old_capacity + old_capacity / 2;

    if (size > new_capacity)

      new_capacity = size;

    else if (new_capacity > max_size)

      new_capacity = size > max_size ? size : max_size;

    T* old_data = buf.data();

    T* new_data = self.alloc_.allocate(new_capacity);

    // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481).

    detail::assume(buf.size() <= new_capacity);

    // The following code doesn't throw, so the raw pointer above doesn't leak.

    memcpy(new_data, old_data, buf.size() * sizeof(T));

    self.set(new_data, new_capacity);

    // deallocate must not throw according to the standard, but even if it does,

    // the buffer already uses the new storage and will deallocate it in

    // destructor.

    if (old_data != self.store_) self.alloc_.deallocate(old_data, old_capacity);

  }

 public:

  using value_type = T;

  using const_reference = const T&;

  FMT_CONSTEXPR20 explicit basic_memory_buffer(

      const Allocator& alloc = Allocator())

      : detail::buffer<T>(grow), alloc_(alloc) {

    this->set(store_, SIZE);

    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());

  }

  FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }

 private:

  // Move data from other to this buffer.

  FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {

    alloc_ = std::move(other.alloc_);

    T* data = other.data();