/*

Formatting library for C++

Copyright (c) 2012 - present, Victor Zverovich

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this

list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,

this list of conditions and the following disclaimer in the documentation

and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

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

WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR

ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#ifndef FMT_FORMAT_H_

#define FMT_FORMAT_H_

#include <algorithm>

#include <cassert>

#include <cmath>

#include <cstring>

#include <limits>

#include <memory>

#include <stdexcept>

#include <stdint.h>

#ifdef __clang__

# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)

#else

# define FMT_CLANG_VERSION 0

#endif

#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

#include "core.h"

#if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION

# pragma GCC diagnostic push

// Disable the warning about declaration shadowing because it affects too

// many valid cases.

# pragma GCC diagnostic ignored "-Wshadow"

// Disable the warning about nonliteral format strings because we construct

// them dynamically when falling back to snprintf for FP formatting.

# pragma GCC diagnostic ignored "-Wformat-nonliteral"

#endif

# if FMT_CLANG_VERSION

# pragma GCC diagnostic ignored "-Wgnu-string-literal-operator-template"

# endif

#ifdef _SECURE_SCL

# define FMT_SECURE_SCL _SECURE_SCL

#else

# define FMT_SECURE_SCL 0

#endif

#if FMT_SECURE_SCL

# include <iterator>

#endif

#ifdef __has_builtin

# define FMT_HAS_BUILTIN(x) __has_builtin(x)

#else

# define FMT_HAS_BUILTIN(x) 0

#endif

#ifdef __GNUC_LIBSTD__

# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)

#endif

#ifndef FMT_THROW

# if FMT_EXCEPTIONS

# if FMT_MSC_VER

FMT_BEGIN_NAMESPACE

namespace internal {

template <typename Exception>

inline void do_throw(const Exception &x) {

// Silence unreachable code warnings in MSVC because these are nearly

// impossible to fix in a generic code.

volatile bool b = true;

if (b)

throw x;

}

}

FMT_END_NAMESPACE

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

# else

# define FMT_THROW(x) throw x

# endif

# else

# define FMT_THROW(x) do { static_cast<void>(sizeof(x)); assert(false); } while(false);

# endif

#endif

#ifndef FMT_USE_USER_DEFINED_LITERALS

// For Intel's compiler and NVIDIA's compiler both it and the system gcc/msc

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

// EDG C++ Front End based compilers (icc, nvcc) do not currently support UDL

// templates.

#if FMT_USE_USER_DEFINED_LITERALS && \

FMT_ICC_VERSION == 0 && \

FMT_CUDA_VERSION == 0 && \

((FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L) || \

(defined(FMT_CLANG_VERSION) && FMT_CLANG_VERSION >= 304))

# define FMT_UDL_TEMPLATE 1

#else

# define FMT_UDL_TEMPLATE 0

#endif

#ifndef FMT_USE_EXTERN_TEMPLATES

# ifndef FMT_HEADER_ONLY

# define FMT_USE_EXTERN_TEMPLATES \

((FMT_CLANG_VERSION >= 209 && __cplusplus >= 201103L) || \

(FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11))

# else

# define FMT_USE_EXTERN_TEMPLATES 0

# endif

#endif

#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_trailing_return) || \

FMT_MSC_VER >= 1600

# define FMT_USE_TRAILING_RETURN 1

#else

# define FMT_USE_TRAILING_RETURN 0

#endif

#ifndef FMT_USE_GRISU

# define FMT_USE_GRISU 0

//# define FMT_USE_GRISU std::numeric_limits<double>::is_iec559

#endif

// __builtin_clz is broken in clang with Microsoft CodeGen:

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

#ifndef _MSC_VER

# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz)

# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)

# endif

# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll)

# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)

# endif

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

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) fmt::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

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) fmt::internal::clzll(n)

}

FMT_END_NAMESPACE

#endif

FMT_BEGIN_NAMESPACE

namespace internal {

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

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

}

// An implementation of begin and end for pre-C++11 compilers such as gcc 4.

template <typename C>

FMT_CONSTEXPR auto begin(const C &c) -> decltype(c.begin()) {

return c.begin();

}

template <typename T, std::size_t N>

FMT_CONSTEXPR T *begin(T (&array)[N]) FMT_NOEXCEPT { return array; }

template <typename C>

FMT_CONSTEXPR auto end(const C &c) -> decltype(c.end()) { return c.end(); }

template <typename T, std::size_t N>

FMT_CONSTEXPR T *end(T (&array)[N]) FMT_NOEXCEPT { return array + N; }

// For std::result_of in gcc 4.4.

template <typename Result>

struct function {

template <typename T>

struct result { typedef Result type; };

};

struct dummy_int {

int data[2];

operator int() const { return 0; }

};

typedef std::numeric_limits<internal::dummy_int> fputil;

// Dummy implementations of system functions called if the latter are not

// available.

inline dummy_int isinf(...) { return dummy_int(); }

inline dummy_int _finite(...) { return dummy_int(); }

inline dummy_int isnan(...) { return dummy_int(); }

inline dummy_int _isnan(...) { return dummy_int(); }

template <typename Allocator>

typename Allocator::value_type *allocate(Allocator& alloc, std::size_t n) {

#if __cplusplus >= 201103L || FMT_MSC_VER >= 1700

return std::allocator_traits<Allocator>::allocate(alloc, n);

#else

return alloc.allocate(n);

#endif

}

// A helper function to suppress bogus "conditional expression is constant"

// warnings.

template <typename T>

inline T const_check(T value) { return value; }

} // namespace internal

FMT_END_NAMESPACE

namespace std {

// Standard permits specialization of std::numeric_limits. This specialization

// is used to resolve ambiguity between isinf and std::isinf in glibc:

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

// and the same for isnan.

template <>

class numeric_limits<fmt::internal::dummy_int> :

public std::numeric_limits<int> {

public:

// Portable version of isinf.

template <typename T>

static bool isinfinity(T x) {

using namespace fmt::internal;

// The resolution "priority" is:

// isinf macro > std::isinf > ::isinf > fmt::internal::isinf

if (const_check(sizeof(isinf(x)) != sizeof(fmt::internal::dummy_int)))

return isinf(x) != 0;

return !_finite(static_cast<double>(x));

}

// Portable version of isnan.

template <typename T>

static bool isnotanumber(T x) {

using namespace fmt::internal;

if (const_check(sizeof(isnan(x)) != sizeof(fmt::internal::dummy_int)))

return isnan(x) != 0;

return _isnan(static_cast<double>(x)) != 0;

}

};

} // namespace std

FMT_BEGIN_NAMESPACE

template <typename Range>

class basic_writer;

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

class output_range {

private:

OutputIt it_;

// Unused yet.

typedef void sentinel;

sentinel end() const;

public:

typedef OutputIt iterator;

typedef T value_type;

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

OutputIt begin() const { return it_; }

};

// A range where begin() returns back_insert_iterator.

template <typename Container>

class back_insert_range:

public output_range<std::back_insert_iterator<Container>> {

typedef output_range<std::back_insert_iterator<Container>> base;

public:

typedef typename Container::value_type value_type;

back_insert_range(Container &c): base(std::back_inserter(c)) {}

back_insert_range(typename base::iterator it): base(it) {}

};

typedef basic_writer<back_insert_range<internal::buffer>> writer;

typedef basic_writer<back_insert_range<internal::wbuffer>> wwriter;

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

class 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) {}

};

namespace internal {

#if FMT_SECURE_SCL

template <typename T>

struct checked { typedef stdext::checked_array_iterator<T*> type; };

// Make a checked iterator to avoid warnings on MSVC.

template <typename T>

inline stdext::checked_array_iterator<T*> make_checked(T *p, std::size_t size) {

return {p, size};

}

#else

template <typename T>

struct checked { typedef T *type; };

template <typename T>

inline T *make_checked(T *p, std::size_t) { return p; }

#endif

template <typename T>

template <typename U>

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

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

reserve(new_size);

std::uninitialized_copy(begin, end,

internal::make_checked(ptr_, capacity_) + size_);

size_ = new_size;

}

} // namespace internal

// C++20 feature test, since r346892 Clang considers char8_t a fundamental

// type in this mode. If this is the case __cpp_char8_t will be defined.

#if !defined(__cpp_char8_t)

// A UTF-8 code unit type.

enum char8_t: unsigned char {};

#endif

// A UTF-8 string view.

class u8string_view : public basic_string_view<char8_t> {

public:

typedef char8_t char_type;

u8string_view(const char *s):

basic_string_view<char8_t>(reinterpret_cast<const char8_t*>(s)) {}

u8string_view(const char *s, size_t count) FMT_NOEXCEPT:

basic_string_view<char8_t>(reinterpret_cast<const char8_t*>(s), count) {}

};

#if FMT_USE_USER_DEFINED_LITERALS

inline namespace literals {

inline u8string_view operator"" _u(const char *s, std::size_t n) {

return {s, n};

}

}

#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 typedefs 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::basic_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:

typedef T value_type;

typedef const T &const_reference;

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

: Allocator(alloc) {

this->set(store_, SIZE);

}

~basic_memory_buffer() { 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) {

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

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

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 = internal::allocate<Allocator>(*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);

}

typedef basic_memory_buffer<char> memory_buffer;

typedef basic_memory_buffer<wchar_t> wmemory_buffer;

namespace internal {

template <typename Char>

struct char_traits;

template <>

struct char_traits<char> {

// Formats a floating-point number.

template <typename T>

FMT_API static int format_float(char *buffer, std::size_t size,

const char *format, int precision, T value);

};

template <>

struct char_traits<wchar_t> {

template <typename T>

FMT_API static int format_float(wchar_t *buffer, std::size_t size,

const wchar_t *format, int precision, T value);

};

#if FMT_USE_EXTERN_TEMPLATES

extern template int char_traits<char>::format_float<double>(

char *buffer, std::size_t size, const char* format, int precision,

double value);

extern template int char_traits<char>::format_float<long double>(

char *buffer, std::size_t size, const char* format, int precision,

long double value);

extern template int char_traits<wchar_t>::format_float<double>(

wchar_t *buffer, std::size_t size, const wchar_t* format, int precision,

double value);

extern template int char_traits<wchar_t>::format_float<long double>(

wchar_t *buffer, std::size_t size, const wchar_t* format, int precision,

long double value);

#endif

template <typename Container>

inline typename std::enable_if<

is_contiguous<Container>::value,

typename checked<typename Container::value_type>::type>::type

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

Container &c = internal::get_container(it);

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

c.resize(size + n);

return make_checked(&c[size], n);

}

template <typename Iterator>

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

template <typename Char>

class null_terminating_iterator;

template <typename Char>

FMT_CONSTEXPR_DECL const Char *pointer_from(null_terminating_iterator<Char> it);

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

// discards them.

template <typename T>

class counting_iterator {

private:

std::size_t count_;

mutable T blackhole_;

public:

typedef std::output_iterator_tag iterator_category;

typedef T value_type;

typedef std::ptrdiff_t difference_type;

typedef T* pointer;

typedef T& reference;

typedef counting_iterator _Unchecked_type; // Mark iterator as checked.

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;

}

T &operator*() const { return blackhole_; }

};

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:

typedef std::output_iterator_tag iterator_category;

typedef void difference_type;

typedef void pointer;

typedef void reference;

typedef truncating_iterator_base _Unchecked_type; // 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> {

typedef std::iterator_traits<OutputIt> traits;

mutable typename traits::value_type blackhole_;

public:

typedef typename traits::value_type 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:

typedef typename OutputIt::container_type::value_type value_type;

truncating_iterator(OutputIt out, std::size_t limit)

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

truncating_iterator& operator=(value_type 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; }

};

// 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_CONSTEXPR typename std::enable_if<

std::numeric_limits<T>::is_signed, bool>::type is_negative(T value) {

return value < 0;

}

template <typename T>

FMT_CONSTEXPR typename std::enable_if<

!std::numeric_limits<T>::is_signed, bool>::type is_negative(T) {

return false;

}

template <typename T>

struct int_traits {

// Smallest of uint32_t and uint64_t that is large enough to represent

// all values of T.

typedef typename std::conditional<

std::numeric_limits<T>::digits <= 32, uint32_t, uint64_t>::type main_type;

};

// Static data is placed in this class template to allow header-only

// configuration.

template <typename T = void>

struct FMT_API basic_data {

static const uint32_t POWERS_OF_10_32[];

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 FOREGROUND_COLOR[];

static const char BACKGROUND_COLOR[];

static const char RESET_COLOR[];

static const wchar_t WRESET_COLOR[];

};

#if FMT_USE_EXTERN_TEMPLATES

extern template struct basic_data<void>;

#endif

typedef basic_data<> 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

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.

FMT_API size_t count_code_points(basic_string_view<char8_t> s);

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

template <typename InputIt, typename OutChar>

struct needs_conversion: std::integral_constant<bool,

std::is_same<

typename std::iterator_traits<InputIt>::value_type, char>::value &&

std::is_same<OutChar, char8_t>::value> {};

template <typename OutChar, typename InputIt, typename OutputIt>

typename std::enable_if<

!needs_conversion<InputIt, OutChar>::value, OutputIt>::type

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

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

}

template <typename OutChar, typename InputIt, typename OutputIt>

typename std::enable_if<

needs_conversion<InputIt, OutChar>::value, OutputIt>::type

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

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

}

#if FMT_HAS_CPP_ATTRIBUTE(always_inline)

# define FMT_ALWAYS_INLINE __attribute__((always_inline))

#else

# define FMT_ALWAYS_INLINE

#endif

template <typename Handler>

inline char *lg(uint32_t n, Handler h) FMT_ALWAYS_INLINE;

// Computes g = floor(log10(n)) and calls h.on<g>(n);

template <typename Handler>

inline char *lg(uint32_t n, Handler h) {

return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n)

: n < 1000000

? n < 10000 ? n < 1000 ? h.template on<2>(n)

: h.template on<3>(n)

: n < 100000 ? h.template on<4>(n)

: h.template on<5>(n)

: n < 100000000 ? n < 10000000 ? h.template on<6>(n)

: h.template on<7>(n)

: n < 1000000000 ? h.template on<8>(n)

: h.template on<9>(n);

}

// An lg handler that formats a decimal number.

// Usage: lg(n, decimal_formatter(buffer));

class decimal_formatter {

private:

char *buffer_;

void write_pair(unsigned N, uint32_t index) {

std::memcpy(buffer_ + N, data::DIGITS + index * 2, 2);

}

public:

explicit decimal_formatter(char *buf) : buffer_(buf) {}

template <unsigned N> char *on(uint32_t u) {

if (N == 0) {

*buffer_ = static_cast<char>(u) + '0';

} else if (N == 1) {

write_pair(0, u);

} else {

// The idea of using 4.32 fixed-point numbers is based on

// https://github.com/jeaiii/itoa

unsigned n = N - 1;

unsigned a = n / 5 * n * 53 / 16;

uint64_t t = ((1ULL << (32 + a)) /

data::ZERO_OR_POWERS_OF_10_32[n] + 1 - n / 9);

t = ((t * u) >> a) + n / 5 * 4;

write_pair(0, t >> 32);

for (unsigned i = 2; i < N; i += 2) {

t = 100ULL * static_cast<uint32_t>(t);

write_pair(i, t >> 32);

}

if (N % 2 == 0) {

buffer_[N] = static_cast<char>(

(10ULL * static_cast<uint32_t>(t)) >> 32) + '0';

}

}

return buffer_ += N + 1;

}

};

// An lg handler that formats a decimal number with a terminating null.

class decimal_formatter_null : public decimal_formatter {

public:

explicit decimal_formatter_null(char *buf) : decimal_formatter(buf) {}

template <unsigned N> char *on(uint32_t u) {

char *buf = decimal_formatter::on<N>(u);

*buf = '\0';

return buf;

}

};

#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

// A functor that doesn't add a thousands separator.

struct no_thousands_sep {

typedef char char_type;

template <typename Char>

void operator()(Char *) {}

enum { size = 0 };

};

// A functor that adds a thousands separator.

template <typename Char>

class add_thousands_sep {

private:

basic_string_view<Char> sep_;

// Index of a decimal digit with the least significant digit having index 0.

unsigned digit_index_;

public:

typedef Char char_type;

explicit add_thousands_sep(basic_string_view<Char> sep)

: sep_(sep), digit_index_(0) {}

void operator()(Char *&buffer) {

if (++digit_index_ % 3 != 0)

return;

buffer -= sep_.size();

std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(),

internal::make_checked(buffer, sep_.size()));

}

enum { size = 1 };

};

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

}

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

// thousands_sep is a functor that is called after writing each char to

// add a thousands separator if necessary.

template <typename UInt, typename Char, typename ThousandsSep>

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

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

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

value /= 100;

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

thousands_sep(buffer);

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

thousands_sep(buffer);

}

if (value < 10) {

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

return end;

}

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

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

thousands_sep(buffer);

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

return end;

}

template <typename OutChar, typename UInt, typename Iterator,

typename ThousandsSep>

inline Iterator format_decimal(

Iterator out, UInt value, int num_digits, ThousandsSep sep) {

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

typedef typename ThousandsSep::char_type char_type;

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

enum { max_size = std::numeric_limits<UInt>::digits10 + 1 };

FMT_ASSERT(ThousandsSep::size <= 1, "invalid separator");

char_type buffer[max_size + max_size / 3];

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

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

}

template <typename OutChar, typename It, typename UInt>

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