/*

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 FMT_HEADER_ONLY

# define FMT_HEADER_ONLY

#endif

#include <cmath> // std::signbit

#include <cstdint> // uint32_t

#include <limits> // std::numeric_limits

#include <memory> // std::uninitialized_copy

#include <stdexcept> // std::runtime_error

#include <system_error> // std::system_error

#include <utility> // std::swap

#include "core.h"

#ifdef __INTEL_COMPILER

# define FMT_ICC_VERSION __INTEL_COMPILER

#elif defined(__ICL)

# define FMT_ICC_VERSION __ICL

#else

# define FMT_ICC_VERSION 0

#endif

#ifdef __NVCC__

# define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)

#else

# define FMT_CUDA_VERSION 0

#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

#if FMT_MSC_VER

# define FMT_MSC_DEFAULT = default

#else

# define FMT_MSC_DEFAULT

#endif

#ifndef FMT_THROW

# if FMT_EXCEPTIONS

# if FMT_MSC_VER || FMT_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) \

do { \

FMT_ASSERT(false, (x).what()); \

} while (false)

# endif

#endif

#if FMT_EXCEPTIONS

# define FMT_TRY try

# define FMT_CATCH(x) catch (x)

#else

# define FMT_TRY if (true)

# define FMT_CATCH(x) if (false)

#endif

#ifndef FMT_DEPRECATED

# if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VER >= 1900

# define FMT_DEPRECATED [[deprecated]]

# else

# if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__)

# define FMT_DEPRECATED __attribute__((deprecated))

# elif FMT_MSC_VER

# define FMT_DEPRECATED __declspec(deprecated)

# else

# define FMT_DEPRECATED /* deprecated */

# endif

# endif

#endif

// Workaround broken [[deprecated]] in the Intel, PGI and NVCC compilers.

#if FMT_ICC_VERSION || defined(__PGI) || FMT_NVCC

# define FMT_DEPRECATED_ALIAS

#else

# define FMT_DEPRECATED_ALIAS FMT_DEPRECATED

#endif

#ifndef FMT_USE_USER_DEFINED_LITERALS

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

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

FMT_MSC_VER >= 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_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER

# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)

#endif

#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER

# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)

#endif

#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_ctz))

# define FMT_BUILTIN_CTZ(n) __builtin_ctz(n)

#endif

#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_ctzll))

# define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n)

#endif

#if FMT_MSC_VER

# 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_VER && !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 managed(push, off)

# 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 ^ (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)

# if !defined(__clang__)

# pragma managed(pop)

# endif

} // namespace detail

FMT_END_NAMESPACE

#endif

FMT_BEGIN_NAMESPACE

namespace detail {

#if __cplusplus >= 202002L || \

(__cplusplus >= 201709L && FMT_GCC_VERSION >= 1002)

# define FMT_CONSTEXPR20 constexpr

#else

# define FMT_CONSTEXPR20

#endif

// An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't have

// undefined behavior (e.g. due to type aliasing).

// Example: uint64_t d = bit_cast<uint64_t>(2.718);

template <typename Dest, typename Source>

inline auto bit_cast(const Source& source) -> Dest {

static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");

Dest dest;

std::memcpy(&dest, &source, sizeof(dest));

return dest;

}

inline auto is_big_endian() -> bool {

const auto u = 1u;

struct bytes {

char data[sizeof(u)];

};

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

}

// A fallback implementation of uintptr_t for systems that lack it.

struct fallback_uintptr {

unsigned char value[sizeof(void*)];

fallback_uintptr() = default;

explicit fallback_uintptr(const void* p) {

*this = bit_cast<fallback_uintptr>(p);

if (is_big_endian()) {

for (size_t i = 0, j = sizeof(void*) - 1; i < j; ++i, --j)

std::swap(value[i], value[j]);

}

}

};

#ifdef UINTPTR_MAX

using uintptr_t = ::uintptr_t;

inline auto to_uintptr(const void* p) -> uintptr_t {

return bit_cast<uintptr_t>(p);

}

#else

using uintptr_t = fallback_uintptr;

inline auto to_uintptr(const void* p) -> fallback_uintptr {

return fallback_uintptr(p);

}

#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_t>() -> int { return 128; }

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

template <> constexpr auto num_bits<fallback_uintptr>() -> int {

return static_cast<int>(sizeof(void*) *

std::numeric_limits<unsigned char>::digits);

}

FMT_INLINE void assume(bool condition) {

(void)condition;

#if FMT_HAS_BUILTIN(__builtin_assume)

__builtin_assume(condition);

#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();

}

#if defined(_SECURE_SCL) && _SECURE_SCL

// Make a checked iterator to avoid MSVC warnings.

template <typename T> using checked_ptr = stdext::checked_array_iterator<T*>;

template <typename T> auto make_checked(T* p, size_t size) -> checked_ptr<T> {

return {p, size};

}

#else

template <typename T> using checked_ptr = T*;

template <typename T> inline auto make_checked(T* p, size_t) -> T* { return p; }

#endif

// 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 Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>

#if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION

__attribute__((no_sanitize("undefined")))

#endif

inline auto

reserve(std::back_insert_iterator<Container> it, size_t n)

-> checked_ptr<typename Container::value_type> {

Container& c = get_container(it);

size_t size = c.size();

c.resize(size + n);

return make_checked(get_data(c) + size, n);

}

template <typename T>

inline auto reserve(buffer_appender<T> it, size_t n) -> buffer_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(buffer_appender<T> it, size_t n) -> T* {

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

auto size = buf.size();

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

buf.try_resize(size + n);

return buf.data() + size;

}

template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>

inline auto base_iterator(std::back_insert_iterator<Container>& it,

checked_ptr<typename Container::value_type>)

-> std::back_insert_iterator<Container> {

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;

}

#ifdef __cpp_char8_t

using char8_type = char8_t;

#else

enum char8_type : unsigned char {};

#endif

template <typename OutChar, typename InputIt, typename OutputIt>

FMT_CONSTEXPR FMT_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end,

OutputIt out) -> OutputIt {

return copy_str<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 = code_point_length(s);

const char* next = s + len;

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

// shifted out.

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

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

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

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

*c >>= shiftc[len];

// Accumulate the various error conditions.

using uchar = unsigned char;

*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;

}

template <typename F>

FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) {

auto decode = [f](const char* p) {

auto cp = uint32_t();

auto error = 0;

p = utf8_decode(p, &cp, &error);

f(cp, error);

return p;

};

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);

}

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

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

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

p = buf;

do {

p = decode(p);

} while (p - 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 size_t compute_width(string_view s) {

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 void operator()(uint32_t cp, int error) const {

*count += detail::to_unsigned(

1 +

(error == 0 && 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))));

}

};

for_each_codepoint(s, count_code_points{&num_code_points});

return num_code_points;

}

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

return compute_width(basic_string_view<char>(

reinterpret_cast<const char*>(s.data()), s.size()));

}

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(basic_string_view<char8_type> s, size_t n)

-> size_t {

const char8_type* data = s.data();

size_t num_code_points = 0;

for (size_t i = 0, size = s.size(); i != size; ++i) {

if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) return i;

}

return s.size();

}

template <typename T>

using is_fast_float = bool_constant<std::numeric_limits<T>::is_iec559 &&

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

#ifndef FMT_USE_FULL_CACHE_DRAGONBOX

# define FMT_USE_FULL_CACHE_DRAGONBOX 0

#endif

template <typename T>

template <typename U>

void buffer<T>::append(const U* begin, const U* end) {

while (begin != end) {

auto count = to_unsigned(end - begin);

try_reserve(size_ + count);

auto free_cap = capacity_ - size_;

if (free_cap < count) count = free_cap;

std::uninitialized_copy_n(begin, count, make_checked(ptr_ + size_, count));

size_ += count;

begin += count;

}

}

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_MODULE_EXPORT_BEGIN

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

// to avoid dynamic memory allocation.

enum { inline_buffer_size = 500 };

/**

\rst

A dynamically growing memory buffer for trivially copyable/constructible types

with the first ``SIZE`` elements stored in the object itself.

You can use the ``memory_buffer`` type alias for ``char`` instead.

**Example**::

fmt::memory_buffer out;

format_to(out, "The answer is {}.", 42);

This will append the following output to the ``out`` object:

.. code-block:: none

The answer is 42.

The output can be converted to an ``std::string`` with ``to_string(out)``.

\endrst

*/

template <typename T, size_t SIZE = inline_buffer_size,

typename Allocator = std::allocator<T>>

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

private:

T store_[SIZE];

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

Allocator alloc_;

// Deallocate memory allocated by the buffer.

void deallocate() {

T* data = this->data();

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

}

protected:

void grow(size_t size) final FMT_OVERRIDE;

public:

using value_type = T;

using const_reference = const T&;

explicit basic_memory_buffer(const Allocator& alloc = Allocator())

: alloc_(alloc) {

this->set(store_, SIZE);

}

~basic_memory_buffer() { deallocate(); }

private:

// Move data from other to this buffer.

void move(basic_memory_buffer& other) {

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

T* data = other.data();

size_t size = other.size(), capacity = other.capacity();

if (data == other.store_) {

this->set(store_, capacity);

std::uninitialized_copy(other.store_, other.store_ + size,

detail::make_checked(store_, capacity));

} else {

this->set(data, capacity);

// Set pointer to the inline array so that delete is not called

// when deallocating.

other.set(other.store_, 0);

}

this->resize(size);

}

public:

/**

\rst

Constructs a :class:`fmt::basic_memory_buffer` object moving the content

of the other object to it.

\endrst

*/

basic_memory_buffer(basic_memory_buffer&& other) FMT_NOEXCEPT { move(other); }

/**

\rst

Moves the content of the other ``basic_memory_buffer`` object to this one.

\endrst

*/

auto operator=(basic_memory_buffer&& other) FMT_NOEXCEPT

-> basic_memory_buffer& {

FMT_ASSERT(this != &other, "");

deallocate();

move(other);

return *this;

}

// Returns a copy of the allocator associated with this buffer.

auto get_allocator() const -> Allocator { return alloc_; }

/**

Resizes the buffer to contain *count* elements. If T is a POD type new

elements may not be initialized.

*/

void resize(size_t count) { this->try_resize(count); }

/** Increases the buffer capacity to *new_capacity*. */

void reserve(size_t new_capacity) { this->try_reserve(new_capacity); }

// Directly append data into the buffer

using detail::buffer<T>::append;

template <typename ContiguousRange>

void append(const ContiguousRange& range) {

append(range.data(), range.data() + range.size());

}

};

template <typename T, size_t SIZE, typename Allocator>

void basic_memory_buffer<T, SIZE, Allocator>::grow(size_t size) {

#ifdef FMT_FUZZ

if (size > 5000) throw std::runtime_error("fuzz mode - won't grow that much");

#endif

const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);

size_t old_capacity = this->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 = this->data();

T* new_data =

std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);

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

std::uninitialized_copy(old_data, old_data + this->size(),

detail::make_checked(new_data, new_capacity));

this->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 != store_) alloc_.deallocate(old_data, old_capacity);

}

using memory_buffer = basic_memory_buffer<char>;

template <typename T, size_t SIZE, typename Allocator>

struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type {

};

namespace detail {

FMT_API void print(std::FILE*, string_view);

}

/** A formatting error such as invalid format string. */

FMT_CLASS_API

class FMT_API format_error : public std::runtime_error {

public:

explicit format_error(const char* message) : std::runtime_error(message) {}

explicit format_error(const std::string& message)

: std::runtime_error(message) {}

format_error(const format_error&) = default;

format_error& operator=(const format_error&) = default;

format_error(format_error&&) = default;

format_error& operator=(format_error&&) = default;

~format_error() FMT_NOEXCEPT FMT_OVERRIDE FMT_MSC_DEFAULT;

};

/**

\rst

Constructs a `~fmt::format_arg_store` object that contains references

to arguments and can be implicitly converted to `~fmt::format_args`.

If ``fmt`` is a compile-time string then `make_args_checked` checks

its validity at compile time.

\endrst

*/

template <typename... Args, typename S, typename Char = char_t<S>>

FMT_INLINE auto make_args_checked(const S& fmt,

const remove_reference_t<Args>&... args)

-> format_arg_store<buffer_context<Char>, remove_reference_t<Args>...> {

static_assert(

detail::count<(

std::is_base_of<detail::view, remove_reference_t<Args>>::value &&

std::is_reference<Args>::value)...>() == 0,

"passing views as lvalues is disallowed");

detail::check_format_string<Args...>(fmt);

return {args...};

}

// compile-time support

namespace detail_exported {

#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS

template <typename Char, size_t N> struct fixed_string {

constexpr fixed_string(const Char (&str)[N]) {

detail::copy_str<Char, const Char*, Char*>(static_cast<const Char*>(str),

str + N, data);

}

Char data[N]{};

};

#endif

// Converts a compile-time string to basic_string_view.

template <typename Char, size_t N>

constexpr auto compile_string_to_view(const Char (&s)[N])

-> basic_string_view<Char> {

// Remove trailing NUL character if needed. Won't be present if this is used

// with a raw character array (i.e. not defined as a string).

return {s, N - (std::char_traits<Char>::to_int_type(s[N - 1]) == 0 ? 1 : 0)};

}

template <typename Char>

constexpr auto compile_string_to_view(detail::std_string_view<Char> s)

-> basic_string_view<Char> {

return {s.data(), s.size()};

}

} // namespace detail_exported

FMT_BEGIN_DETAIL_NAMESPACE

inline void throw_format_error(const char* message) {

FMT_THROW(format_error(message));

}

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

template <> struct is_integral<int128_t> : 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_t>::value>;

// Returns true if value is negative, false otherwise.

// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.

template <typename T, FMT_ENABLE_IF(is_signed<T>::value)>

FMT_CONSTEXPR auto is_negative(T value) -> bool {

return value < 0;

}

template <typename T, FMT_ENABLE_IF(!is_signed<T>::value)>

FMT_CONSTEXPR auto is_negative(T) -> bool {

return false;

}

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

FMT_CONSTEXPR auto is_supported_floating_point(T) -> uint16_t {

return (std::is_same<T, float>::value && FMT_USE_FLOAT) ||

(std::is_same<T, double>::value && FMT_USE_DOUBLE) ||

(std::is_same<T, long double>::value && FMT_USE_LONG_DOUBLE);

}

// Smallest of uint32_t, uint64_t, uint128_t that is large enough to

// represent all values of an integral type T.

template <typename T>

using uint32_or_64_or_128_t =

conditional_t<num_bits<T>() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS,

uint32_t,

conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>>;

template <typename T>

using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>;

#define FMT_POWERS_OF_10(factor) \

factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \

(factor)*1000000, (factor)*10000000, (factor)*100000000, \

(factor)*1000000000

// Static data is placed in this class template for the header-only config.

template <typename T = void> struct basic_data {

// log10(2) = 0x0.4d104d427de7fbcc...

static const uint64_t log10_2_significand = 0x4d104d427de7fbcc;

// GCC generates slightly better code for pairs than chars.

FMT_API static constexpr const char digits[100][2] = {

{'0', '0'}, {'0', '1'}, {'0', '2'}, {'0', '3'}, {'0', '4'}, {'0', '5'},

{'0', '6'}, {'0', '7'}, {'0', '8'}, {'0', '9'}, {'1', '0'}, {'1', '1'},

{'1', '2'}, {'1', '3'}, {'1', '4'}, {'1', '5'}, {'1', '6'}, {'1', '7'},

{'1', '8'}, {'1', '9'}, {'2', '0'}, {'2', '1'}, {'2', '2'}, {'2', '3'},

{'2', '4'}, {'2', '5'}, {'2', '6'}, {'2', '7'}, {'2', '8'}, {'2', '9'},

{'3', '0'}, {'3', '1'}, {'3', '2'}, {'3', '3'}, {'3', '4'}, {'3', '5'},

{'3', '6'}, {'3', '7'}, {'3', '8'}, {'3', '9'}, {'4', '0'}, {'4', '1'},

{'4', '2'}, {'4', '3'}, {'4', '4'}, {'4', '5'}, {'4', '6'}, {'4', '7'},

{'4', '8'}, {'4', '9'}, {'5', '0'}, {'5', '1'}, {'5', '2'}, {'5', '3'},

{'5', '4'}, {'5', '5'}, {'5', '6'}, {'5', '7'}, {'5', '8'}, {'5', '9'},

{'6', '0'}, {'6', '1'}, {'6', '2'}, {'6', '3'}, {'6', '4'}, {'6', '5'},

{'6', '6'}, {'6', '7'}, {'6', '8'}, {'6', '9'}, {'7', '0'}, {'7', '1'},

{'7', '2'}, {'7', '3'}, {'7', '4'}, {'7', '5'}, {'7', '6'}, {'7', '7'},

{'7', '8'}, {'7', '9'}, {'8', '0'}, {'8', '1'}, {'8', '2'}, {'8', '3'},

{'8', '4'}, {'8', '5'}, {'8', '6'}, {'8', '7'}, {'8', '8'}, {'8', '9'},

{'9', '0'}, {'9', '1'}, {'9', '2'}, {'9', '3'}, {'9', '4'}, {'9', '5'},

{'9', '6'}, {'9', '7'}, {'9', '8'}, {'9', '9'}};

FMT_API static constexpr const char hex_digits[] = "0123456789abcdef";

FMT_API static constexpr const char signs[4] = {0, '-', '+', ' '};

FMT_API static constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+',

0x1000000u | ' '};

FMT_API static constexpr const char left_padding_shifts[5] = {31, 31, 0, 1,

0};

FMT_API static constexpr const char right_padding_shifts[5] = {0, 31, 0, 1,

0};

};

#ifdef FMT_SHARED

// Required for -flto, -fivisibility=hidden and -shared to work

extern template struct basic_data<void>;

#endif

// This is a struct rather than an alias to avoid shadowing warnings in gcc.

struct data : basic_data<> {};

template <typename T> FMT_CONSTEXPR auto count_digits_fallback(T n) -> int {

int count = 1;

for (;;) {

// Integer division is slow so do it for a group of four digits instead

// of for every digit. The idea comes from the talk by Alexandrescu

// "Three Optimization Tips for C++". See speed-test for a comparison.

if (n < 10) return count;

if (n < 100) return count + 1;

if (n < 1000) return count + 2;

if (n < 10000) return count + 3;

n /= 10000u;

count += 4;

}

}

#if FMT_USE_INT128

FMT_CONSTEXPR inline auto count_digits(uint128_t n) -> int {

return count_digits_fallback(n);

}

#endif

// Returns the number of decimal digits in n. Leading zeros are not counted

// except for n == 0 in which case count_digits returns 1.

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

#ifdef FMT_BUILTIN_CLZLL

if (!is_constant_evaluated()) {

// https://github.com/fmtlib/format-benchmark/blob/master/digits10

// Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).

constexpr uint16_t bsr2log10[] = {

1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5,

6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10,

10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,

15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};

auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63];

constexpr const uint64_t zero_or_powers_of_10[] = {

0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),

10000000000000000000ULL};

return t - (n < zero_or_powers_of_10[t]);

}

#endif

return count_digits_fallback(n);

}

// Counts the number of digits in n. BITS = log2(radix).

template <int BITS, typename UInt>

FMT_CONSTEXPR auto count_digits(UInt n) -> int {

#ifdef FMT_BUILTIN_CLZ

if (num_bits<UInt>() == 32)

return (FMT_BUILTIN_CLZ(static_cast<uint32_t>(n) | 1) ^ 31) / BITS + 1;

#endif

int num_digits = 0;

do {

++num_digits;

} while ((n >>= BITS) != 0);

return num_digits;

}

template <> auto count_digits<4>(detail::fallback_uintptr n) -> int;

// It is a separate function rather than a part of count_digits to workaround

// the lack of static constexpr in constexpr functions.

FMT_INLINE uint64_t count_digits_inc(int n) {

// An optimization by Kendall Willets from https://bit.ly/3uOIQrB.

// This increments the upper 32 bits (log10(T) - 1) when >= T is added.

#define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)

static constexpr uint64_t table[] = {

FMT_INC(0), FMT_INC(0), FMT_INC(0), // 8

FMT_INC(10), FMT_INC(10), FMT_INC(10), // 64

FMT_INC(100), FMT_INC(100), FMT_INC(100), // 512

FMT_INC(1000), FMT_INC(1000), FMT_INC(1000), // 4096

FMT_INC(10000), FMT_INC(10000), FMT_INC(10000), // 32k

FMT_INC(100000), FMT_INC(100000), FMT_INC(100000), // 256k

FMT_INC(1000000), FMT_INC(1000000), FMT_INC(1000000), // 2048k

FMT_INC(10000000), FMT_INC(10000000), FMT_INC(10000000), // 16M

FMT_INC(100000000), FMT_INC(100000000), FMT_INC(100000000), // 128M

FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000), // 1024M

FMT_INC(1000000000), FMT_INC(1000000000) // 4B

};

return table[n];

}

// Optional version of count_digits for better performance on 32-bit platforms.

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

#ifdef FMT_BUILTIN_CLZ

if (!is_constant_evaluated()) {

auto inc = count_digits_inc(FMT_BUILTIN_CLZ(n | 1) ^ 31);

return static_cast<int>((n + inc) >> 32);

}

#endif

return count_digits_fallback(n);

}

template <typename Int> constexpr auto digits10() FMT_NOEXCEPT -> int {

return std::numeric_limits<Int>::digits10;

}

template <> constexpr auto digits10<int128_t>() FMT_NOEXCEPT -> int {

return 38;

}

template <> constexpr auto digits10<uint128_t>() FMT_NOEXCEPT -> int {