3548 lines
114 KiB
C++
3548 lines
114 KiB
C++
/*
|
|
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 __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
|
|
|
|
#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
|
|
# define FMT_FALLTHROUGH [[gnu::fallthrough]]
|
|
# else
|
|
# define FMT_FALLTHROUGH
|
|
# endif
|
|
#elif (FMT_HAS_CPP_ATTRIBUTE(fallthrough) && (__cplusplus >= 201703)) || \
|
|
(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) do not support UDL templates yet
|
|
// and GCC 9 warns about them.
|
|
# if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && \
|
|
FMT_CUDA_VERSION == 0 && \
|
|
((FMT_GCC_VERSION >= 600 && 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 {
|
|
|
|
// A helper function to suppress bogus "conditional expression is constant"
|
|
// warnings.
|
|
template <typename T> inline T const_check(T value) { return value; }
|
|
|
|
// 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:
|
|
static const bool 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<char8_t> s) {
|
|
const char8_t* 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;
|
|
}
|
|
|
|
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_t> s, size_t n) {
|
|
const char8_t* 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_t to_char8_t(char c) { return static_cast<char8_t>(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_t>::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<char8_t> {
|
|
public:
|
|
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 basic_string_view<char8_t> operator"" _u(const char* s, std::size_t n) {
|
|
return {reinterpret_cast<const char8_t*>(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 = 5 };
|
|
Char data_[max_size + 1];
|
|
|
|
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];
|
|
data_[size] = Char();
|
|
}
|
|
|
|
size_t size() const {
|
|
size_t i = 1;
|
|
while (data_[i] && i <= max_size) ++i;
|
|
return i;
|
|
}
|
|
|
|
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(' ');
|
|
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;
|
|
|
|
namespace sign {
|
|
enum type { none, minus, plus, space };
|
|
}
|
|
using sign_t = sign::type;
|
|
|
|
// Format specifiers for built-in and string types.
|
|
template <typename Char> struct basic_format_specs {
|
|
int width;
|
|
int precision;
|
|
char type;
|
|
align_t align : 4;
|
|
sign_t sign : 3;
|
|
bool alt : 1; // Alternate form ('#').
|
|
internal::fill_t<Char> fill;
|
|
|
|
constexpr basic_format_specs()
|
|
: width(0),
|
|
precision(-1),
|
|
type(0),
|
|
align(align::none),
|
|
sign(sign::none),
|
|
alt(false),
|
|
fill(internal::fill_t<Char>::make()) {}
|
|
};
|
|
|
|
using format_specs = basic_format_specs<char>;
|
|
|
|
namespace internal {
|
|
|
|
// A floating-point presentation format.
|
|
enum class float_format : unsigned char {
|
|
general, // General: exponent notation or fixed point based on magnitude.
|
|
exp, // Exponent notation with the default precision of 6, e.g. 1.2e-3.
|
|
fixed, // Fixed point with the default precision of 6, e.g. 0.0012.
|
|
hex
|
|
};
|
|
|
|
struct float_specs {
|
|
int precision;
|
|
float_format format : 8;
|
|
sign_t sign : 8;
|
|
bool upper : 1;
|
|
bool locale : 1;
|
|
bool percent : 1;
|
|
bool binary32 : 1;
|
|
bool use_grisu : 1;
|
|
bool showpoint : 1;
|
|
};
|
|
|
|
// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
|
|
template <typename Char, typename It> It write_exponent(int exp, It it) {
|
|
FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
|
|
if (exp < 0) {
|
|
*it++ = static_cast<Char>('-');
|
|
exp = -exp;
|
|
} else {
|
|
*it++ = static_cast<Char>('+');
|
|
}
|
|
if (exp >= 100) {
|
|
const char* top = data::digits + (exp / 100) * 2;
|
|
if (exp >= 1000) *it++ = static_cast<Char>(top[0]);
|
|
*it++ = static_cast<Char>(top[1]);
|
|
exp %= 100;
|
|
}
|
|
const char* d = data::digits + exp * 2;
|
|
*it++ = static_cast<Char>(d[0]);
|
|
*it++ = static_cast<Char>(d[1]);
|
|
return it;
|
|
}
|
|
|
|
template <typename Char> class float_writer {
|
|
private:
|
|
// The number is given as v = digits_ * pow(10, exp_).
|
|
const char* digits_;
|
|
int num_digits_;
|
|
int exp_;
|
|
size_t size_;
|
|
float_specs specs_;
|
|
Char decimal_point_;
|
|
|
|
template <typename It> It prettify(It it) const {
|
|
// pow(10, full_exp - 1) <= v <= pow(10, full_exp).
|
|
int full_exp = num_digits_ + exp_;
|
|
if (specs_.format == float_format::exp) {
|
|
// Insert a decimal point after the first digit and add an exponent.
|
|
*it++ = static_cast<Char>(*digits_);
|
|
int num_zeros = specs_.precision - num_digits_;
|
|
if (num_digits_ > 1 || specs_.showpoint) *it++ = decimal_point_;
|
|
it = copy_str<Char>(digits_ + 1, digits_ + num_digits_, it);
|
|
if (num_zeros > 0 && specs_.showpoint)
|
|
it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
|
|
*it++ = static_cast<Char>(specs_.upper ? 'E' : 'e');
|
|
return write_exponent<Char>(full_exp - 1, it);
|
|
}
|
|
if (num_digits_ <= full_exp) {
|
|
// 1234e7 -> 12340000000[.0+]
|
|
it = copy_str<Char>(digits_, digits_ + num_digits_, it);
|
|
it = std::fill_n(it, full_exp - num_digits_, static_cast<Char>('0'));
|
|
if (specs_.showpoint || specs_.precision < 0) {
|
|
*it++ = decimal_point_;
|
|
int num_zeros = specs_.precision - full_exp;
|
|
if (num_zeros <= 0) {
|
|
if (specs_.format != float_format::fixed)
|
|
*it++ = static_cast<Char>('0');
|
|
return it;
|
|
}
|
|
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
|
|
if (num_zeros > 1000)
|
|
throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
|
|
#endif
|
|
it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
|
|
}
|
|
} else if (full_exp > 0) {
|
|
// 1234e-2 -> 12.34[0+]
|
|
it = copy_str<Char>(digits_, digits_ + full_exp, it);
|
|
if (!specs_.showpoint) {
|
|
// Remove trailing zeros.
|
|
int num_digits = num_digits_;
|
|
while (num_digits > full_exp && digits_[num_digits - 1] == '0')
|
|
--num_digits;
|
|
if (num_digits != full_exp) *it++ = decimal_point_;
|
|
return copy_str<Char>(digits_ + full_exp, digits_ + num_digits, it);
|
|
}
|
|
*it++ = decimal_point_;
|
|
it = copy_str<Char>(digits_ + full_exp, digits_ + num_digits_, it);
|
|
if (specs_.precision > num_digits_) {
|
|
// Add trailing zeros.
|
|
int num_zeros = specs_.precision - num_digits_;
|
|
it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
|
|
}
|
|
} else {
|
|
// 1234e-6 -> 0.001234
|
|
*it++ = static_cast<Char>('0');
|
|
int num_zeros = -full_exp;
|
|
if (specs_.precision >= 0 && specs_.precision < num_zeros)
|
|
num_zeros = specs_.precision;
|
|
int num_digits = num_digits_;
|
|
// Remove trailing zeros.
|
|
if (!specs_.showpoint)
|
|
while (num_digits > 0 && digits_[num_digits - 1] == '0') --num_digits;
|
|
if (num_zeros != 0 || num_digits != 0 || specs_.showpoint) {
|
|
*it++ = decimal_point_;
|
|
it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
|
|
it = copy_str<Char>(digits_, digits_ + num_digits, it);
|
|
}
|
|
}
|
|
return it;
|
|
}
|
|
|
|
public:
|
|
float_writer(const char* digits, int num_digits, int exp, float_specs specs,
|
|
Char decimal_point)
|
|
: digits_(digits),
|
|
num_digits_(num_digits),
|
|
exp_(exp),
|
|
specs_(specs),
|
|
decimal_point_(decimal_point) {
|
|
int full_exp = num_digits + exp - 1;
|
|
int precision = specs.precision > 0 ? specs.precision : 16;
|
|
if (specs_.format == float_format::general &&
|
|
!(full_exp >= -4 && full_exp < precision)) {
|
|
specs_.format = float_format::exp;
|
|
}
|
|
size_ = prettify(counting_iterator()).count();
|
|
size_ += specs.sign ? 1 : 0;
|
|
}
|
|
|
|
size_t size() const { return size_; }
|
|
size_t width() const { return size(); }
|
|
|
|
template <typename It> void operator()(It&& it) {
|
|
if (specs_.sign) *it++ = static_cast<Char>(data::signs[specs_.sign]);
|
|
it = prettify(it);
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
int format_float(T value, int precision, float_specs specs, buffer<char>& buf);
|
|
|
|
// Formats a floating-point number with snprintf.
|
|
template <typename T>
|
|
int snprintf_float(T value, int precision, float_specs specs,
|
|
buffer<char>& buf);
|
|
|
|
template <typename T> T promote_float(T value) { return value; }
|
|
inline double promote_float(float value) { return static_cast<double>(value); }
|
|
|
|
template <typename Handler>
|
|
FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
|
|
switch (spec) {
|
|
case 0:
|
|
case 'd':
|
|
handler.on_dec();
|
|
break;
|
|
case 'x':
|
|
case 'X':
|
|
handler.on_hex();
|
|
break;
|
|
case 'b':
|
|
case 'B':
|
|
handler.on_bin();
|
|
break;
|
|
case 'o':
|
|
handler.on_oct();
|
|
break;
|
|
case 'n':
|
|
handler.on_num();
|
|
break;
|
|
default:
|
|
handler.on_error();
|
|
}
|
|
}
|
|
|
|
template <typename ErrorHandler = error_handler, typename Char>
|
|
FMT_CONSTEXPR float_specs parse_float_type_spec(
|
|
const basic_format_specs<Char>& specs, ErrorHandler&& eh = {}) {
|
|
auto result = float_specs();
|
|
result.showpoint = specs.alt;
|
|
switch (specs.type) {
|
|
case 0:
|
|
result.format = float_format::general;
|
|
result.showpoint |= specs.precision > 0;
|
|
break;
|
|
case 'G':
|
|
result.upper = true;
|
|
FMT_FALLTHROUGH;
|
|
case 'g':
|
|
result.format = float_format::general;
|
|
break;
|
|
case 'E':
|
|
result.upper = true;
|
|
FMT_FALLTHROUGH;
|
|
case 'e':
|
|
result.format = float_format::exp;
|
|
result.showpoint |= specs.precision != 0;
|
|
break;
|
|
case 'F':
|
|
result.upper = true;
|
|
FMT_FALLTHROUGH;
|
|
case 'f':
|
|
result.format = float_format::fixed;
|
|
result.showpoint |= specs.precision != 0;
|
|
break;
|
|
#if FMT_DEPRECATED_PERCENT
|
|
case '%':
|
|
result.format = float_format::fixed;
|
|
result.percent = true;
|
|
break;
|
|
#endif
|
|
case 'A':
|
|
result.upper = true;
|
|
FMT_FALLTHROUGH;
|
|
case 'a':
|
|
result.format = float_format::hex;
|
|
break;
|
|
case 'n':
|
|
result.locale = true;
|
|
break;
|
|
default:
|
|
eh.on_error("invalid type specifier");
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
template <typename Char, typename Handler>
|
|
FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char>* specs,
|
|
Handler&& handler) {
|
|
if (!specs) return handler.on_char();
|
|
if (specs->type && specs->type != 'c') return handler.on_int();
|
|
if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)
|
|
handler.on_error("invalid format specifier for char");
|
|
handler.on_char();
|
|
}
|
|
|
|
template <typename Char, typename Handler>
|
|
FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) {
|
|
if (spec == 0 || spec == 's')
|
|
handler.on_string();
|
|
else if (spec == 'p')
|
|
handler.on_pointer();
|
|
else
|
|
handler.on_error("invalid type specifier");
|
|
}
|
|
|
|
template <typename Char, typename ErrorHandler>
|
|
FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh) {
|
|
if (spec != 0 && spec != 's') eh.on_error("invalid type specifier");
|
|
}
|
|
|
|
template <typename Char, typename ErrorHandler>
|
|
FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) {
|
|
if (spec != 0 && spec != 'p') eh.on_error("invalid type specifier");
|
|
}
|
|
|
|
template <typename ErrorHandler> class int_type_checker : private ErrorHandler {
|
|
public:
|
|
FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
|
|
|
|
FMT_CONSTEXPR void on_dec() {}
|
|
FMT_CONSTEXPR void on_hex() {}
|
|
FMT_CONSTEXPR void on_bin() {}
|
|
FMT_CONSTEXPR void on_oct() {}
|
|
FMT_CONSTEXPR void on_num() {}
|
|
|
|
FMT_CONSTEXPR void on_error() {
|
|
ErrorHandler::on_error("invalid type specifier");
|
|
}
|
|
};
|
|
|
|
template <typename ErrorHandler>
|
|
class char_specs_checker : public ErrorHandler {
|
|
private:
|
|
char type_;
|
|
|
|
public:
|
|
FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh)
|
|
: ErrorHandler(eh), type_(type) {}
|
|
|
|
FMT_CONSTEXPR void on_int() {
|
|
handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
|
|
}
|
|
FMT_CONSTEXPR void on_char() {}
|
|
};
|
|
|
|
template <typename ErrorHandler>
|
|
class cstring_type_checker : public ErrorHandler {
|
|
public:
|
|
FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)
|
|
: ErrorHandler(eh) {}
|
|
|
|
FMT_CONSTEXPR void on_string() {}
|
|
FMT_CONSTEXPR void on_pointer() {}
|
|
};
|
|
|
|
template <typename Context>
|
|
void arg_map<Context>::init(const basic_format_args<Context>& args) {
|
|
if (map_) return;
|
|
map_ = new entry[internal::to_unsigned(args.max_size())];
|
|
if (args.is_packed()) {
|
|
for (int i = 0;; ++i) {
|
|
internal::type arg_type = args.type(i);
|
|
if (arg_type == internal::type::none_type) return;
|
|
if (arg_type == internal::type::named_arg_type)
|
|
push_back(args.values_[i]);
|
|
}
|
|
}
|
|
for (int i = 0, n = args.max_size(); i < n; ++i) {
|
|
auto type = args.args_[i].type_;
|
|
if (type == internal::type::named_arg_type) push_back(args.args_[i].value_);
|
|
}
|
|
}
|
|
|
|
template <typename Char> struct nonfinite_writer {
|
|
sign_t sign;
|
|
const char* str;
|
|
static constexpr size_t str_size = 3;
|
|
|
|
size_t size() const { return str_size + (sign ? 1 : 0); }
|
|
size_t width() const { return size(); }
|
|
|
|
template <typename It> void operator()(It&& it) const {
|
|
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
|
|
it = copy_str<Char>(str, str + str_size, it);
|
|
}
|
|
};
|
|
|
|
template <typename OutputIt, typename Char>
|
|
OutputIt fill(OutputIt it, size_t n, const fill_t<Char>& fill) {
|
|
auto fill_size = fill.size();
|
|
if (fill_size == 1) return std::fill_n(it, n, fill[0]);
|
|
for (size_t i = 0; i < n; ++i) it = std::copy_n(fill.data(), fill_size, it);
|
|
return it;
|
|
}
|
|
|
|
// This template provides operations for formatting and writing data into a
|
|
// character range.
|
|
template <typename Range> class basic_writer {
|
|
public:
|
|
using char_type = typename Range::value_type;
|
|
using iterator = typename Range::iterator;
|
|
using format_specs = basic_format_specs<char_type>;
|
|
|
|
private:
|
|
iterator out_; // Output iterator.
|
|
locale_ref locale_;
|
|
|
|
// Attempts to reserve space for n extra characters in the output range.
|
|
// Returns a pointer to the reserved range or a reference to out_.
|
|
auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
|
|
return internal::reserve(out_, n);
|
|
}
|
|
|
|
template <typename F> struct padded_int_writer {
|
|
size_t size_;
|
|
string_view prefix;
|
|
char_type fill;
|
|
std::size_t padding;
|
|
F f;
|
|
|
|
size_t size() const { return size_; }
|
|
size_t width() const { return size_; }
|
|
|
|
template <typename It> void operator()(It&& it) const {
|
|
if (prefix.size() != 0)
|
|
it = copy_str<char_type>(prefix.begin(), prefix.end(), it);
|
|
it = std::fill_n(it, padding, fill);
|
|
f(it);
|
|
}
|
|
};
|
|
|
|
// Writes an integer in the format
|
|
// <left-padding><prefix><numeric-padding><digits><right-padding>
|
|
// where <digits> are written by f(it).
|
|
template <typename F>
|
|
void write_int(int num_digits, string_view prefix, format_specs specs, F f) {
|
|
std::size_t size = prefix.size() + to_unsigned(num_digits);
|
|
char_type fill = specs.fill[0];
|
|
std::size_t padding = 0;
|
|
if (specs.align == align::numeric) {
|
|
auto unsiged_width = to_unsigned(specs.width);
|
|
if (unsiged_width > size) {
|
|
padding = unsiged_width - size;
|
|
size = unsiged_width;
|
|
}
|
|
} else if (specs.precision > num_digits) {
|
|
size = prefix.size() + to_unsigned(specs.precision);
|
|
padding = to_unsigned(specs.precision - num_digits);
|
|
fill = static_cast<char_type>('0');
|
|
}
|
|
if (specs.align == align::none) specs.align = align::right;
|
|
write_padded(specs, padded_int_writer<F>{size, prefix, fill, padding, f});
|
|
}
|
|
|
|
// Writes a decimal integer.
|
|
template <typename Int> void write_decimal(Int value) {
|
|
auto abs_value = static_cast<uint32_or_64_or_128_t<Int>>(value);
|
|
bool negative = is_negative(value);
|
|
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
|
|
if (negative) abs_value = ~abs_value + 1;
|
|
int num_digits = count_digits(abs_value);
|
|
auto&& it = reserve((negative ? 1 : 0) + static_cast<size_t>(num_digits));
|
|
if (negative) *it++ = static_cast<char_type>('-');
|
|
it = format_decimal<char_type>(it, abs_value, num_digits);
|
|
}
|
|
|
|
// The handle_int_type_spec handler that writes an integer.
|
|
template <typename Int, typename Specs> struct int_writer {
|
|
using unsigned_type = uint32_or_64_or_128_t<Int>;
|
|
|
|
basic_writer<Range>& writer;
|
|
const Specs& specs;
|
|
unsigned_type abs_value;
|
|
char prefix[4];
|
|
unsigned prefix_size;
|
|
|
|
string_view get_prefix() const { return string_view(prefix, prefix_size); }
|
|
|
|
int_writer(basic_writer<Range>& w, Int value, const Specs& s)
|
|
: writer(w),
|
|
specs(s),
|
|
abs_value(static_cast<unsigned_type>(value)),
|
|
prefix_size(0) {
|
|
if (is_negative(value)) {
|
|
prefix[0] = '-';
|
|
++prefix_size;
|
|
abs_value = 0 - abs_value;
|
|
} else if (specs.sign != sign::none && specs.sign != sign::minus) {
|
|
prefix[0] = specs.sign == sign::plus ? '+' : ' ';
|
|
++prefix_size;
|
|
}
|
|
}
|
|
|
|
struct dec_writer {
|
|
unsigned_type abs_value;
|
|
int num_digits;
|
|
|
|
template <typename It> void operator()(It&& it) const {
|
|
it = internal::format_decimal<char_type>(it, abs_value, num_digits);
|
|
}
|
|
};
|
|
|
|
void on_dec() {
|
|
int num_digits = count_digits(abs_value);
|
|
writer.write_int(num_digits, get_prefix(), specs,
|
|
dec_writer{abs_value, num_digits});
|
|
}
|
|
|
|
struct hex_writer {
|
|
int_writer& self;
|
|
int num_digits;
|
|
|
|
template <typename It> void operator()(It&& it) const {
|
|
it = format_uint<4, char_type>(it, self.abs_value, num_digits,
|
|
self.specs.type != 'x');
|
|
}
|
|
};
|
|
|
|
void on_hex() {
|
|
if (specs.alt) {
|
|
prefix[prefix_size++] = '0';
|
|
prefix[prefix_size++] = specs.type;
|
|
}
|
|
int num_digits = count_digits<4>(abs_value);
|
|
writer.write_int(num_digits, get_prefix(), specs,
|
|
hex_writer{*this, num_digits});
|
|
}
|
|
|
|
template <int BITS> struct bin_writer {
|
|
unsigned_type abs_value;
|
|
int num_digits;
|
|
|
|
template <typename It> void operator()(It&& it) const {
|
|
it = format_uint<BITS, char_type>(it, abs_value, num_digits);
|
|
}
|
|
};
|
|
|
|
void on_bin() {
|
|
if (specs.alt) {
|
|
prefix[prefix_size++] = '0';
|
|
prefix[prefix_size++] = static_cast<char>(specs.type);
|
|
}
|
|
int num_digits = count_digits<1>(abs_value);
|
|
writer.write_int(num_digits, get_prefix(), specs,
|
|
bin_writer<1>{abs_value, num_digits});
|
|
}
|
|
|
|
void on_oct() {
|
|
int num_digits = count_digits<3>(abs_value);
|
|
if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
|
|
// Octal prefix '0' is counted as a digit, so only add it if precision
|
|
// is not greater than the number of digits.
|
|
prefix[prefix_size++] = '0';
|
|
}
|
|
writer.write_int(num_digits, get_prefix(), specs,
|
|
bin_writer<3>{abs_value, num_digits});
|
|
}
|
|
|
|
enum { sep_size = 1 };
|
|
|
|
struct num_writer {
|
|
unsigned_type abs_value;
|
|
int size;
|
|
const std::string& groups;
|
|
char_type sep;
|
|
|
|
template <typename It> void operator()(It&& it) const {
|
|
basic_string_view<char_type> s(&sep, sep_size);
|
|
// Index of a decimal digit with the least significant digit having
|
|
// index 0.
|
|
int digit_index = 0;
|
|
std::string::const_iterator group = groups.cbegin();
|
|
it = format_decimal<char_type>(
|
|
it, abs_value, size,
|
|
[this, s, &group, &digit_index](char_type*& buffer) {
|
|
if (*group <= 0 || ++digit_index % *group != 0 ||
|
|
*group == max_value<char>())
|
|
return;
|
|
if (group + 1 != groups.cend()) {
|
|
digit_index = 0;
|
|
++group;
|
|
}
|
|
buffer -= s.size();
|
|
std::uninitialized_copy(s.data(), s.data() + s.size(),
|
|
make_checked(buffer, s.size()));
|
|
});
|
|
}
|
|
};
|
|
|
|
void on_num() {
|
|
std::string groups = grouping<char_type>(writer.locale_);
|
|
if (groups.empty()) return on_dec();
|
|
auto sep = thousands_sep<char_type>(writer.locale_);
|
|
if (!sep) return on_dec();
|
|
int num_digits = count_digits(abs_value);
|
|
int size = num_digits;
|
|
std::string::const_iterator group = groups.cbegin();
|
|
while (group != groups.cend() && num_digits > *group && *group > 0 &&
|
|
*group != max_value<char>()) {
|
|
size += sep_size;
|
|
num_digits -= *group;
|
|
++group;
|
|
}
|
|
if (group == groups.cend())
|
|
size += sep_size * ((num_digits - 1) / groups.back());
|
|
writer.write_int(size, get_prefix(), specs,
|
|
num_writer{abs_value, size, groups, sep});
|
|
}
|
|
|
|
FMT_NORETURN void on_error() {
|
|
FMT_THROW(format_error("invalid type specifier"));
|
|
}
|
|
};
|
|
|
|
template <typename Char> struct str_writer {
|
|
const Char* s;
|
|
size_t size_;
|
|
|
|
size_t size() const { return size_; }
|
|
size_t width() const {
|
|
return count_code_points(basic_string_view<Char>(s, size_));
|
|
}
|
|
|
|
template <typename It> void operator()(It&& it) const {
|
|
it = copy_str<char_type>(s, s + size_, it);
|
|
}
|
|
};
|
|
|
|
template <typename UIntPtr> struct pointer_writer {
|
|
UIntPtr value;
|
|
int num_digits;
|
|
|
|
size_t size() const { return to_unsigned(num_digits) + 2; }
|
|
size_t width() const { return size(); }
|
|
|
|
template <typename It> void operator()(It&& it) const {
|
|
*it++ = static_cast<char_type>('0');
|
|
*it++ = static_cast<char_type>('x');
|
|
it = format_uint<4, char_type>(it, value, num_digits);
|
|
}
|
|
};
|
|
|
|
public:
|
|
explicit basic_writer(Range out, locale_ref loc = locale_ref())
|
|
: out_(out.begin()), locale_(loc) {}
|
|
|
|
iterator out() const { return out_; }
|
|
|
|
// Writes a value in the format
|
|
// <left-padding><value><right-padding>
|
|
// where <value> is written by f(it).
|
|
template <typename F> void write_padded(const format_specs& specs, F&& f) {
|
|
// User-perceived width (in code points).
|
|
unsigned width = to_unsigned(specs.width);
|
|
size_t size = f.size(); // The number of code units.
|
|
size_t num_code_points = width != 0 ? f.width() : size;
|
|
if (width <= num_code_points) return f(reserve(size));
|
|
size_t padding = width - num_code_points;
|
|
size_t fill_size = specs.fill.size();
|
|
auto&& it = reserve(size + padding * fill_size);
|
|
if (specs.align == align::right) {
|
|
it = fill(it, padding, specs.fill);
|
|
f(it);
|
|
} else if (specs.align == align::center) {
|
|
std::size_t left_padding = padding / 2;
|
|
it = fill(it, left_padding, specs.fill);
|
|
f(it);
|
|
it = fill(it, padding - left_padding, specs.fill);
|
|
} else {
|
|
f(it);
|
|
it = fill(it, padding, specs.fill);
|
|
}
|
|
}
|
|
|
|
void write(int value) { write_decimal(value); }
|
|
void write(long value) { write_decimal(value); }
|
|
void write(long long value) { write_decimal(value); }
|
|
|
|
void write(unsigned value) { write_decimal(value); }
|
|
void write(unsigned long value) { write_decimal(value); }
|
|
void write(unsigned long long value) { write_decimal(value); }
|
|
|
|
#if FMT_USE_INT128
|
|
void write(int128_t value) { write_decimal(value); }
|
|
void write(uint128_t value) { write_decimal(value); }
|
|
#endif
|
|
|
|
template <typename T, typename Spec>
|
|
void write_int(T value, const Spec& spec) {
|
|
handle_int_type_spec(spec.type, int_writer<T, Spec>(*this, value, spec));
|
|
}
|
|
|
|
template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
|
|
void write(T value, format_specs specs = {}) {
|
|
float_specs fspecs = parse_float_type_spec(specs);
|
|
fspecs.sign = specs.sign;
|
|
if (std::signbit(value)) { // value < 0 is false for NaN so use signbit.
|
|
fspecs.sign = sign::minus;
|
|
value = -value;
|
|
} else if (fspecs.sign == sign::minus) {
|
|
fspecs.sign = sign::none;
|
|
}
|
|
|
|
if (!std::isfinite(value)) {
|
|
auto str = std::isinf(value) ? (fspecs.upper ? "INF" : "inf")
|
|
: (fspecs.upper ? "NAN" : "nan");
|
|
return write_padded(specs, nonfinite_writer<char_type>{fspecs.sign, str});
|
|
}
|
|
|
|
if (specs.align == align::none) {
|
|
specs.align = align::right;
|
|
} else if (specs.align == align::numeric) {
|
|
if (fspecs.sign) {
|
|
auto&& it = reserve(1);
|
|
*it++ = static_cast<char_type>(data::signs[fspecs.sign]);
|
|
fspecs.sign = sign::none;
|
|
if (specs.width != 0) --specs.width;
|
|
}
|
|
specs.align = align::right;
|
|
}
|
|
|
|
memory_buffer buffer;
|
|
if (fspecs.format == float_format::hex) {
|
|
if (fspecs.sign) buffer.push_back(data::signs[fspecs.sign]);
|
|
snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
|
|
write_padded(specs, str_writer<char>{buffer.data(), buffer.size()});
|
|
return;
|
|
}
|
|
int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
|
|
if (fspecs.format == float_format::exp) {
|
|
if (precision == max_value<int>())
|
|
FMT_THROW(format_error("number is too big"));
|
|
else
|
|
++precision;
|
|
}
|
|
if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
|
|
fspecs.use_grisu = use_grisu<T>();
|
|
if (const_check(FMT_DEPRECATED_PERCENT) && fspecs.percent) value *= 100;
|
|
int exp = format_float(promote_float(value), precision, fspecs, buffer);
|
|
if (const_check(FMT_DEPRECATED_PERCENT) && fspecs.percent) {
|
|
buffer.push_back('%');
|
|
--exp; // Adjust decimal place position.
|
|
}
|
|
fspecs.precision = precision;
|
|
char_type point = fspecs.locale ? decimal_point<char_type>(locale_)
|
|
: static_cast<char_type>('.');
|
|
write_padded(specs, float_writer<char_type>(buffer.data(),
|
|
static_cast<int>(buffer.size()),
|
|
exp, fspecs, point));
|
|
}
|
|
|
|
void write(char value) {
|
|
auto&& it = reserve(1);
|
|
*it++ = value;
|
|
}
|
|
|
|
template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char_type>::value)>
|
|
void write(Char value) {
|
|
auto&& it = reserve(1);
|
|
*it++ = value;
|
|
}
|
|
|
|
void write(string_view value) {
|
|
auto&& it = reserve(value.size());
|
|
it = copy_str<char_type>(value.begin(), value.end(), it);
|
|
}
|
|
void write(wstring_view value) {
|
|
static_assert(std::is_same<char_type, wchar_t>::value, "");
|
|
auto&& it = reserve(value.size());
|
|
it = std::copy(value.begin(), value.end(), it);
|
|
}
|
|
|
|
template <typename Char>
|
|
void write(const Char* s, std::size_t size, const format_specs& specs) {
|
|
write_padded(specs, str_writer<Char>{s, size});
|
|
}
|
|
|
|
template <typename Char>
|
|
void write(basic_string_view<Char> s, const format_specs& specs = {}) {
|
|
const Char* data = s.data();
|
|
std::size_t size = s.size();
|
|
if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
|
|
size = code_point_index(s, to_unsigned(specs.precision));
|
|
write(data, size, specs);
|
|
}
|
|
|
|
template <typename UIntPtr>
|
|
void write_pointer(UIntPtr value, const format_specs* specs) {
|
|
int num_digits = count_digits<4>(value);
|
|
auto pw = pointer_writer<UIntPtr>{value, num_digits};
|
|
if (!specs) return pw(reserve(to_unsigned(num_digits) + 2));
|
|
format_specs specs_copy = *specs;
|
|
if (specs_copy.align == align::none) specs_copy.align = align::right;
|
|
write_padded(specs_copy, pw);
|
|
}
|
|
};
|
|
|
|
using writer = basic_writer<buffer_range<char>>;
|
|
|
|
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 Range, typename ErrorHandler = internal::error_handler>
|
|
class arg_formatter_base {
|
|
public:
|
|
using char_type = typename Range::value_type;
|
|
using iterator = typename Range::iterator;
|
|
using format_specs = basic_format_specs<char_type>;
|
|
|
|
private:
|
|
using writer_type = basic_writer<Range>;
|
|
writer_type writer_;
|
|
format_specs* specs_;
|
|
|
|
struct char_writer {
|
|
char_type value;
|
|
|
|
size_t size() const { return 1; }
|
|
size_t width() const { return 1; }
|
|
|
|
template <typename It> void operator()(It&& it) const { *it++ = value; }
|
|
};
|
|
|
|
void write_char(char_type value) {
|
|
if (specs_)
|
|
writer_.write_padded(*specs_, char_writer{value});
|
|
else
|
|
writer_.write(value);
|
|
}
|
|
|
|
void write_pointer(const void* p) {
|
|
writer_.write_pointer(internal::to_uintptr(p), specs_);
|
|
}
|
|
|
|
protected:
|
|
writer_type& writer() { return writer_; }
|
|
FMT_DEPRECATED format_specs* spec() { return specs_; }
|
|
format_specs* specs() { return specs_; }
|
|
iterator out() { return writer_.out(); }
|
|
|
|
void write(bool value) {
|
|
string_view sv(value ? "true" : "false");
|
|
specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
|
|
}
|
|
|
|
void write(const char_type* value) {
|
|
if (!value) {
|
|
FMT_THROW(format_error("string pointer is null"));
|
|
} else {
|
|
auto length = std::char_traits<char_type>::length(value);
|
|
basic_string_view<char_type> sv(value, length);
|
|
specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
|
|
}
|
|
}
|
|
|
|
public:
|
|
arg_formatter_base(Range r, format_specs* s, locale_ref loc)
|
|
: writer_(r, loc), specs_(s) {}
|
|
|
|
iterator operator()(monostate) {
|
|
FMT_ASSERT(false, "invalid argument type");
|
|
return out();
|
|
}
|
|
|
|
template <typename T, FMT_ENABLE_IF(is_integral<T>::value)>
|
|
iterator operator()(T value) {
|
|
if (specs_)
|
|
writer_.write_int(value, *specs_);
|
|
else
|
|
writer_.write(value);
|
|
return out();
|
|
}
|
|
|
|
iterator operator()(char_type value) {
|
|
internal::handle_char_specs(
|
|
specs_, char_spec_handler(*this, static_cast<char_type>(value)));
|
|
return out();
|
|
}
|
|
|
|
iterator operator()(bool value) {
|
|
if (specs_ && specs_->type) return (*this)(value ? 1 : 0);
|
|
write(value != 0);
|
|
return out();
|
|
}
|
|
|
|
template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
|
|
iterator operator()(T value) {
|
|
writer_.write(value, specs_ ? *specs_ : format_specs());
|
|
return out();
|
|
}
|
|
|
|
struct char_spec_handler : ErrorHandler {
|
|
arg_formatter_base& formatter;
|
|
char_type value;
|
|
|
|
char_spec_handler(arg_formatter_base& f, char_type val)
|
|
: formatter(f), value(val) {}
|
|
|
|
void on_int() {
|
|
if (formatter.specs_)
|
|
formatter.writer_.write_int(value, *formatter.specs_);
|
|
else
|
|
formatter.writer_.write(value);
|
|
}
|
|
void on_char() { formatter.write_char(value); }
|
|
};
|
|
|
|
struct cstring_spec_handler : internal::error_handler {
|
|
arg_formatter_base& formatter;
|
|
const char_type* value;
|
|
|
|
cstring_spec_handler(arg_formatter_base& f, const char_type* val)
|
|
: formatter(f), value(val) {}
|
|
|
|
void on_string() { formatter.write(value); }
|
|
void on_pointer() { formatter.write_pointer(value); }
|
|
};
|
|
|
|
iterator operator()(const char_type* value) {
|
|
if (!specs_) return write(value), out();
|
|
internal::handle_cstring_type_spec(specs_->type,
|
|
cstring_spec_handler(*this, value));
|
|
return out();
|
|
}
|
|
|
|
iterator operator()(basic_string_view<char_type> value) {
|
|
if (specs_) {
|
|
internal::check_string_type_spec(specs_->type, internal::error_handler());
|
|
writer_.write(value, *specs_);
|
|
} else {
|
|
writer_.write(value);
|
|
}
|
|
return out();
|
|
}
|
|
|
|
iterator operator()(const void* value) {
|
|
if (specs_)
|
|
check_pointer_type_spec(specs_->type, internal::error_handler());
|
|
write_pointer(value);
|
|
return out();
|
|
}
|
|
};
|
|
|
|
template <typename Char> FMT_CONSTEXPR bool is_name_start(Char c) {
|
|
return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
|
|
}
|
|
|
|
// Parses the range [begin, end) as an unsigned integer. This function assumes
|
|
// that the range is non-empty and the first character is a digit.
|
|
template <typename Char, typename ErrorHandler>
|
|
FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
|
|
ErrorHandler&& eh) {
|
|
FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
|
|
if (*begin == '0') {
|
|
++begin;
|
|
return 0;
|
|
}
|
|
unsigned value = 0;
|
|
// Convert to unsigned to prevent a warning.
|
|
constexpr unsigned max_int = max_value<int>();
|
|
unsigned big = max_int / 10;
|
|
do {
|
|
// Check for overflow.
|
|
if (value > big) {
|
|
value = max_int + 1;
|
|
break;
|
|
}
|
|
value = value * 10 + unsigned(*begin - '0');
|
|
++begin;
|
|
} while (begin != end && '0' <= *begin && *begin <= '9');
|
|
if (value > max_int) eh.on_error("number is too big");
|
|
return static_cast<int>(value);
|
|
}
|
|
|
|
template <typename Context> class custom_formatter {
|
|
private:
|
|
using char_type = typename Context::char_type;
|
|
|
|
basic_format_parse_context<char_type>& parse_ctx_;
|
|
Context& ctx_;
|
|
|
|
public:
|
|
explicit custom_formatter(basic_format_parse_context<char_type>& parse_ctx,
|
|
Context& ctx)
|
|
: parse_ctx_(parse_ctx), ctx_(ctx) {}
|
|
|
|
bool operator()(typename basic_format_arg<Context>::handle h) const {
|
|
h.format(parse_ctx_, ctx_);
|
|
return true;
|
|
}
|
|
|
|
template <typename T> bool operator()(T) const { return false; }
|
|
};
|
|
|
|
template <typename T>
|
|
using is_integer =
|
|
bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
|
|
!std::is_same<T, char>::value &&
|
|
!std::is_same<T, wchar_t>::value>;
|
|
|
|
template <typename ErrorHandler> class width_checker {
|
|
public:
|
|
explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}
|
|
|
|
template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
|
|
FMT_CONSTEXPR unsigned long long operator()(T value) {
|
|
if (is_negative(value)) handler_.on_error("negative width");
|
|
return static_cast<unsigned long long>(value);
|
|
}
|
|
|
|
template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
|
|
FMT_CONSTEXPR unsigned long long operator()(T) {
|
|
handler_.on_error("width is not integer");
|
|
return 0;
|
|
}
|
|
|
|
private:
|
|
ErrorHandler& handler_;
|
|
};
|
|
|
|
template <typename ErrorHandler> class precision_checker {
|
|
public:
|
|
explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}
|
|
|
|
template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
|
|
FMT_CONSTEXPR unsigned long long operator()(T value) {
|
|
if (is_negative(value)) handler_.on_error("negative precision");
|
|
return static_cast<unsigned long long>(value);
|
|
}
|
|
|
|
template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
|
|
FMT_CONSTEXPR unsigned long long operator()(T) {
|
|
handler_.on_error("precision is not integer");
|
|
return 0;
|
|
}
|
|
|
|
private:
|
|
ErrorHandler& handler_;
|
|
};
|
|
|
|
// A format specifier handler that sets fields in basic_format_specs.
|
|
template <typename Char> class specs_setter {
|
|
public:
|
|
explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char>& specs)
|
|
: specs_(specs) {}
|
|
|
|
FMT_CONSTEXPR specs_setter(const specs_setter& other)
|
|
: specs_(other.specs_) {}
|
|
|
|
FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
|
|
FMT_CONSTEXPR void on_fill(basic_string_view<Char> fill) {
|
|
specs_.fill = fill;
|
|
}
|
|
FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
|
|
FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
|
|
FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
|
|
FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
|
|
|
|
FMT_CONSTEXPR void on_zero() {
|
|
specs_.align = align::numeric;
|
|
specs_.fill[0] = Char('0');
|
|
}
|
|
|
|
FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
|
|
FMT_CONSTEXPR void on_precision(int precision) {
|
|
specs_.precision = precision;
|
|
}
|
|
FMT_CONSTEXPR void end_precision() {}
|
|
|
|
FMT_CONSTEXPR void on_type(Char type) {
|
|
specs_.type = static_cast<char>(type);
|
|
}
|
|
|
|
protected:
|
|
basic_format_specs<Char>& specs_;
|
|
};
|
|
|
|
template <typename ErrorHandler> class numeric_specs_checker {
|
|
public:
|
|
FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, internal::type arg_type)
|
|
: error_handler_(eh), arg_type_(arg_type) {}
|
|
|
|
FMT_CONSTEXPR void require_numeric_argument() {
|
|
if (!is_arithmetic_type(arg_type_))
|
|
error_handler_.on_error("format specifier requires numeric argument");
|
|
}
|
|
|
|
FMT_CONSTEXPR void check_sign() {
|
|
require_numeric_argument();
|
|
if (is_integral_type(arg_type_) && arg_type_ != type::int_type &&
|
|
arg_type_ != type::long_long_type && arg_type_ != type::char_type) {
|
|
error_handler_.on_error("format specifier requires signed argument");
|
|
}
|
|
}
|
|
|
|
FMT_CONSTEXPR void check_precision() {
|
|
if (is_integral_type(arg_type_) || arg_type_ == type::pointer_type)
|
|
error_handler_.on_error("precision not allowed for this argument type");
|
|
}
|
|
|
|
private:
|
|
ErrorHandler& error_handler_;
|
|
internal::type arg_type_;
|
|
};
|
|
|
|
// A format specifier handler that checks if specifiers are consistent with the
|
|
// argument type.
|
|
template <typename Handler> class specs_checker : public Handler {
|
|
public:
|
|
FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type)
|
|
: Handler(handler), checker_(*this, arg_type) {}
|
|
|
|
FMT_CONSTEXPR specs_checker(const specs_checker& other)
|
|
: Handler(other), checker_(*this, other.arg_type_) {}
|
|
|
|
FMT_CONSTEXPR void on_align(align_t align) {
|
|
if (align == align::numeric) checker_.require_numeric_argument();
|
|
Handler::on_align(align);
|
|
}
|
|
|
|
FMT_CONSTEXPR void on_plus() {
|
|
checker_.check_sign();
|
|
Handler::on_plus();
|
|
}
|
|
|
|
FMT_CONSTEXPR void on_minus() {
|
|
checker_.check_sign();
|
|
Handler::on_minus();
|
|
}
|
|
|
|
FMT_CONSTEXPR void on_space() {
|
|
checker_.check_sign();
|
|
Handler::on_space();
|
|
}
|
|
|
|
FMT_CONSTEXPR void on_hash() {
|
|
checker_.require_numeric_argument();
|
|
Handler::on_hash();
|
|
}
|
|
|
|
FMT_CONSTEXPR void on_zero() {
|
|
checker_.require_numeric_argument();
|
|
Handler::on_zero();
|
|
}
|
|
|
|
FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }
|
|
|
|
private:
|
|
numeric_specs_checker<Handler> checker_;
|
|
};
|
|
|
|
template <template <typename> class Handler, typename FormatArg,
|
|
typename ErrorHandler>
|
|
FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
|
|
unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
|
|
if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
|
|
return static_cast<int>(value);
|
|
}
|
|
|
|
struct auto_id {};
|
|
|
|
template <typename Context>
|
|
FMT_CONSTEXPR typename Context::format_arg get_arg(Context& ctx, int id) {
|
|
auto arg = ctx.arg(id);
|
|
if (!arg) ctx.on_error("argument index out of range");
|
|
return arg;
|
|
}
|
|
|
|
// The standard format specifier handler with checking.
|
|
template <typename ParseContext, typename Context>
|
|
class specs_handler : public specs_setter<typename Context::char_type> {
|
|
public:
|
|
using char_type = typename Context::char_type;
|
|
|
|
FMT_CONSTEXPR specs_handler(basic_format_specs<char_type>& specs,
|
|
ParseContext& parse_ctx, Context& ctx)
|
|
: specs_setter<char_type>(specs),
|
|
parse_context_(parse_ctx),
|
|
context_(ctx) {}
|
|
|
|
template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
|
|
this->specs_.width = get_dynamic_spec<width_checker>(
|
|
get_arg(arg_id), context_.error_handler());
|
|
}
|
|
|
|
template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
|
|
this->specs_.precision = get_dynamic_spec<precision_checker>(
|
|
get_arg(arg_id), context_.error_handler());
|
|
}
|
|
|
|
void on_error(const char* message) { context_.on_error(message); }
|
|
|
|
private:
|
|
// This is only needed for compatibility with gcc 4.4.
|
|
using format_arg = typename Context::format_arg;
|
|
|
|
FMT_CONSTEXPR format_arg get_arg(auto_id) {
|
|
return internal::get_arg(context_, parse_context_.next_arg_id());
|
|
}
|
|
|
|
FMT_CONSTEXPR format_arg get_arg(int arg_id) {
|
|
parse_context_.check_arg_id(arg_id);
|
|
return internal::get_arg(context_, arg_id);
|
|
}
|
|
|
|
FMT_CONSTEXPR format_arg get_arg(basic_string_view<char_type> arg_id) {
|
|
parse_context_.check_arg_id(arg_id);
|
|
return context_.arg(arg_id);
|
|
}
|
|
|
|
ParseContext& parse_context_;
|
|
Context& context_;
|
|
};
|
|
|
|
enum class arg_id_kind { none, index, name };
|
|
|
|
// An argument reference.
|
|
template <typename Char> struct arg_ref {
|
|
FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
|
|
FMT_CONSTEXPR explicit arg_ref(int index)
|
|
: kind(arg_id_kind::index), val(index) {}
|
|
FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
|
|
: kind(arg_id_kind::name), val(name) {}
|
|
|
|
FMT_CONSTEXPR arg_ref& operator=(int idx) {
|
|
kind = arg_id_kind::index;
|
|
val.index = idx;
|
|
return *this;
|
|
}
|
|
|
|
arg_id_kind kind;
|
|
union value {
|
|
FMT_CONSTEXPR value(int id = 0) : index{id} {}
|
|
FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
|
|
|
|
int index;
|
|
basic_string_view<Char> name;
|
|
} val;
|
|
};
|
|
|
|
// Format specifiers with width and precision resolved at formatting rather
|
|
// than parsing time to allow re-using the same parsed specifiers with
|
|
// different sets of arguments (precompilation of format strings).
|
|
template <typename Char>
|
|
struct dynamic_format_specs : basic_format_specs<Char> {
|
|
arg_ref<Char> width_ref;
|
|
arg_ref<Char> precision_ref;
|
|
};
|
|
|
|
// Format spec handler that saves references to arguments representing dynamic
|
|
// width and precision to be resolved at formatting time.
|
|
template <typename ParseContext>
|
|
class dynamic_specs_handler
|
|
: public specs_setter<typename ParseContext::char_type> {
|
|
public:
|
|
using char_type = typename ParseContext::char_type;
|
|
|
|
FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type>& specs,
|
|
ParseContext& ctx)
|
|
: specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
|
|
|
|
FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler& other)
|
|
: specs_setter<char_type>(other),
|
|
specs_(other.specs_),
|
|
context_(other.context_) {}
|
|
|
|
template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
|
|
specs_.width_ref = make_arg_ref(arg_id);
|
|
}
|
|
|
|
template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
|
|
specs_.precision_ref = make_arg_ref(arg_id);
|
|
}
|
|
|
|
FMT_CONSTEXPR void on_error(const char* message) {
|
|
context_.on_error(message);
|
|
}
|
|
|
|
private:
|
|
using arg_ref_type = arg_ref<char_type>;
|
|
|
|
FMT_CONSTEXPR arg_ref_type make_arg_ref(int arg_id) {
|
|
context_.check_arg_id(arg_id);
|
|
return arg_ref_type(arg_id);
|
|
}
|
|
|
|
FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) {
|
|
return arg_ref_type(context_.next_arg_id());
|
|
}
|
|
|
|
FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<char_type> arg_id) {
|
|
context_.check_arg_id(arg_id);
|
|
basic_string_view<char_type> format_str(
|
|
context_.begin(), to_unsigned(context_.end() - context_.begin()));
|
|
return arg_ref_type(arg_id);
|
|
}
|
|
|
|
dynamic_format_specs<char_type>& specs_;
|
|
ParseContext& context_;
|
|
};
|
|
|
|
template <typename Char, typename IDHandler>
|
|
FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
|
|
IDHandler&& handler) {
|
|
FMT_ASSERT(begin != end, "");
|
|
Char c = *begin;
|
|
if (c == '}' || c == ':') {
|
|
handler();
|
|
return begin;
|
|
}
|
|
if (c >= '0' && c <= '9') {
|
|
int index = parse_nonnegative_int(begin, end, handler);
|
|
if (begin == end || (*begin != '}' && *begin != ':'))
|
|
handler.on_error("invalid format string");
|
|
else
|
|
handler(index);
|
|
return begin;
|
|
}
|
|
if (!is_name_start(c)) {
|
|
handler.on_error("invalid format string");
|
|
return begin;
|
|
}
|
|
auto it = begin;
|
|
do {
|
|
++it;
|
|
} while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
|
|
handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
|
|
return it;
|
|
}
|
|
|
|
// Adapts SpecHandler to IDHandler API for dynamic width.
|
|
template <typename SpecHandler, typename Char> struct width_adapter {
|
|
explicit FMT_CONSTEXPR width_adapter(SpecHandler& h) : handler(h) {}
|
|
|
|
FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
|
|
FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
|
|
FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
|
|
handler.on_dynamic_width(id);
|
|
}
|
|
|
|
FMT_CONSTEXPR void on_error(const char* message) {
|
|
handler.on_error(message);
|
|
}
|
|
|
|
SpecHandler& handler;
|
|
};
|
|
|
|
// Adapts SpecHandler to IDHandler API for dynamic precision.
|
|
template <typename SpecHandler, typename Char> struct precision_adapter {
|
|
explicit FMT_CONSTEXPR precision_adapter(SpecHandler& h) : handler(h) {}
|
|
|
|
FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
|
|
FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
|
|
FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
|
|
handler.on_dynamic_precision(id);
|
|
}
|
|
|
|
FMT_CONSTEXPR void on_error(const char* message) {
|
|
handler.on_error(message);
|
|
}
|
|
|
|
SpecHandler& handler;
|
|
};
|
|
|
|
template <typename Char>
|
|
FMT_CONSTEXPR const Char* next_code_point(const Char* begin, const Char* end) {
|
|
if (sizeof(Char) != 1 || (*begin & 0x80) == 0) return begin + 1;
|
|
do {
|
|
++begin;
|
|
} while (begin != end && (*begin & 0xc0) == 0x80);
|
|
return begin;
|
|
}
|
|
|
|
// Parses fill and alignment.
|
|
template <typename Char, typename Handler>
|
|
FMT_CONSTEXPR const Char* parse_align(const Char* begin, const Char* end,
|
|
Handler&& handler) {
|
|
FMT_ASSERT(begin != end, "");
|
|
auto align = align::none;
|
|
auto p = next_code_point(begin, end);
|
|
if (p == end) p = begin;
|
|
for (;;) {
|
|
switch (static_cast<char>(*p)) {
|
|
case '<':
|
|
align = align::left;
|
|
break;
|
|
case '>':
|
|
align = align::right;
|
|
break;
|
|
#if FMT_NUMERIC_ALIGN
|
|
case '=':
|
|
align = align::numeric;
|
|
break;
|
|
#endif
|
|
case '^':
|
|
align = align::center;
|
|
break;
|
|
}
|
|
if (align != align::none) {
|
|
if (p != begin) {
|
|
auto c = *begin;
|
|
if (c == '{')
|
|
return handler.on_error("invalid fill character '{'"), begin;
|
|
handler.on_fill(basic_string_view<Char>(begin, p - begin));
|
|
begin = p + 1;
|
|
} else
|
|
++begin;
|
|
handler.on_align(align);
|
|
break;
|
|
} else if (p == begin) {
|
|
break;
|
|
}
|
|
p = begin;
|
|
}
|
|
return begin;
|
|
}
|
|
|
|
template <typename Char, typename Handler>
|
|
FMT_CONSTEXPR const Char* parse_width(const Char* begin, const Char* end,
|
|
Handler&& handler) {
|
|
FMT_ASSERT(begin != end, "");
|
|
if ('0' <= *begin && *begin <= '9') {
|
|
handler.on_width(parse_nonnegative_int(begin, end, handler));
|
|
} else if (*begin == '{') {
|
|
++begin;
|
|
if (begin != end)
|
|
begin = parse_arg_id(begin, end, width_adapter<Handler, Char>(handler));
|
|
if (begin == end || *begin != '}')
|
|
return handler.on_error("invalid format string"), begin;
|
|
++begin;
|
|
}
|
|
return begin;
|
|
}
|
|
|
|
template <typename Char, typename Handler>
|
|
FMT_CONSTEXPR const Char* parse_precision(const Char* begin, const Char* end,
|
|
Handler&& handler) {
|
|
++begin;
|
|
auto c = begin != end ? *begin : Char();
|
|
if ('0' <= c && c <= '9') {
|
|
handler.on_precision(parse_nonnegative_int(begin, end, handler));
|
|
} else if (c == '{') {
|
|
++begin;
|
|
if (begin != end) {
|
|
begin =
|
|
parse_arg_id(begin, end, precision_adapter<Handler, Char>(handler));
|
|
}
|
|
if (begin == end || *begin++ != '}')
|
|
return handler.on_error("invalid format string"), begin;
|
|
} else {
|
|
return handler.on_error("missing precision specifier"), begin;
|
|
}
|
|
handler.end_precision();
|
|
return begin;
|
|
}
|
|
|
|
// Parses standard format specifiers and sends notifications about parsed
|
|
// components to handler.
|
|
template <typename Char, typename SpecHandler>
|
|
FMT_CONSTEXPR const Char* parse_format_specs(const Char* begin, const Char* end,
|
|
SpecHandler&& handler) {
|
|
if (begin == end || *begin == '}') return begin;
|
|
|
|
begin = parse_align(begin, end, handler);
|
|
if (begin == end) return begin;
|
|
|
|
// Parse sign.
|
|
switch (static_cast<char>(*begin)) {
|
|
case '+':
|
|
handler.on_plus();
|
|
++begin;
|
|
break;
|
|
case '-':
|
|
handler.on_minus();
|
|
++begin;
|
|
break;
|
|
case ' ':
|
|
handler.on_space();
|
|
++begin;
|
|
break;
|
|
}
|
|
if (begin == end) return begin;
|
|
|
|
if (*begin == '#') {
|
|
handler.on_hash();
|
|
if (++begin == end) return begin;
|
|
}
|
|
|
|
// Parse zero flag.
|
|
if (*begin == '0') {
|
|
handler.on_zero();
|
|
if (++begin == end) return begin;
|
|
}
|
|
|
|
begin = parse_width(begin, end, handler);
|
|
if (begin == end) return begin;
|
|
|
|
// Parse precision.
|
|
if (*begin == '.') {
|
|
begin = parse_precision(begin, end, handler);
|
|
}
|
|
|
|
// Parse type.
|
|
if (begin != end && *begin != '}') handler.on_type(*begin++);
|
|
return begin;
|
|
}
|
|
|
|
// Return the result via the out param to workaround gcc bug 77539.
|
|
template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
|
|
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr& out) {
|
|
for (out = first; out != last; ++out) {
|
|
if (*out == value) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template <>
|
|
inline bool find<false, char>(const char* first, const char* last, char value,
|
|
const char*& out) {
|
|
out = static_cast<const char*>(
|
|
std::memchr(first, value, internal::to_unsigned(last - first)));
|
|
return out != nullptr;
|
|
}
|
|
|
|
template <typename Handler, typename Char> struct id_adapter {
|
|
FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
|
|
FMT_CONSTEXPR void operator()(int id) { handler.on_arg_id(id); }
|
|
FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
|
|
handler.on_arg_id(id);
|
|
}
|
|
FMT_CONSTEXPR void on_error(const char* message) {
|
|
handler.on_error(message);
|
|
}
|
|
Handler& handler;
|
|
};
|
|
|
|
template <bool IS_CONSTEXPR, typename Char, typename Handler>
|
|
FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> format_str,
|
|
Handler&& handler) {
|
|
struct pfs_writer {
|
|
FMT_CONSTEXPR void operator()(const Char* begin, const Char* end) {
|
|
if (begin == end) return;
|
|
for (;;) {
|
|
const Char* p = nullptr;
|
|
if (!find<IS_CONSTEXPR>(begin, end, '}', p))
|
|
return handler_.on_text(begin, end);
|
|
++p;
|
|
if (p == end || *p != '}')
|
|
return handler_.on_error("unmatched '}' in format string");
|
|
handler_.on_text(begin, p);
|
|
begin = p + 1;
|
|
}
|
|
}
|
|
Handler& handler_;
|
|
} write{handler};
|
|
auto begin = format_str.data();
|
|
auto end = begin + format_str.size();
|
|
while (begin != end) {
|
|
// Doing two passes with memchr (one for '{' and another for '}') is up to
|
|
// 2.5x faster than the naive one-pass implementation on big format strings.
|
|
const Char* p = begin;
|
|
if (*begin != '{' && !find<IS_CONSTEXPR>(begin, end, '{', p))
|
|
return write(begin, end);
|
|
write(begin, p);
|
|
++p;
|
|
if (p == end) return handler.on_error("invalid format string");
|
|
if (static_cast<char>(*p) == '}') {
|
|
handler.on_arg_id();
|
|
handler.on_replacement_field(p);
|
|
} else if (*p == '{') {
|
|
handler.on_text(p, p + 1);
|
|
} else {
|
|
p = parse_arg_id(p, end, id_adapter<Handler, Char>{handler});
|
|
Char c = p != end ? *p : Char();
|
|
if (c == '}') {
|
|
handler.on_replacement_field(p);
|
|
} else if (c == ':') {
|
|
p = handler.on_format_specs(p + 1, end);
|
|
if (p == end || *p != '}')
|
|
return handler.on_error("unknown format specifier");
|
|
} else {
|
|
return handler.on_error("missing '}' in format string");
|
|
}
|
|
}
|
|
begin = p + 1;
|
|
}
|
|
}
|
|
|
|
template <typename T, typename ParseContext>
|
|
FMT_CONSTEXPR const typename ParseContext::char_type* parse_format_specs(
|
|
ParseContext& ctx) {
|
|
using char_type = typename ParseContext::char_type;
|
|
using context = buffer_context<char_type>;
|
|
using mapped_type =
|
|
conditional_t<internal::mapped_type_constant<T, context>::value !=
|
|
type::custom_type,
|
|
decltype(arg_mapper<context>().map(std::declval<T>())), T>;
|
|
auto f = conditional_t<has_formatter<mapped_type, context>::value,
|
|
formatter<mapped_type, char_type>,
|
|
internal::fallback_formatter<T, char_type>>();
|
|
return f.parse(ctx);
|
|
}
|
|
|
|
template <typename Char, typename ErrorHandler, typename... Args>
|
|
class format_string_checker {
|
|
public:
|
|
explicit FMT_CONSTEXPR format_string_checker(
|
|
basic_string_view<Char> format_str, ErrorHandler eh)
|
|
: arg_id_(-1),
|
|
context_(format_str, eh),
|
|
parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
|
|
|
|
FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
|
|
|
|
FMT_CONSTEXPR void on_arg_id() {
|
|
arg_id_ = context_.next_arg_id();
|
|
check_arg_id();
|
|
}
|
|
FMT_CONSTEXPR void on_arg_id(int id) {
|
|
arg_id_ = id;
|
|
context_.check_arg_id(id);
|
|
check_arg_id();
|
|
}
|
|
FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {
|
|
on_error("compile-time checks don't support named arguments");
|
|
}
|
|
|
|
FMT_CONSTEXPR void on_replacement_field(const Char*) {}
|
|
|
|
FMT_CONSTEXPR const Char* on_format_specs(const Char* begin, const Char*) {
|
|
advance_to(context_, begin);
|
|
return arg_id_ < num_args ? parse_funcs_[arg_id_](context_) : begin;
|
|
}
|
|
|
|
FMT_CONSTEXPR void on_error(const char* message) {
|
|
context_.on_error(message);
|
|
}
|
|
|
|
private:
|
|
using parse_context_type = basic_format_parse_context<Char, ErrorHandler>;
|
|
enum { num_args = sizeof...(Args) };
|
|
|
|
FMT_CONSTEXPR void check_arg_id() {
|
|
if (arg_id_ >= num_args) context_.on_error("argument index out of range");
|
|
}
|
|
|
|
// Format specifier parsing function.
|
|
using parse_func = const Char* (*)(parse_context_type&);
|
|
|
|
int arg_id_;
|
|
parse_context_type context_;
|
|
parse_func parse_funcs_[num_args > 0 ? num_args : 1];
|
|
};
|
|
|
|
template <typename Char, typename ErrorHandler, typename... Args>
|
|
FMT_CONSTEXPR bool do_check_format_string(basic_string_view<Char> s,
|
|
ErrorHandler eh = ErrorHandler()) {
|
|
format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
|
|
parse_format_string<true>(s, checker);
|
|
return true;
|
|
}
|
|
|
|
template <typename... Args, typename S,
|
|
enable_if_t<(is_compile_string<S>::value), int>>
|
|
void check_format_string(S format_str) {
|
|
FMT_CONSTEXPR_DECL bool invalid_format =
|
|
internal::do_check_format_string<typename S::char_type,
|
|
internal::error_handler, Args...>(
|
|
to_string_view(format_str));
|
|
(void)invalid_format;
|
|
}
|
|
|
|
template <template <typename> class Handler, typename Context>
|
|
void handle_dynamic_spec(int& value, arg_ref<typename Context::char_type> ref,
|
|
Context& ctx) {
|
|
switch (ref.kind) {
|
|
case arg_id_kind::none:
|
|
break;
|
|
case arg_id_kind::index:
|
|
value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.index),
|
|
ctx.error_handler());
|
|
break;
|
|
case arg_id_kind::name:
|
|
value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.name),
|
|
ctx.error_handler());
|
|
break;
|
|
}
|
|
}
|
|
|
|
using format_func = void (*)(internal::buffer<char>&, int, string_view);
|
|
|
|
FMT_API void format_error_code(buffer<char>& out, int error_code,
|
|
string_view message) FMT_NOEXCEPT;
|
|
|
|
FMT_API void report_error(format_func func, int error_code,
|
|
string_view message) FMT_NOEXCEPT;
|
|
} // namespace internal
|
|
|
|
template <typename Range>
|
|
using basic_writer FMT_DEPRECATED_ALIAS = internal::basic_writer<Range>;
|
|
using writer FMT_DEPRECATED_ALIAS = internal::writer;
|
|
using wwriter FMT_DEPRECATED_ALIAS =
|
|
internal::basic_writer<buffer_range<wchar_t>>;
|
|
|
|
/** The default argument formatter. */
|
|
template <typename Range>
|
|
class arg_formatter : public internal::arg_formatter_base<Range> {
|
|
private:
|
|
using char_type = typename Range::value_type;
|
|
using base = internal::arg_formatter_base<Range>;
|
|
using context_type = basic_format_context<typename base::iterator, char_type>;
|
|
|
|
context_type& ctx_;
|
|
basic_format_parse_context<char_type>* parse_ctx_;
|
|
|
|
public:
|
|
using range = Range;
|
|
using iterator = typename base::iterator;
|
|
using format_specs = typename base::format_specs;
|
|
|
|
/**
|
|
\rst
|
|
Constructs an argument formatter object.
|
|
*ctx* is a reference to the formatting context,
|
|
*specs* contains format specifier information for standard argument types.
|
|
\endrst
|
|
*/
|
|
explicit arg_formatter(
|
|
context_type& ctx,
|
|
basic_format_parse_context<char_type>* parse_ctx = nullptr,
|
|
format_specs* specs = nullptr)
|
|
: base(Range(ctx.out()), specs, ctx.locale()),
|
|
ctx_(ctx),
|
|
parse_ctx_(parse_ctx) {}
|
|
|
|
using base::operator();
|
|
|
|
/** Formats an argument of a user-defined type. */
|
|
iterator operator()(typename basic_format_arg<context_type>::handle handle) {
|
|
handle.format(*parse_ctx_, ctx_);
|
|
return ctx_.out();
|
|
}
|
|
};
|
|
|
|
/**
|
|
An error returned by an operating system or a language runtime,
|
|
for example a file opening error.
|
|
*/
|
|
FMT_CLASS_API
|
|
class FMT_API system_error : public std::runtime_error {
|
|
private:
|
|
void init(int err_code, string_view format_str, format_args args);
|
|
|
|
protected:
|
|
int error_code_;
|
|
|
|
system_error() : std::runtime_error(""), error_code_(0) {}
|
|
|
|
public:
|
|
/**
|
|
\rst
|
|
Constructs a :class:`fmt::system_error` object with a description
|
|
formatted with `fmt::format_system_error`. *message* and additional
|
|
arguments passed into the constructor are formatted similarly to
|
|
`fmt::format`.
|
|
|
|
**Example**::
|
|
|
|
// This throws a system_error with the description
|
|
// cannot open file 'madeup': No such file or directory
|
|
// or similar (system message may vary).
|
|
const char *filename = "madeup";
|
|
std::FILE *file = std::fopen(filename, "r");
|
|
if (!file)
|
|
throw fmt::system_error(errno, "cannot open file '{}'", filename);
|
|
\endrst
|
|
*/
|
|
template <typename... Args>
|
|
system_error(int error_code, string_view message, const Args&... args)
|
|
: std::runtime_error("") {
|
|
init(error_code, message, make_format_args(args...));
|
|
}
|
|
system_error(const system_error&) = default;
|
|
system_error& operator=(const system_error&) = default;
|
|
system_error(system_error&&) = default;
|
|
system_error& operator=(system_error&&) = default;
|
|
~system_error() FMT_NOEXCEPT FMT_OVERRIDE;
|
|
|
|
int error_code() const { return error_code_; }
|
|
};
|
|
|
|
/**
|
|
\rst
|
|
Formats an error returned by an operating system or a language runtime,
|
|
for example a file opening error, and writes it to *out* in the following
|
|
form:
|
|
|
|
.. parsed-literal::
|
|
*<message>*: *<system-message>*
|
|
|
|
where *<message>* is the passed message and *<system-message>* is
|
|
the system message corresponding to the error code.
|
|
*error_code* is a system error code as given by ``errno``.
|
|
If *error_code* is not a valid error code such as -1, the system message
|
|
may look like "Unknown error -1" and is platform-dependent.
|
|
\endrst
|
|
*/
|
|
FMT_API void format_system_error(internal::buffer<char>& out, int error_code,
|
|
string_view message) FMT_NOEXCEPT;
|
|
|
|
// Reports a system error without throwing an exception.
|
|
// Can be used to report errors from destructors.
|
|
FMT_API void report_system_error(int error_code,
|
|
string_view message) FMT_NOEXCEPT;
|
|
|
|
/** Fast integer formatter. */
|
|
class format_int {
|
|
private:
|
|
// Buffer should be large enough to hold all digits (digits10 + 1),
|
|
// a sign and a null character.
|
|
enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
|
|
mutable char buffer_[buffer_size];
|
|
char* str_;
|
|
|
|
// Formats value in reverse and returns a pointer to the beginning.
|
|
char* format_decimal(unsigned long long value) {
|
|
char* ptr = buffer_ + (buffer_size - 1); // Parens to workaround MSVC bug.
|
|
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;
|
|
*--ptr = internal::data::digits[index + 1];
|
|
*--ptr = internal::data::digits[index];
|
|
}
|
|
if (value < 10) {
|
|
*--ptr = static_cast<char>('0' + value);
|
|
return ptr;
|
|
}
|
|
auto index = static_cast<unsigned>(value * 2);
|
|
*--ptr = internal::data::digits[index + 1];
|
|
*--ptr = internal::data::digits[index];
|
|
return ptr;
|
|
}
|
|
|
|
void format_signed(long long value) {
|
|
auto abs_value = static_cast<unsigned long long>(value);
|
|
bool negative = value < 0;
|
|
if (negative) abs_value = 0 - abs_value;
|
|
str_ = format_decimal(abs_value);
|
|
if (negative) *--str_ = '-';
|
|
}
|
|
|
|
public:
|
|
explicit format_int(int value) { format_signed(value); }
|
|
explicit format_int(long value) { format_signed(value); }
|
|
explicit format_int(long long value) { format_signed(value); }
|
|
explicit format_int(unsigned value) : str_(format_decimal(value)) {}
|
|
explicit format_int(unsigned long value) : str_(format_decimal(value)) {}
|
|
explicit format_int(unsigned long long value) : str_(format_decimal(value)) {}
|
|
|
|
/** Returns the number of characters written to the output buffer. */
|
|
std::size_t size() const {
|
|
return internal::to_unsigned(buffer_ - str_ + buffer_size - 1);
|
|
}
|
|
|
|
/**
|
|
Returns a pointer to the output buffer content. No terminating null
|
|
character is appended.
|
|
*/
|
|
const char* data() const { return str_; }
|
|
|
|
/**
|
|
Returns a pointer to the output buffer content with terminating null
|
|
character appended.
|
|
*/
|
|
const char* c_str() const {
|
|
buffer_[buffer_size - 1] = '\0';
|
|
return str_;
|
|
}
|
|
|
|
/**
|
|
\rst
|
|
Returns the content of the output buffer as an ``std::string``.
|
|
\endrst
|
|
*/
|
|
std::string str() const { return std::string(str_, size()); }
|
|
};
|
|
|
|
// A formatter specialization for the core types corresponding to internal::type
|
|
// constants.
|
|
template <typename T, typename Char>
|
|
struct formatter<T, Char,
|
|
enable_if_t<internal::type_constant<T, Char>::value !=
|
|
internal::type::custom_type>> {
|
|
FMT_CONSTEXPR formatter() = default;
|
|
|
|
// Parses format specifiers stopping either at the end of the range or at the
|
|
// terminating '}'.
|
|
template <typename ParseContext>
|
|
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
|
|
using handler_type = internal::dynamic_specs_handler<ParseContext>;
|
|
auto type = internal::type_constant<T, Char>::value;
|
|
internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
|
|
type);
|
|
auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
|
|
auto eh = ctx.error_handler();
|
|
switch (type) {
|
|
case internal::type::none_type:
|
|
case internal::type::named_arg_type:
|
|
FMT_ASSERT(false, "invalid argument type");
|
|
break;
|
|
case internal::type::int_type:
|
|
case internal::type::uint_type:
|
|
case internal::type::long_long_type:
|
|
case internal::type::ulong_long_type:
|
|
case internal::type::int128_type:
|
|
case internal::type::uint128_type:
|
|
case internal::type::bool_type:
|
|
handle_int_type_spec(specs_.type,
|
|
internal::int_type_checker<decltype(eh)>(eh));
|
|
break;
|
|
case internal::type::char_type:
|
|
handle_char_specs(
|
|
&specs_, internal::char_specs_checker<decltype(eh)>(specs_.type, eh));
|
|
break;
|
|
case internal::type::float_type:
|
|
case internal::type::double_type:
|
|
case internal::type::long_double_type:
|
|
internal::parse_float_type_spec(specs_, eh);
|
|
break;
|
|
case internal::type::cstring_type:
|
|
internal::handle_cstring_type_spec(
|
|
specs_.type, internal::cstring_type_checker<decltype(eh)>(eh));
|
|
break;
|
|
case internal::type::string_type:
|
|
internal::check_string_type_spec(specs_.type, eh);
|
|
break;
|
|
case internal::type::pointer_type:
|
|
internal::check_pointer_type_spec(specs_.type, eh);
|
|
break;
|
|
case internal::type::custom_type:
|
|
// Custom format specifiers should be checked in parse functions of
|
|
// formatter specializations.
|
|
break;
|
|
}
|
|
return it;
|
|
}
|
|
|
|
template <typename FormatContext>
|
|
auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
|
|
internal::handle_dynamic_spec<internal::width_checker>(
|
|
specs_.width, specs_.width_ref, ctx);
|
|
internal::handle_dynamic_spec<internal::precision_checker>(
|
|
specs_.precision, specs_.precision_ref, ctx);
|
|
using range_type =
|
|
internal::output_range<typename FormatContext::iterator,
|
|
typename FormatContext::char_type>;
|
|
return visit_format_arg(arg_formatter<range_type>(ctx, nullptr, &specs_),
|
|
internal::make_arg<FormatContext>(val));
|
|
}
|
|
|
|
private:
|
|
internal::dynamic_format_specs<Char> specs_;
|
|
};
|
|
|
|
#define FMT_FORMAT_AS(Type, Base) \
|
|
template <typename Char> \
|
|
struct formatter<Type, Char> : formatter<Base, Char> { \
|
|
template <typename FormatContext> \
|
|
auto format(const Type& val, FormatContext& ctx) -> decltype(ctx.out()) { \
|
|
return formatter<Base, Char>::format(val, ctx); \
|
|
} \
|
|
}
|
|
|
|
FMT_FORMAT_AS(signed char, int);
|
|
FMT_FORMAT_AS(unsigned char, unsigned);
|
|
FMT_FORMAT_AS(short, int);
|
|
FMT_FORMAT_AS(unsigned short, unsigned);
|
|
FMT_FORMAT_AS(long, long long);
|
|
FMT_FORMAT_AS(unsigned long, unsigned long long);
|
|
FMT_FORMAT_AS(Char*, const Char*);
|
|
FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
|
|
FMT_FORMAT_AS(std::nullptr_t, const void*);
|
|
FMT_FORMAT_AS(internal::std_string_view<Char>, basic_string_view<Char>);
|
|
|
|
template <typename Char>
|
|
struct formatter<void*, Char> : formatter<const void*, Char> {
|
|
template <typename FormatContext>
|
|
auto format(void* val, FormatContext& ctx) -> decltype(ctx.out()) {
|
|
return formatter<const void*, Char>::format(val, ctx);
|
|
}
|
|
};
|
|
|
|
template <typename Char, size_t N>
|
|
struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
|
|
template <typename FormatContext>
|
|
auto format(const Char* val, FormatContext& ctx) -> decltype(ctx.out()) {
|
|
return formatter<basic_string_view<Char>, Char>::format(val, ctx);
|
|
}
|
|
};
|
|
|
|
// A formatter for types known only at run time such as variant alternatives.
|
|
//
|
|
// Usage:
|
|
// using variant = std::variant<int, std::string>;
|
|
// template <>
|
|
// struct formatter<variant>: dynamic_formatter<> {
|
|
// void format(buffer &buf, const variant &v, context &ctx) {
|
|
// visit([&](const auto &val) { format(buf, val, ctx); }, v);
|
|
// }
|
|
// };
|
|
template <typename Char = char> class dynamic_formatter {
|
|
private:
|
|
struct null_handler : internal::error_handler {
|
|
void on_align(align_t) {}
|
|
void on_plus() {}
|
|
void on_minus() {}
|
|
void on_space() {}
|
|
void on_hash() {}
|
|
};
|
|
|
|
public:
|
|
template <typename ParseContext>
|
|
auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
|
|
format_str_ = ctx.begin();
|
|
// Checks are deferred to formatting time when the argument type is known.
|
|
internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
|
|
return parse_format_specs(ctx.begin(), ctx.end(), handler);
|
|
}
|
|
|
|
template <typename T, typename FormatContext>
|
|
auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
|
|
handle_specs(ctx);
|
|
internal::specs_checker<null_handler> checker(
|
|
null_handler(),
|
|
internal::mapped_type_constant<T, FormatContext>::value);
|
|
checker.on_align(specs_.align);
|
|
switch (specs_.sign) {
|
|
case sign::none:
|
|
break;
|
|
case sign::plus:
|
|
checker.on_plus();
|
|
break;
|
|
case sign::minus:
|
|
checker.on_minus();
|
|
break;
|
|
case sign::space:
|
|
checker.on_space();
|
|
break;
|
|
}
|
|
if (specs_.alt) checker.on_hash();
|
|
if (specs_.precision >= 0) checker.end_precision();
|
|
using range = internal::output_range<typename FormatContext::iterator,
|
|
typename FormatContext::char_type>;
|
|
visit_format_arg(arg_formatter<range>(ctx, nullptr, &specs_),
|
|
internal::make_arg<FormatContext>(val));
|
|
return ctx.out();
|
|
}
|
|
|
|
private:
|
|
template <typename Context> void handle_specs(Context& ctx) {
|
|
internal::handle_dynamic_spec<internal::width_checker>(
|
|
specs_.width, specs_.width_ref, ctx);
|
|
internal::handle_dynamic_spec<internal::precision_checker>(
|
|
specs_.precision, specs_.precision_ref, ctx);
|
|
}
|
|
|
|
internal::dynamic_format_specs<Char> specs_;
|
|
const Char* format_str_;
|
|
};
|
|
|
|
template <typename Range, typename Char>
|
|
typename basic_format_context<Range, Char>::format_arg
|
|
basic_format_context<Range, Char>::arg(basic_string_view<char_type> name) {
|
|
map_.init(args_);
|
|
format_arg arg = map_.find(name);
|
|
if (arg.type() == internal::type::none_type)
|
|
this->on_error("argument not found");
|
|
return arg;
|
|
}
|
|
|
|
template <typename Char, typename ErrorHandler>
|
|
FMT_CONSTEXPR void advance_to(
|
|
basic_format_parse_context<Char, ErrorHandler>& ctx, const Char* p) {
|
|
ctx.advance_to(ctx.begin() + (p - &*ctx.begin()));
|
|
}
|
|
|
|
template <typename ArgFormatter, typename Char, typename Context>
|
|
struct format_handler : internal::error_handler {
|
|
using range = typename ArgFormatter::range;
|
|
|
|
format_handler(range r, basic_string_view<Char> str,
|
|
basic_format_args<Context> format_args,
|
|
internal::locale_ref loc)
|
|
: parse_context(str), context(r.begin(), format_args, loc) {}
|
|
|
|
void on_text(const Char* begin, const Char* end) {
|
|
auto size = internal::to_unsigned(end - begin);
|
|
auto out = context.out();
|
|
auto&& it = internal::reserve(out, size);
|
|
it = std::copy_n(begin, size, it);
|
|
context.advance_to(out);
|
|
}
|
|
|
|
void get_arg(int id) { arg = internal::get_arg(context, id); }
|
|
|
|
void on_arg_id() { get_arg(parse_context.next_arg_id()); }
|
|
void on_arg_id(int id) {
|
|
parse_context.check_arg_id(id);
|
|
get_arg(id);
|
|
}
|
|
void on_arg_id(basic_string_view<Char> id) { arg = context.arg(id); }
|
|
|
|
void on_replacement_field(const Char* p) {
|
|
advance_to(parse_context, p);
|
|
context.advance_to(
|
|
visit_format_arg(ArgFormatter(context, &parse_context), arg));
|
|
}
|
|
|
|
const Char* on_format_specs(const Char* begin, const Char* end) {
|
|
advance_to(parse_context, begin);
|
|
internal::custom_formatter<Context> f(parse_context, context);
|
|
if (visit_format_arg(f, arg)) return parse_context.begin();
|
|
basic_format_specs<Char> specs;
|
|
using internal::specs_handler;
|
|
using parse_context_t = basic_format_parse_context<Char>;
|
|
internal::specs_checker<specs_handler<parse_context_t, Context>> handler(
|
|
specs_handler<parse_context_t, Context>(specs, parse_context, context),
|
|
arg.type());
|
|
begin = parse_format_specs(begin, end, handler);
|
|
if (begin == end || *begin != '}') on_error("missing '}' in format string");
|
|
advance_to(parse_context, begin);
|
|
context.advance_to(
|
|
visit_format_arg(ArgFormatter(context, &parse_context, &specs), arg));
|
|
return begin;
|
|
}
|
|
|
|
basic_format_parse_context<Char> parse_context;
|
|
Context context;
|
|
basic_format_arg<Context> arg;
|
|
};
|
|
|
|
/** Formats arguments and writes the output to the range. */
|
|
template <typename ArgFormatter, typename Char, typename Context>
|
|
typename Context::iterator vformat_to(
|
|
typename ArgFormatter::range out, basic_string_view<Char> format_str,
|
|
basic_format_args<Context> args,
|
|
internal::locale_ref loc = internal::locale_ref()) {
|
|
format_handler<ArgFormatter, Char, Context> h(out, format_str, args, loc);
|
|
internal::parse_format_string<false>(format_str, h);
|
|
return h.context.out();
|
|
}
|
|
|
|
// Casts ``p`` to ``const void*`` for pointer formatting.
|
|
// Example:
|
|
// auto s = format("{}", ptr(p));
|
|
template <typename T> inline const void* ptr(const T* p) { return p; }
|
|
template <typename T> inline const void* ptr(const std::unique_ptr<T>& p) {
|
|
return p.get();
|
|
}
|
|
template <typename T> inline const void* ptr(const std::shared_ptr<T>& p) {
|
|
return p.get();
|
|
}
|
|
|
|
class bytes {
|
|
private:
|
|
string_view data_;
|
|
friend struct formatter<bytes>;
|
|
|
|
public:
|
|
explicit bytes(string_view data) : data_(data) {}
|
|
};
|
|
|
|
template <> struct formatter<bytes> : formatter<string_view> {
|
|
template <typename FormatContext>
|
|
auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) {
|
|
return formatter<string_view>::format(b.data_, ctx);
|
|
}
|
|
};
|
|
|
|
template <typename It, typename Char> struct arg_join : internal::view {
|
|
It begin;
|
|
It end;
|
|
basic_string_view<Char> sep;
|
|
|
|
arg_join(It b, It e, basic_string_view<Char> s) : begin(b), end(e), sep(s) {}
|
|
};
|
|
|
|
template <typename It, typename Char>
|
|
struct formatter<arg_join<It, Char>, Char>
|
|
: formatter<typename std::iterator_traits<It>::value_type, Char> {
|
|
template <typename FormatContext>
|
|
auto format(const arg_join<It, Char>& value, FormatContext& ctx)
|
|
-> decltype(ctx.out()) {
|
|
using base = formatter<typename std::iterator_traits<It>::value_type, Char>;
|
|
auto it = value.begin;
|
|
auto out = ctx.out();
|
|
if (it != value.end) {
|
|
out = base::format(*it++, ctx);
|
|
while (it != value.end) {
|
|
out = std::copy(value.sep.begin(), value.sep.end(), out);
|
|
ctx.advance_to(out);
|
|
out = base::format(*it++, ctx);
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
};
|
|
|
|
/**
|
|
Returns an object that formats the iterator range `[begin, end)` with elements
|
|
separated by `sep`.
|
|
*/
|
|
template <typename It>
|
|
arg_join<It, char> join(It begin, It end, string_view sep) {
|
|
return {begin, end, sep};
|
|
}
|
|
|
|
template <typename It>
|
|
arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
|
|
return {begin, end, sep};
|
|
}
|
|
|
|
/**
|
|
\rst
|
|
Returns an object that formats `range` with elements separated by `sep`.
|
|
|
|
**Example**::
|
|
|
|
std::vector<int> v = {1, 2, 3};
|
|
fmt::print("{}", fmt::join(v, ", "));
|
|
// Output: "1, 2, 3"
|
|
|
|
``fmt::join`` applies passed format specifiers to the range elements::
|
|
|
|
fmt::print("{:02}", fmt::join(v, ", "));
|
|
// Output: "01, 02, 03"
|
|
\endrst
|
|
*/
|
|
template <typename Range>
|
|
arg_join<internal::iterator_t<const Range>, char> join(const Range& range,
|
|
string_view sep) {
|
|
return join(std::begin(range), std::end(range), sep);
|
|
}
|
|
|
|
template <typename Range>
|
|
arg_join<internal::iterator_t<const Range>, wchar_t> join(const Range& range,
|
|
wstring_view sep) {
|
|
return join(std::begin(range), std::end(range), sep);
|
|
}
|
|
|
|
/**
|
|
\rst
|
|
Converts *value* to ``std::string`` using the default format for type *T*.
|
|
It doesn't support user-defined types with custom formatters.
|
|
|
|
**Example**::
|
|
|
|
#include <fmt/format.h>
|
|
|
|
std::string answer = fmt::to_string(42);
|
|
\endrst
|
|
*/
|
|
template <typename T> inline std::string to_string(const T& value) {
|
|
return format("{}", value);
|
|
}
|
|
|
|
/**
|
|
Converts *value* to ``std::wstring`` using the default format for type *T*.
|
|
*/
|
|
template <typename T> inline std::wstring to_wstring(const T& value) {
|
|
return format(L"{}", value);
|
|
}
|
|
|
|
template <typename Char, std::size_t SIZE>
|
|
std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE>& buf) {
|
|
return std::basic_string<Char>(buf.data(), buf.size());
|
|
}
|
|
|
|
template <typename Char>
|
|
typename buffer_context<Char>::iterator internal::vformat_to(
|
|
internal::buffer<Char>& buf, basic_string_view<Char> format_str,
|
|
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
|
|
using range = buffer_range<Char>;
|
|
return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str),
|
|
args);
|
|
}
|
|
|
|
template <typename S, typename Char = char_t<S>,
|
|
FMT_ENABLE_IF(internal::is_string<S>::value)>
|
|
inline typename buffer_context<Char>::iterator vformat_to(
|
|
internal::buffer<Char>& buf, const S& format_str,
|
|
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
|
|
return internal::vformat_to(buf, to_string_view(format_str), args);
|
|
}
|
|
|
|
template <typename S, typename... Args, std::size_t SIZE = inline_buffer_size,
|
|
typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
|
|
inline typename buffer_context<Char>::iterator format_to(
|
|
basic_memory_buffer<Char, SIZE>& buf, const S& format_str, Args&&... args) {
|
|
internal::check_format_string<Args...>(format_str);
|
|
using context = buffer_context<Char>;
|
|
return internal::vformat_to(buf, to_string_view(format_str),
|
|
make_format_args<context>(args...));
|
|
}
|
|
|
|
template <typename OutputIt, typename Char = char>
|
|
using format_context_t = basic_format_context<OutputIt, Char>;
|
|
|
|
template <typename OutputIt, typename Char = char>
|
|
using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
|
|
|
|
template <typename S, typename OutputIt, typename... Args,
|
|
FMT_ENABLE_IF(
|
|
internal::is_output_iterator<OutputIt>::value &&
|
|
!internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
|
|
inline OutputIt vformat_to(
|
|
OutputIt out, const S& format_str,
|
|
format_args_t<type_identity_t<OutputIt>, char_t<S>> args) {
|
|
using range = internal::output_range<OutputIt, char_t<S>>;
|
|
return vformat_to<arg_formatter<range>>(range(out),
|
|
to_string_view(format_str), args);
|
|
}
|
|
|
|
/**
|
|
\rst
|
|
Formats arguments, writes the result to the output iterator ``out`` and returns
|
|
the iterator past the end of the output range.
|
|
|
|
**Example**::
|
|
|
|
std::vector<char> out;
|
|
fmt::format_to(std::back_inserter(out), "{}", 42);
|
|
\endrst
|
|
*/
|
|
template <typename OutputIt, typename S, typename... Args,
|
|
FMT_ENABLE_IF(
|
|
internal::is_output_iterator<OutputIt>::value &&
|
|
!internal::is_contiguous_back_insert_iterator<OutputIt>::value &&
|
|
internal::is_string<S>::value)>
|
|
inline OutputIt format_to(OutputIt out, const S& format_str, Args&&... args) {
|
|
internal::check_format_string<Args...>(format_str);
|
|
using context = format_context_t<OutputIt, char_t<S>>;
|
|
return vformat_to(out, to_string_view(format_str),
|
|
make_format_args<context>(args...));
|
|
}
|
|
|
|
template <typename OutputIt> struct format_to_n_result {
|
|
/** Iterator past the end of the output range. */
|
|
OutputIt out;
|
|
/** Total (not truncated) output size. */
|
|
std::size_t size;
|
|
};
|
|
|
|
template <typename OutputIt, typename Char = typename OutputIt::value_type>
|
|
using format_to_n_context =
|
|
format_context_t<internal::truncating_iterator<OutputIt>, Char>;
|
|
|
|
template <typename OutputIt, typename Char = typename OutputIt::value_type>
|
|
using format_to_n_args = basic_format_args<format_to_n_context<OutputIt, Char>>;
|
|
|
|
template <typename OutputIt, typename Char, typename... Args>
|
|
inline format_arg_store<format_to_n_context<OutputIt, Char>, Args...>
|
|
make_format_to_n_args(const Args&... args) {
|
|
return format_arg_store<format_to_n_context<OutputIt, Char>, Args...>(
|
|
args...);
|
|
}
|
|
|
|
template <typename OutputIt, typename Char, typename... Args,
|
|
FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
|
|
inline format_to_n_result<OutputIt> vformat_to_n(
|
|
OutputIt out, std::size_t n, basic_string_view<Char> format_str,
|
|
format_to_n_args<type_identity_t<OutputIt>, type_identity_t<Char>> args) {
|
|
auto it = vformat_to(internal::truncating_iterator<OutputIt>(out, n),
|
|
format_str, args);
|
|
return {it.base(), it.count()};
|
|
}
|
|
|
|
/**
|
|
\rst
|
|
Formats arguments, writes up to ``n`` characters of the result to the output
|
|
iterator ``out`` and returns the total output size and the iterator past the
|
|
end of the output range.
|
|
\endrst
|
|
*/
|
|
template <typename OutputIt, typename S, typename... Args,
|
|
FMT_ENABLE_IF(internal::is_string<S>::value&&
|
|
internal::is_output_iterator<OutputIt>::value)>
|
|
inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n,
|
|
const S& format_str,
|
|
const Args&... args) {
|
|
internal::check_format_string<Args...>(format_str);
|
|
using context = format_to_n_context<OutputIt, char_t<S>>;
|
|
return vformat_to_n(out, n, to_string_view(format_str),
|
|
make_format_args<context>(args...));
|
|
}
|
|
|
|
template <typename Char>
|
|
inline std::basic_string<Char> internal::vformat(
|
|
basic_string_view<Char> format_str,
|
|
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
|
|
basic_memory_buffer<Char> buffer;
|
|
internal::vformat_to(buffer, format_str, args);
|
|
return to_string(buffer);
|
|
}
|
|
|
|
/**
|
|
Returns the number of characters in the output of
|
|
``format(format_str, args...)``.
|
|
*/
|
|
template <typename... Args>
|
|
inline std::size_t formatted_size(string_view format_str, const Args&... args) {
|
|
return format_to(internal::counting_iterator(), format_str, args...).count();
|
|
}
|
|
|
|
template <typename Char, FMT_ENABLE_IF(std::is_same<Char, wchar_t>::value)>
|
|
void vprint(std::FILE* f, basic_string_view<Char> format_str,
|
|
wformat_args args) {
|
|
wmemory_buffer buffer;
|
|
internal::vformat_to(buffer, format_str, args);
|
|
buffer.push_back(L'\0');
|
|
if (std::fputws(buffer.data(), f) == -1)
|
|
FMT_THROW(system_error(errno, "cannot write to file"));
|
|
}
|
|
|
|
template <typename Char, FMT_ENABLE_IF(std::is_same<Char, wchar_t>::value)>
|
|
void vprint(basic_string_view<Char> format_str, wformat_args args) {
|
|
vprint(stdout, format_str, args);
|
|
}
|
|
|
|
#if FMT_USE_USER_DEFINED_LITERALS
|
|
namespace internal {
|
|
|
|
# if FMT_USE_UDL_TEMPLATE
|
|
template <typename Char, Char... CHARS> class udl_formatter {
|
|
public:
|
|
template <typename... Args>
|
|
std::basic_string<Char> operator()(Args&&... args) const {
|
|
FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
|
|
FMT_CONSTEXPR_DECL bool invalid_format =
|
|
do_check_format_string<Char, error_handler, remove_cvref_t<Args>...>(
|
|
basic_string_view<Char>(s, sizeof...(CHARS)));
|
|
(void)invalid_format;
|
|
return format(s, std::forward<Args>(args)...);
|
|
}
|
|
};
|
|
# else
|
|
template <typename Char> struct udl_formatter {
|
|
basic_string_view<Char> str;
|
|
|
|
template <typename... Args>
|
|
std::basic_string<Char> operator()(Args&&... args) const {
|
|
return format(str, std::forward<Args>(args)...);
|
|
}
|
|
};
|
|
# endif // FMT_USE_UDL_TEMPLATE
|
|
|
|
template <typename Char> struct udl_arg {
|
|
basic_string_view<Char> str;
|
|
|
|
template <typename T> named_arg<T, Char> operator=(T&& value) const {
|
|
return {str, std::forward<T>(value)};
|
|
}
|
|
};
|
|
|
|
} // namespace internal
|
|
|
|
inline namespace literals {
|
|
# if FMT_USE_UDL_TEMPLATE
|
|
# pragma GCC diagnostic push
|
|
# if FMT_CLANG_VERSION
|
|
# pragma GCC diagnostic ignored "-Wgnu-string-literal-operator-template"
|
|
# endif
|
|
template <typename Char, Char... CHARS>
|
|
FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
|
|
return {};
|
|
}
|
|
# pragma GCC diagnostic pop
|
|
# else
|
|
/**
|
|
\rst
|
|
User-defined literal equivalent of :func:`fmt::format`.
|
|
|
|
**Example**::
|
|
|
|
using namespace fmt::literals;
|
|
std::string message = "The answer is {}"_format(42);
|
|
\endrst
|
|
*/
|
|
FMT_CONSTEXPR internal::udl_formatter<char> operator"" _format(const char* s,
|
|
std::size_t n) {
|
|
return {{s, n}};
|
|
}
|
|
FMT_CONSTEXPR internal::udl_formatter<wchar_t> operator"" _format(
|
|
const wchar_t* s, std::size_t n) {
|
|
return {{s, n}};
|
|
}
|
|
# endif // FMT_USE_UDL_TEMPLATE
|
|
|
|
/**
|
|
\rst
|
|
User-defined literal equivalent of :func:`fmt::arg`.
|
|
|
|
**Example**::
|
|
|
|
using namespace fmt::literals;
|
|
fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
|
|
\endrst
|
|
*/
|
|
FMT_CONSTEXPR internal::udl_arg<char> operator"" _a(const char* s,
|
|
std::size_t n) {
|
|
return {{s, n}};
|
|
}
|
|
FMT_CONSTEXPR internal::udl_arg<wchar_t> operator"" _a(const wchar_t* s,
|
|
std::size_t n) {
|
|
return {{s, n}};
|
|
}
|
|
} // namespace literals
|
|
#endif // FMT_USE_USER_DEFINED_LITERALS
|
|
FMT_END_NAMESPACE
|
|
|
|
#define FMT_STRING_IMPL(s, ...) \
|
|
[] { \
|
|
/* Use a macro-like name to avoid shadowing warnings. */ \
|
|
struct FMT_STRING : fmt::compile_string { \
|
|
using char_type = fmt::remove_cvref_t<decltype(*s)>; \
|
|
__VA_ARGS__ FMT_CONSTEXPR \
|
|
operator fmt::basic_string_view<char_type>() const { \
|
|
return {s, sizeof(s) / sizeof(char_type) - 1}; \
|
|
} \
|
|
}; \
|
|
return FMT_STRING(); \
|
|
}()
|
|
|
|
/**
|
|
\rst
|
|
Constructs a compile-time format string.
|
|
|
|
**Example**::
|
|
|
|
// A compile-time error because 'd' is an invalid specifier for strings.
|
|
std::string s = format(FMT_STRING("{:d}"), "foo");
|
|
\endrst
|
|
*/
|
|
#define FMT_STRING(s) FMT_STRING_IMPL(s, )
|
|
|
|
#if defined(FMT_STRING_ALIAS) && FMT_STRING_ALIAS
|
|
# define fmt(s) FMT_STRING_IMPL(s, [[deprecated]])
|
|
#endif
|
|
|
|
#ifdef FMT_HEADER_ONLY
|
|
# define FMT_FUNC inline
|
|
# include "format-inl.h"
|
|
#else
|
|
# define FMT_FUNC
|
|
#endif
|
|
|
|
#endif // FMT_FORMAT_H_
|