/*

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_

#include <algorithm>

#include <cerrno>

#include <cmath>

#include <cstdint>

#include <limits>

#include <memory>

#include <stdexcept>

#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 __cplusplus == 201103L || __cplusplus == 201402L

# if defined(__clang__)

# define FMT_FALLTHROUGH [[clang::fallthrough]]

# elif FMT_GCC_VERSION >= 700 && !defined(__PGI)

# define FMT_FALLTHROUGH [[gnu::fallthrough]]

# else

# define FMT_FALLTHROUGH

# endif

#elif FMT_HAS_CPP17_ATTRIBUTE(fallthrough) || \

(defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)

# define FMT_FALLTHROUGH [[fallthrough]]

#else

# define FMT_FALLTHROUGH

#endif

#ifndef FMT_THROW

# if FMT_EXCEPTIONS

# if FMT_MSC_VER || FMT_NVCC

FMT_BEGIN_NAMESPACE

namespace internal {

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 internal

FMT_END_NAMESPACE

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

# else

# define FMT_THROW(x) throw x

# endif

# else

# define FMT_THROW(x) \

do { \

static_cast<void>(sizeof(x)); \

FMT_ASSERT(false, ""); \

} 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_USE_USER_DEFINED_LITERALS

// For Intel and NVIDIA compilers both they and the system gcc/msc support UDLs.

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

FMT_MSC_VER >= 1900) && \

(!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || \

FMT_CUDA_VERSION >= 700)

# define FMT_USE_USER_DEFINED_LITERALS 1

# else

# define FMT_USE_USER_DEFINED_LITERALS 0

# endif

#endif

#ifndef FMT_USE_UDL_TEMPLATE

// EDG front end based compilers (icc, nvcc) and GCC < 6.4 do not propertly

// support UDL templates and GCC >= 9 warns about them.

# if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && \

FMT_CUDA_VERSION == 0 && \

((FMT_GCC_VERSION >= 604 && FMT_GCC_VERSION <= 900 && \

__cplusplus >= 201402L) || \

FMT_CLANG_VERSION >= 304)

# define FMT_USE_UDL_TEMPLATE 1

# else

# define FMT_USE_UDL_TEMPLATE 0

# endif

#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

// 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(_MANAGED)

# include <intrin.h> // _BitScanReverse, _BitScanReverse64

FMT_BEGIN_NAMESPACE

namespace internal {

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

# ifndef __clang__

# pragma intrinsic(_BitScanReverse)

# endif

inline uint32_t clz(uint32_t x) {

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.

# pragma warning(suppress : 6102)

return 31 - r;

}

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

# if defined(_WIN64) && !defined(__clang__)

# pragma intrinsic(_BitScanReverse64)

# endif

inline uint32_t clzll(uint64_t x) {

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

// 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.

# pragma warning(suppress : 6102)

return 63 - r;

}

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

} // namespace internal

FMT_END_NAMESPACE

#endif

// Enable the deprecated numeric alignment.

#ifndef FMT_NUMERIC_ALIGN

# define FMT_NUMERIC_ALIGN 1

#endif

// Enable the deprecated percent specifier.

#ifndef FMT_DEPRECATED_PERCENT

# define FMT_DEPRECATED_PERCENT 0

#endif

FMT_BEGIN_NAMESPACE

namespace internal {

// 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 Dest bit_cast(const Source& source) {

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

Dest dest;

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

return dest;

}

inline bool is_big_endian() {

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 uintptr_t to_uintptr(const void* p) { return bit_cast<uintptr_t>(p); }

#else

using uintptr_t = fallback_uintptr;

inline fallback_uintptr to_uintptr(const void* p) {

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 T max_value() {

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

}

template <typename T> constexpr int num_bits() {

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

}

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

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

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

}

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

template <typename T>

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

// Detect the iterator category of *any* given type in a SFINAE-friendly way.

// Unfortunately, older implementations of std::iterator_traits are not safe

// for use in a SFINAE-context.

template <typename It, typename Enable = void>

struct iterator_category : std::false_type {};

template <typename T> struct iterator_category<T*> {

using type = std::random_access_iterator_tag;

};

template <typename It>

struct iterator_category<It, void_t<typename It::iterator_category>> {

using type = typename It::iterator_category;

};

// Detect if *any* given type models the OutputIterator concept.

template <typename It> class is_output_iterator {

// Check for mutability because all iterator categories derived from

// std::input_iterator_tag *may* also meet the requirements of an

// OutputIterator, thereby falling into the category of 'mutable iterators'

// [iterator.requirements.general] clause 4. The compiler reveals this

// property only at the point of *actually dereferencing* the iterator!

template <typename U>

static decltype(*(std::declval<U>())) test(std::input_iterator_tag);

template <typename U> static char& test(std::output_iterator_tag);

template <typename U> static const char& test(...);

using type = decltype(test<It>(typename iterator_category<It>::type{}));

public:

enum { value = !std::is_const<remove_reference_t<type>>::value };

};

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

template <typename Char> inline Char* get_data(std::basic_string<Char>& s) {

return &s[0];

}

template <typename Container>

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

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> checked_ptr<T> make_checked(T* p, std::size_t size) {

return {p, size};

}

#else

template <typename T> using checked_ptr = T*;

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

#endif

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

inline checked_ptr<typename Container::value_type> reserve(

std::back_insert_iterator<Container>& it, std::size_t n) {

Container& c = get_container(it);

std::size_t size = c.size();

c.resize(size + n);

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

}

template <typename Iterator>

inline Iterator& reserve(Iterator& it, std::size_t) {

return it;

}

// An output iterator that counts the number of objects written to it and

// discards them.

class counting_iterator {

private:

std::size_t count_;

public:

using iterator_category = std::output_iterator_tag;

using difference_type = std::ptrdiff_t;

using pointer = void;

using reference = void;

using _Unchecked_type = counting_iterator; // Mark iterator as checked.

struct value_type {

template <typename T> void operator=(const T&) {}

};

counting_iterator() : count_(0) {}

std::size_t count() const { return count_; }

counting_iterator& operator++() {

++count_;

return *this;

}

counting_iterator operator++(int) {

auto it = *this;

++*this;

return it;

}

value_type operator*() const { return {}; }

};

template <typename OutputIt> class truncating_iterator_base {

protected:

OutputIt out_;

std::size_t limit_;

std::size_t count_;

truncating_iterator_base(OutputIt out, std::size_t limit)

: out_(out), limit_(limit), count_(0) {}

public:

using iterator_category = std::output_iterator_tag;

using value_type = typename std::iterator_traits<OutputIt>::value_type;

using difference_type = void;

using pointer = void;

using reference = void;

using _Unchecked_type =

truncating_iterator_base; // Mark iterator as checked.

OutputIt base() const { return out_; }

std::size_t count() const { return count_; }

};

// An output iterator that truncates the output and counts the number of objects

// written to it.

template <typename OutputIt,

typename Enable = typename std::is_void<

typename std::iterator_traits<OutputIt>::value_type>::type>

class truncating_iterator;

template <typename OutputIt>

class truncating_iterator<OutputIt, std::false_type>

: public truncating_iterator_base<OutputIt> {

mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;

public:

using value_type = typename truncating_iterator_base<OutputIt>::value_type;

truncating_iterator(OutputIt out, std::size_t limit)

: truncating_iterator_base<OutputIt>(out, limit) {}

truncating_iterator& operator++() {

if (this->count_++ < this->limit_) ++this->out_;

return *this;

}

truncating_iterator operator++(int) {

auto it = *this;

++*this;

return it;

}

value_type& operator*() const {

return this->count_ < this->limit_ ? *this->out_ : blackhole_;

}

};

template <typename OutputIt>

class truncating_iterator<OutputIt, std::true_type>

: public truncating_iterator_base<OutputIt> {

public:

truncating_iterator(OutputIt out, std::size_t limit)

: truncating_iterator_base<OutputIt>(out, limit) {}

template <typename T> truncating_iterator& operator=(T val) {

if (this->count_++ < this->limit_) *this->out_++ = val;

return *this;

}

truncating_iterator& operator++() { return *this; }

truncating_iterator& operator++(int) { return *this; }

truncating_iterator& operator*() { return *this; }

};

// A range with the specified output iterator and value type.

template <typename OutputIt, typename T = typename OutputIt::value_type>

class output_range {

private:

OutputIt it_;

public:

using value_type = T;

using iterator = OutputIt;

struct sentinel {};

explicit output_range(OutputIt it) : it_(it) {}

OutputIt begin() const { return it_; }

sentinel end() const { return {}; } // Sentinel is not used yet.

};

template <typename Char>

inline size_t count_code_points(basic_string_view<Char> s) {

return s.size();

}

// Counts the number of code points in a UTF-8 string.

inline size_t count_code_points(basic_string_view<char> s) {

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

}

return num_code_points;

}

inline size_t count_code_points(basic_string_view<char8_type> s) {

return count_code_points(basic_string_view<char>(

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

}

template <typename Char>

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

size_t size = s.size();

return n < size ? n : size;

}

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

inline size_t code_point_index(basic_string_view<char8_type> s, size_t n) {

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

}

inline char8_type to_char8_t(char c) { return static_cast<char8_type>(c); }

template <typename InputIt, typename OutChar>

using needs_conversion = bool_constant<

std::is_same<typename std::iterator_traits<InputIt>::value_type,

char>::value &&

std::is_same<OutChar, char8_type>::value>;

template <typename OutChar, typename InputIt, typename OutputIt,

FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>

OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {

return std::copy(begin, end, it);

}

template <typename OutChar, typename InputIt, typename OutputIt,

FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>

OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {

return std::transform(begin, end, it, to_char8_t);

}

#ifndef FMT_USE_GRISU

# define FMT_USE_GRISU 1

#endif

template <typename T> constexpr bool use_grisu() {

return FMT_USE_GRISU && std::numeric_limits<double>::is_iec559 &&

sizeof(T) <= sizeof(double);

}

template <typename T>

template <typename U>

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

std::size_t new_size = size_ + to_unsigned(end - begin);

reserve(new_size);

std::uninitialized_copy(begin, end, make_checked(ptr_, capacity_) + size_);

size_ = new_size;

}

} // namespace internal

// A range with an iterator appending to a buffer.

template <typename T>

class buffer_range : public internal::output_range<

std::back_insert_iterator<internal::buffer<T>>, T> {

public:

using iterator = std::back_insert_iterator<internal::buffer<T>>;

using internal::output_range<iterator, T>::output_range;

buffer_range(internal::buffer<T>& buf)

: internal::output_range<iterator, T>(std::back_inserter(buf)) {}

};

class FMT_DEPRECATED u8string_view

: public basic_string_view<internal::char8_type> {

public:

u8string_view(const char* s)

: basic_string_view<internal::char8_type>(

reinterpret_cast<const internal::char8_type*>(s)) {}

u8string_view(const char* s, size_t count) FMT_NOEXCEPT

: basic_string_view<internal::char8_type>(

reinterpret_cast<const internal::char8_type*>(s), count) {}

};

#if FMT_USE_USER_DEFINED_LITERALS

inline namespace literals {

FMT_DEPRECATED inline basic_string_view<internal::char8_type> operator"" _u(

const char* s, std::size_t n) {

return {reinterpret_cast<const internal::char8_type*>(s), n};

}

} // namespace literals

#endif

// 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 one of the following type aliases for common character types:

+----------------+------------------------------+

| Type | Definition |

+================+==============================+

| memory_buffer | basic_memory_buffer<char> |

+----------------+------------------------------+

| wmemory_buffer | basic_memory_buffer<wchar_t> |

+----------------+------------------------------+

**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, std::size_t SIZE = inline_buffer_size,

typename Allocator = std::allocator<T>>

class basic_memory_buffer : private Allocator, public internal::buffer<T> {

private:

T store_[SIZE];

// Deallocate memory allocated by the buffer.

void deallocate() {

T* data = this->data();

if (data != store_) Allocator::deallocate(data, this->capacity());

}

protected:

void grow(std::size_t size) FMT_OVERRIDE;

public:

using value_type = T;

using const_reference = const T&;

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

: Allocator(alloc) {

this->set(store_, SIZE);

}

~basic_memory_buffer() FMT_OVERRIDE { deallocate(); }

private:

// Move data from other to this buffer.

void move(basic_memory_buffer& other) {

Allocator &this_alloc = *this, &other_alloc = other;

this_alloc = std::move(other_alloc);

T* data = other.data();

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

if (data == other.store_) {

this->set(store_, capacity);

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

internal::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

*/

basic_memory_buffer& operator=(basic_memory_buffer&& other) FMT_NOEXCEPT {

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

deallocate();

move(other);

return *this;

}

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

Allocator get_allocator() const { return *this; }

};

template <typename T, std::size_t SIZE, typename Allocator>

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

#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION

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

#endif

std::size_t old_capacity = this->capacity();

std::size_t new_capacity = old_capacity + old_capacity / 2;

if (size > new_capacity) new_capacity = size;

T* old_data = this->data();

T* new_data = std::allocator_traits<Allocator>::allocate(*this, 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(),

internal::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_) Allocator::deallocate(old_data, old_capacity);

}

using memory_buffer = basic_memory_buffer<char>;

using wmemory_buffer = basic_memory_buffer<wchar_t>;

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

};

namespace internal {

// 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(std::numeric_limits<T>::is_signed)>

FMT_CONSTEXPR bool is_negative(T value) {

return value < 0;

}

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

FMT_CONSTEXPR bool is_negative(T) {

return false;

}

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

// represent all values of T.

template <typename T>

using uint32_or_64_or_128_t = conditional_t<

std::numeric_limits<T>::digits <= 32, uint32_t,

conditional_t<std::numeric_limits<T>::digits <= 64, uint64_t, uint128_t>>;

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

template <typename T = void> struct FMT_EXTERN_TEMPLATE_API basic_data {

static const uint64_t powers_of_10_64[];

static const uint32_t zero_or_powers_of_10_32[];

static const uint64_t zero_or_powers_of_10_64[];

static const uint64_t pow10_significands[];

static const int16_t pow10_exponents[];

static const char digits[];

static const char hex_digits[];

static const char foreground_color[];

static const char background_color[];

static const char reset_color[5];

static const wchar_t wreset_color[5];

static const char signs[];

};

FMT_EXTERN template struct basic_data<void>;

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

struct data : basic_data<> {};

#ifdef FMT_BUILTIN_CLZLL

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

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

inline int count_digits(uint64_t n) {

// Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10

// and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.

int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;

return t - (n < data::zero_or_powers_of_10_64[t]) + 1;

}

#else

// Fallback version of count_digits used when __builtin_clz is not available.

inline int count_digits(uint64_t n) {

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;

}

}

#endif

#if FMT_USE_INT128

inline int count_digits(uint128_t n) {

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;

}

}

#endif

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

template <unsigned BITS, typename UInt> inline int count_digits(UInt n) {

int num_digits = 0;

do {

++num_digits;

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

return num_digits;

}

template <> int count_digits<4>(internal::fallback_uintptr n);

#if FMT_GCC_VERSION || FMT_CLANG_VERSION

# define FMT_ALWAYS_INLINE inline __attribute__((always_inline))

#else

# define FMT_ALWAYS_INLINE

#endif

#ifdef FMT_BUILTIN_CLZ

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

inline int count_digits(uint32_t n) {

int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;

return t - (n < data::zero_or_powers_of_10_32[t]) + 1;

}

#endif

template <typename Char> FMT_API std::string grouping_impl(locale_ref loc);

template <typename Char> inline std::string grouping(locale_ref loc) {

return grouping_impl<char>(loc);

}

template <> inline std::string grouping<wchar_t>(locale_ref loc) {

return grouping_impl<wchar_t>(loc);

}

template <typename Char> FMT_API Char thousands_sep_impl(locale_ref loc);

template <typename Char> inline Char thousands_sep(locale_ref loc) {

return Char(thousands_sep_impl<char>(loc));

}

template <> inline wchar_t thousands_sep(locale_ref loc) {

return thousands_sep_impl<wchar_t>(loc);

}

template <typename Char> FMT_API Char decimal_point_impl(locale_ref loc);

template <typename Char> inline Char decimal_point(locale_ref loc) {

return Char(decimal_point_impl<char>(loc));

}

template <> inline wchar_t decimal_point(locale_ref loc) {

return decimal_point_impl<wchar_t>(loc);

}

// Formats a decimal unsigned integer value writing into buffer.

// add_thousands_sep is called after writing each char to add a thousands

// separator if necessary.

template <typename UInt, typename Char, typename F>

inline Char* format_decimal(Char* buffer, UInt value, int num_digits,

F add_thousands_sep) {

FMT_ASSERT(num_digits >= 0, "invalid digit count");

buffer += num_digits;

Char* end = buffer;

while (value >= 100) {

// Integer division is slow so do it for a group of two 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.

auto index = static_cast<unsigned>((value % 100) * 2);

value /= 100;

*--buffer = static_cast<Char>(data::digits[index + 1]);

add_thousands_sep(buffer);

*--buffer = static_cast<Char>(data::digits[index]);

add_thousands_sep(buffer);

}

if (value < 10) {

*--buffer = static_cast<Char>('0' + value);

return end;

}

auto index = static_cast<unsigned>(value * 2);

*--buffer = static_cast<Char>(data::digits[index + 1]);

add_thousands_sep(buffer);

*--buffer = static_cast<Char>(data::digits[index]);

return end;

}

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

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

}

template <> constexpr int digits10<int128_t>() FMT_NOEXCEPT { return 38; }

template <> constexpr int digits10<uint128_t>() FMT_NOEXCEPT { return 38; }

template <typename Char, typename UInt, typename Iterator, typename F>

inline Iterator format_decimal(Iterator out, UInt value, int num_digits,

F add_thousands_sep) {

FMT_ASSERT(num_digits >= 0, "invalid digit count");

// Buffer should be large enough to hold all digits (<= digits10 + 1).

enum { max_size = digits10<UInt>() + 1 };

Char buffer[2 * max_size];

auto end = format_decimal(buffer, value, num_digits, add_thousands_sep);

return internal::copy_str<Char>(buffer, end, out);

}

template <typename Char, typename It, typename UInt>

inline It format_decimal(It out, UInt value, int num_digits) {

return format_decimal<Char>(out, value, num_digits, [](Char*) {});

}

template <unsigned BASE_BITS, typename Char, typename UInt>

inline Char* format_uint(Char* buffer, UInt value, int num_digits,

bool upper = false) {

buffer += num_digits;

Char* end = buffer;

do {

const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;

unsigned digit = (value & ((1 << BASE_BITS) - 1));

*--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)

: digits[digit]);

} while ((value >>= BASE_BITS) != 0);

return end;

}

template <unsigned BASE_BITS, typename Char>

Char* format_uint(Char* buffer, internal::fallback_uintptr n, int num_digits,

bool = false) {

auto char_digits = std::numeric_limits<unsigned char>::digits / 4;

int start = (num_digits + char_digits - 1) / char_digits - 1;

if (int start_digits = num_digits % char_digits) {

unsigned value = n.value[start--];

buffer = format_uint<BASE_BITS>(buffer, value, start_digits);

}

for (; start >= 0; --start) {

unsigned value = n.value[start];

buffer += char_digits;

auto p = buffer;

for (int i = 0; i < char_digits; ++i) {

unsigned digit = (value & ((1 << BASE_BITS) - 1));

*--p = static_cast<Char>(data::hex_digits[digit]);

value >>= BASE_BITS;

}

}

return buffer;

}

template <unsigned BASE_BITS, typename Char, typename It, typename UInt>

inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {

// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).

char buffer[num_bits<UInt>() / BASE_BITS + 1];

format_uint<BASE_BITS>(buffer, value, num_digits, upper);

return internal::copy_str<Char>(buffer, buffer + num_digits, out);

}

// A converter from UTF-8 to UTF-16.

class utf8_to_utf16 {

private:

wmemory_buffer buffer_;

public:

FMT_API explicit utf8_to_utf16(string_view s);

operator wstring_view() const { return {&buffer_[0], size()}; }

size_t size() const { return buffer_.size() - 1; }

const wchar_t* c_str() const { return &buffer_[0]; }

std::wstring str() const { return {&buffer_[0], size()}; }

};

template <typename T = void> struct null {};

// Workaround an array initialization issue in gcc 4.8.

template <typename Char> struct fill_t {

private:

enum { max_size = 4 };

Char data_[max_size];

unsigned char size_;

public:

FMT_CONSTEXPR void operator=(basic_string_view<Char> s) {

auto size = s.size();

if (size > max_size) {

FMT_THROW(format_error("invalid fill"));

return;

}

for (size_t i = 0; i < size; ++i) data_[i] = s[i];

size_ = static_cast<unsigned char>(size);

}

size_t size() const { return size_; }

const Char* data() const { return data_; }

FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; }

FMT_CONSTEXPR const Char& operator[](size_t index) const {

return data_[index];

}

static FMT_CONSTEXPR fill_t<Char> make() {

auto fill = fill_t<Char>();

fill[0] = Char(' ');

fill.size_ = 1;

return fill;

}

};

} // namespace internal

// We cannot use enum classes as bit fields because of a gcc bug

// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.

namespace align {

enum type { none, left, right, center, numeric };

}

using align_t = align::type;