=== src/third_party/fmt/*.h and src/third_party/format.cpp
-This is a subset of https://fmt.dev[fmt] 10.1.1 with the following license:
+This is a subset of https://fmt.dev[fmt] 10.2.1 with the following license:
----
Formatting library for C++
#include <type_traits>
// The fmt library version in the form major * 10000 + minor * 100 + patch.
-#define FMT_VERSION 100100
+#define FMT_VERSION 100201
#if defined(__clang__) && !defined(__ibmxl__)
# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
# define FMT_CONSTEXPR
#endif
-#if ((FMT_CPLUSPLUS >= 202002L) && \
- (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE > 9)) || \
- (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)
+#if (FMT_CPLUSPLUS >= 202002L || \
+ (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)) && \
+ ((!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 10) && \
+ (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 10000) && \
+ (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1928)) && \
+ defined(__cpp_lib_is_constant_evaluated)
# define FMT_CONSTEXPR20 constexpr
#else
# define FMT_CONSTEXPR20
# define FMT_END_EXPORT
#endif
+#if FMT_GCC_VERSION || FMT_CLANG_VERSION
+# define FMT_VISIBILITY(value) __attribute__((visibility(value)))
+#else
+# define FMT_VISIBILITY(value)
+#endif
+
#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
-# ifdef FMT_LIB_EXPORT
+# if defined(FMT_LIB_EXPORT)
# define FMT_API __declspec(dllexport)
# elif defined(FMT_SHARED)
# define FMT_API __declspec(dllimport)
# endif
-#else
-# if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
-# if defined(__GNUC__) || defined(__clang__)
-# define FMT_API __attribute__((visibility("default")))
-# endif
-# endif
+#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
+# define FMT_API FMT_VISIBILITY("default")
#endif
#ifndef FMT_API
# define FMT_API
__apple_build_version__ >= 14000029L) && \
FMT_CPLUSPLUS >= 202002L) || \
(defined(__cpp_consteval) && \
- (!FMT_MSC_VERSION || _MSC_FULL_VER >= 193030704))
-// consteval is broken in MSVC before VS2022 and Apple clang before 14.
+ (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1929))
+// consteval is broken in MSVC before VS2019 version 16.10 and Apple clang
+// before 14.
# define FMT_CONSTEVAL consteval
# define FMT_HAS_CONSTEVAL
# else
# endif
#endif
+// GCC < 5 requires this-> in decltype
+#ifndef FMT_DECLTYPE_THIS
+# if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
+# define FMT_DECLTYPE_THIS this->
+# else
+# define FMT_DECLTYPE_THIS
+# endif
+#endif
+
// Enable minimal optimizations for more compact code in debug mode.
FMT_GCC_PRAGMA("GCC push_options")
#if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER) && !defined(__LCC__) && \
using remove_const_t = typename std::remove_const<T>::type;
template <typename T>
using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
-template <typename T> struct type_identity { using type = T; };
+template <typename T> struct type_identity {
+ using type = T;
+};
template <typename T> using type_identity_t = typename type_identity<T>::type;
template <typename T>
using underlying_t = typename std::underlying_type<T>::type;
size_ -= n;
}
- FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(
- basic_string_view<Char> sv) const noexcept {
+ FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(
+ basic_string_view<Char> sv) const noexcept -> bool {
return size_ >= sv.size_ &&
std::char_traits<Char>::compare(data_, sv.data_, sv.size_) == 0;
}
- FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(Char c) const noexcept {
+ FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(Char c) const noexcept -> bool {
return size_ >= 1 && std::char_traits<Char>::eq(*data_, c);
}
- FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(const Char* s) const {
+ FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(const Char* s) const -> bool {
return starts_with(basic_string_view<Char>(s));
}
FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
FMT_TYPE_CONSTANT(const void*, pointer_type);
-constexpr bool is_integral_type(type t) {
+constexpr auto is_integral_type(type t) -> bool {
return t > type::none_type && t <= type::last_integer_type;
}
-constexpr bool is_arithmetic_type(type t) {
+constexpr auto is_arithmetic_type(type t) -> bool {
return t > type::none_type && t <= type::last_numeric_type;
}
pointer_set = set(type::pointer_type)
};
+// DEPRECATED!
FMT_NORETURN FMT_API void throw_format_error(const char* message);
struct error_handler {
protected:
// Don't initialize ptr_ since it is not accessed to save a few cycles.
FMT_MSC_WARNING(suppress : 26495)
- buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {}
+ FMT_CONSTEXPR buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {}
FMT_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept
: ptr_(p), size_(sz), capacity_(cap) {}
}
/** Increases the buffer capacity to hold at least *capacity* elements. */
+ // DEPRECATED!
virtual FMT_CONSTEXPR20 void grow(size_t capacity) = 0;
public:
parse_ctx.advance_to(f.parse(parse_ctx));
using qualified_type =
conditional_t<has_const_formatter<T, Context>(), const T, T>;
+ // Calling format through a mutable reference is deprecated.
ctx.advance_to(f.format(*static_cast<qualified_type*>(arg), ctx));
}
};
template <typename T> struct format_as_result {
template <typename U,
FMT_ENABLE_IF(std::is_enum<U>::value || std::is_class<U>::value)>
- static auto map(U*) -> decltype(format_as(std::declval<U>()));
+ static auto map(U*) -> remove_cvref_t<decltype(format_as(std::declval<U>()))>;
static auto map(...) -> void;
using type = decltype(map(static_cast<T*>(nullptr)));
// Only map owning types because mapping views can be unsafe.
template <typename T, typename U = format_as_t<T>,
FMT_ENABLE_IF(std::is_arithmetic<U>::value)>
- FMT_CONSTEXPR FMT_INLINE auto map(const T& val) -> decltype(this->map(U())) {
+ FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
+ -> decltype(FMT_DECLTYPE_THIS map(U())) {
return map(format_as(val));
}
!is_string<U>::value && !is_char<U>::value &&
!is_named_arg<U>::value &&
!std::is_arithmetic<format_as_t<U>>::value)>
- FMT_CONSTEXPR FMT_INLINE auto map(T& val) -> decltype(this->do_map(val)) {
+ FMT_CONSTEXPR FMT_INLINE auto map(T& val)
+ -> decltype(FMT_DECLTYPE_THIS do_map(val)) {
return do_map(val);
}
template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg)
- -> decltype(this->map(named_arg.value)) {
+ -> decltype(FMT_DECLTYPE_THIS map(named_arg.value)) {
return map(named_arg.value);
}
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
-template <typename...> struct void_t_impl { using type = void; };
+template <typename...> struct void_t_impl {
+ using type = void;
+};
template <typename... T> using void_t = typename void_t_impl<T...>::type;
#else
template <typename...> using void_t = void;
} // namespace detail
FMT_BEGIN_EXPORT
-// A formatting argument. It is a trivially copyable/constructible type to
-// allow storage in basic_memory_buffer.
+// A formatting argument. Context is a template parameter for the compiled API
+// where output can be unbuffered.
template <typename Context> class basic_format_arg {
private:
detail::value<Context> value_;
auto is_arithmetic() const -> bool {
return detail::is_arithmetic_type(type_);
}
+
+ FMT_INLINE auto format_custom(const char_type* parse_begin,
+ typename Context::parse_context_type& parse_ctx,
+ Context& ctx) -> bool {
+ if (type_ != detail::type::custom_type) return false;
+ parse_ctx.advance_to(parse_begin);
+ value_.custom.format(value_.custom.value, parse_ctx, ctx);
+ return true;
+ }
};
/**
}
auto args() const -> const format_args& { return args_; }
+ // DEPRECATED!
FMT_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; }
void on_error(const char* message) { error_handler().on_error(message); }
dynamic_format_specs<Char>& specs;
type arg_type;
- FMT_CONSTEXPR auto operator()(pres type, int set) -> const Char* {
- if (!in(arg_type, set)) throw_format_error("invalid format specifier");
- specs.type = type;
+ FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
+ if (!in(arg_type, set)) {
+ if (arg_type == type::none_type) return begin;
+ throw_format_error("invalid format specifier");
+ }
+ specs.type = pres_type;
return begin + 1;
}
} parse_presentation_type{begin, specs, arg_type};
case '+':
case '-':
case ' ':
+ if (arg_type == type::none_type) return begin;
enter_state(state::sign, in(arg_type, sint_set | float_set));
switch (c) {
case '+':
++begin;
break;
case '#':
+ if (arg_type == type::none_type) return begin;
enter_state(state::hash, is_arithmetic_type(arg_type));
specs.alt = true;
++begin;
break;
case '0':
enter_state(state::zero);
- if (!is_arithmetic_type(arg_type))
+ if (!is_arithmetic_type(arg_type)) {
+ if (arg_type == type::none_type) return begin;
throw_format_error("format specifier requires numeric argument");
+ }
if (specs.align == align::none) {
// Ignore 0 if align is specified for compatibility with std::format.
specs.align = align::numeric;
begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx);
break;
case '.':
+ if (arg_type == type::none_type) return begin;
enter_state(state::precision,
in(arg_type, float_set | string_set | cstring_set));
begin = parse_precision(begin, end, specs.precision, specs.precision_ref,
ctx);
break;
case 'L':
+ if (arg_type == type::none_type) return begin;
enter_state(state::locale, is_arithmetic_type(arg_type));
specs.localized = true;
++begin;
case 'G':
return parse_presentation_type(pres::general_upper, float_set);
case 'c':
+ if (arg_type == type::bool_type)
+ throw_format_error("invalid format specifier");
return parse_presentation_type(pres::chr, integral_set);
case 's':
return parse_presentation_type(pres::string,
decltype(arg_mapper<context>().map(std::declval<const T&>())),
typename strip_named_arg<T>::type>;
#if defined(__cpp_if_constexpr)
- if constexpr (std::is_default_constructible_v<
- formatter<mapped_type, char_type>>) {
+ if constexpr (std::is_default_constructible<
+ formatter<mapped_type, char_type>>::value) {
return formatter<mapped_type, char_type>().parse(ctx);
} else {
type_is_unformattable_for<T, char_type> _;
using type = basic_format_args<
basic_format_context<std::back_insert_iterator<buffer<Char>>, Char>>;
};
-template <> struct vformat_args<char> { using type = format_args; };
+template <> struct vformat_args<char> {
+ using type = format_args;
+};
// Use vformat_args and avoid type_identity to keep symbols short.
template <typename Char>
# include <locale>
#endif
-#ifdef _WIN32
+#if defined(_WIN32) && !defined(FMT_WINDOWS_NO_WCHAR)
# include <io.h> // _isatty
#endif
error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
auto it = buffer_appender<char>(out);
if (message.size() <= inline_buffer_size - error_code_size)
- format_to(it, FMT_STRING("{}{}"), message, SEP);
- format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
+ fmt::format_to(it, FMT_STRING("{}{}"), message, SEP);
+ fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
FMT_ASSERT(out.size() <= inline_buffer_size, "");
}
}
// A wrapper around fwrite that throws on error.
-inline void fwrite_fully(const void* ptr, size_t size, size_t count,
- FILE* stream) {
- size_t written = std::fwrite(ptr, size, count, stream);
+inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) {
+ size_t written = std::fwrite(ptr, 1, count, stream);
if (written < count)
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
}
static_assert(std::is_same<Locale, std::locale>::value, "");
}
-template <typename Locale> Locale locale_ref::get() const {
+template <typename Locale> auto locale_ref::get() const -> Locale {
static_assert(std::is_same<Locale, std::locale>::value, "");
return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
}
auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
return {std::move(grouping), thousands_sep};
}
-template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
+template <typename Char>
+FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char {
return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
.decimal_point();
}
}
#endif
-FMT_FUNC std::system_error vsystem_error(int error_code, string_view fmt,
- format_args args) {
+FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args)
+ -> std::system_error {
auto ec = std::error_code(error_code, std::generic_category());
return std::system_error(ec, vformat(fmt, args));
}
namespace detail {
-template <typename F> inline bool operator==(basic_fp<F> x, basic_fp<F> y) {
+template <typename F>
+inline auto operator==(basic_fp<F> x, basic_fp<F> y) -> bool {
return x.f == y.f && x.e == y.e;
}
// Compilers should be able to optimize this into the ror instruction.
-FMT_CONSTEXPR inline uint32_t rotr(uint32_t n, uint32_t r) noexcept {
+FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t {
r &= 31;
return (n >> r) | (n << (32 - r));
}
-FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept {
+FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t {
r &= 63;
return (n >> r) | (n << (64 - r));
}
namespace dragonbox {
// Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
// 64-bit unsigned integer.
-inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept {
+inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t {
return umul128_upper64(static_cast<uint64_t>(x) << 32, y);
}
// Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a
// 128-bit unsigned integer.
-inline uint128_fallback umul192_lower128(uint64_t x,
- uint128_fallback y) noexcept {
+inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept
+ -> uint128_fallback {
uint64_t high = x * y.high();
uint128_fallback high_low = umul128(x, y.low());
return {high + high_low.high(), high_low.low()};
// Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
// 64-bit unsigned integer.
-inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept {
+inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t {
return x * y;
}
// Various fast log computations.
-inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept {
+inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int {
FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
return (e * 631305 - 261663) >> 21;
}
// divisible by pow(10, N).
// Precondition: n <= pow(10, N + 1).
template <int N>
-bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept {
+auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool {
// The numbers below are chosen such that:
// 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,
// 2. nm mod 2^k < m if and only if n is divisible by d,
// Computes floor(n / pow(10, N)) for small n and N.
// Precondition: n <= pow(10, N + 1).
-template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept {
+template <int N> auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t {
constexpr auto info = div_small_pow10_infos[N - 1];
FMT_ASSERT(n <= info.divisor * 10, "n is too large");
constexpr uint32_t magic_number =
}
// Computes floor(n / 10^(kappa + 1)) (float)
-inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept {
+inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t {
// 1374389535 = ceil(2^37/100)
return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37);
}
// Computes floor(n / 10^(kappa + 1)) (double)
-inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept {
+inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t {
// 2361183241434822607 = ceil(2^(64+7)/1000)
return umul128_upper64(n, 2361183241434822607ull) >> 7;
}
using carrier_uint = float_info<float>::carrier_uint;
using cache_entry_type = uint64_t;
- static uint64_t get_cached_power(int k) noexcept {
+ static auto get_cached_power(int k) noexcept -> uint64_t {
FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
"k is out of range");
static constexpr const uint64_t pow10_significands[] = {
bool is_integer;
};
- static compute_mul_result compute_mul(
- carrier_uint u, const cache_entry_type& cache) noexcept {
+ static auto compute_mul(carrier_uint u,
+ const cache_entry_type& cache) noexcept
+ -> compute_mul_result {
auto r = umul96_upper64(u, cache);
return {static_cast<carrier_uint>(r >> 32),
static_cast<carrier_uint>(r) == 0};
}
- static uint32_t compute_delta(const cache_entry_type& cache,
- int beta) noexcept {
+ static auto compute_delta(const cache_entry_type& cache, int beta) noexcept
+ -> uint32_t {
return static_cast<uint32_t>(cache >> (64 - 1 - beta));
}
- static compute_mul_parity_result compute_mul_parity(
- carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
+ static auto compute_mul_parity(carrier_uint two_f,
+ const cache_entry_type& cache,
+ int beta) noexcept
+ -> compute_mul_parity_result {
FMT_ASSERT(beta >= 1, "");
FMT_ASSERT(beta < 64, "");
static_cast<uint32_t>(r >> (32 - beta)) == 0};
}
- static carrier_uint compute_left_endpoint_for_shorter_interval_case(
- const cache_entry_type& cache, int beta) noexcept {
+ static auto compute_left_endpoint_for_shorter_interval_case(
+ const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return static_cast<carrier_uint>(
(cache - (cache >> (num_significand_bits<float>() + 2))) >>
(64 - num_significand_bits<float>() - 1 - beta));
}
- static carrier_uint compute_right_endpoint_for_shorter_interval_case(
- const cache_entry_type& cache, int beta) noexcept {
+ static auto compute_right_endpoint_for_shorter_interval_case(
+ const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return static_cast<carrier_uint>(
(cache + (cache >> (num_significand_bits<float>() + 1))) >>
(64 - num_significand_bits<float>() - 1 - beta));
}
- static carrier_uint compute_round_up_for_shorter_interval_case(
- const cache_entry_type& cache, int beta) noexcept {
+ static auto compute_round_up_for_shorter_interval_case(
+ const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return (static_cast<carrier_uint>(
cache >> (64 - num_significand_bits<float>() - 2 - beta)) +
1) /
using carrier_uint = float_info<double>::carrier_uint;
using cache_entry_type = uint128_fallback;
- static uint128_fallback get_cached_power(int k) noexcept {
+ static auto get_cached_power(int k) noexcept -> uint128_fallback {
FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
"k is out of range");
{0xe0accfa875af45a7, 0x93eb1b80a33b8606},
{0x8c6c01c9498d8b88, 0xbc72f130660533c4},
{0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
- { 0xdb68c2ca82ed2a05,
- 0xa67398db9f6820e2 }
+ {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2},
#else
{0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
{0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
bool is_integer;
};
- static compute_mul_result compute_mul(
- carrier_uint u, const cache_entry_type& cache) noexcept {
+ static auto compute_mul(carrier_uint u,
+ const cache_entry_type& cache) noexcept
+ -> compute_mul_result {
auto r = umul192_upper128(u, cache);
return {r.high(), r.low() == 0};
}
- static uint32_t compute_delta(cache_entry_type const& cache,
- int beta) noexcept {
+ static auto compute_delta(cache_entry_type const& cache, int beta) noexcept
+ -> uint32_t {
return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
}
- static compute_mul_parity_result compute_mul_parity(
- carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
+ static auto compute_mul_parity(carrier_uint two_f,
+ const cache_entry_type& cache,
+ int beta) noexcept
+ -> compute_mul_parity_result {
FMT_ASSERT(beta >= 1, "");
FMT_ASSERT(beta < 64, "");
((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
}
- static carrier_uint compute_left_endpoint_for_shorter_interval_case(
- const cache_entry_type& cache, int beta) noexcept {
+ static auto compute_left_endpoint_for_shorter_interval_case(
+ const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return (cache.high() -
(cache.high() >> (num_significand_bits<double>() + 2))) >>
(64 - num_significand_bits<double>() - 1 - beta);
}
- static carrier_uint compute_right_endpoint_for_shorter_interval_case(
- const cache_entry_type& cache, int beta) noexcept {
+ static auto compute_right_endpoint_for_shorter_interval_case(
+ const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return (cache.high() +
(cache.high() >> (num_significand_bits<double>() + 1))) >>
(64 - num_significand_bits<double>() - 1 - beta);
}
- static carrier_uint compute_round_up_for_shorter_interval_case(
- const cache_entry_type& cache, int beta) noexcept {
+ static auto compute_round_up_for_shorter_interval_case(
+ const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) +
1) /
2;
}
};
-FMT_FUNC uint128_fallback get_cached_power(int k) noexcept {
+FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback {
return cache_accessor<double>::get_cached_power(k);
}
// Various integer checks
template <typename T>
-bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
+auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool {
const int case_shorter_interval_left_endpoint_lower_threshold = 2;
const int case_shorter_interval_left_endpoint_upper_threshold = 3;
return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
FMT_ASSERT(n != 0, "");
// Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.
constexpr uint32_t mod_inv_5 = 0xcccccccd;
- constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5
+ constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5
while (true) {
auto q = rotr(n * mod_inv_25, 2);
// If n is not divisible by 10^8, work with n itself.
constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd;
- constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // = mod_inv_5 * mod_inv_5
+ constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // mod_inv_5 * mod_inv_5
int s = 0;
while (true) {
return ret_value;
}
-template <typename T> decimal_fp<T> to_decimal(T x) noexcept {
+template <typename T> auto to_decimal(T x) noexcept -> decimal_fp<T> {
// Step 1: integer promotion & Schubfach multiplier calculation.
using carrier_uint = typename float_info<T>::carrier_uint;
for (auto i = n.bigits_.size(); i > 0; --i) {
auto value = n.bigits_[i - 1u];
if (first) {
- out = format_to(out, FMT_STRING("{:x}"), value);
+ out = fmt::format_to(out, FMT_STRING("{:x}"), value);
first = false;
continue;
}
- out = format_to(out, FMT_STRING("{:08x}"), value);
+ out = fmt::format_to(out, FMT_STRING("{:08x}"), value);
}
if (n.exp_ > 0)
- out = format_to(out, FMT_STRING("p{}"),
- n.exp_ * detail::bigint::bigit_bits);
+ out = fmt::format_to(out, FMT_STRING("p{}"),
+ n.exp_ * detail::bigint::bigit_bits);
return out;
}
};
report_error(format_system_error, error_code, message);
}
-FMT_FUNC std::string vformat(string_view fmt, format_args args) {
+FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
// Don't optimize the "{}" case to keep the binary size small and because it
// can be better optimized in fmt::format anyway.
auto buffer = memory_buffer();
}
namespace detail {
-#ifndef _WIN32
-FMT_FUNC bool write_console(std::FILE*, string_view) { return false; }
+#if !defined(_WIN32) || defined(FMT_WINDOWS_NO_WCHAR)
+FMT_FUNC auto write_console(int, string_view) -> bool { return false; }
+FMT_FUNC auto write_console(std::FILE*, string_view) -> bool { return false; }
#else
using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( //
void*, const void*, dword, dword*, void*);
-FMT_FUNC bool write_console(std::FILE* f, string_view text) {
- auto fd = _fileno(f);
- if (!_isatty(fd)) return false;
+FMT_FUNC bool write_console(int fd, string_view text) {
auto u16 = utf8_to_utf16(text);
- auto written = dword();
return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
- static_cast<uint32_t>(u16.size()), &written, nullptr) != 0;
+ static_cast<dword>(u16.size()), nullptr, nullptr) != 0;
}
+FMT_FUNC auto write_console(std::FILE* f, string_view text) -> bool {
+ return write_console(_fileno(f), text);
+}
+#endif
+
+#ifdef _WIN32
// Print assuming legacy (non-Unicode) encoding.
FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
auto buffer = memory_buffer();
- detail::vformat_to(buffer, fmt,
- basic_format_args<buffer_context<char>>(args));
- fwrite_fully(buffer.data(), 1, buffer.size(), f);
+ detail::vformat_to(buffer, fmt, args);
+ fwrite_fully(buffer.data(), buffer.size(), f);
}
#endif
FMT_FUNC void print(std::FILE* f, string_view text) {
- if (!write_console(f, text)) fwrite_fully(text.data(), 1, text.size(), f);
+#ifdef _WIN32
+ int fd = _fileno(f);
+ if (_isatty(fd)) {
+ std::fflush(f);
+ if (write_console(fd, text)) return;
+ }
+#endif
+ fwrite_fully(text.data(), text.size(), f);
}
} // namespace detail
#include <system_error> // std::system_error
#ifdef __cpp_lib_bit_cast
-# include <bit> // std::bitcast
+# include <bit> // std::bit_cast
#endif
#include "core.h"
# define FMT_NO_UNIQUE_ADDRESS
#endif
-#if FMT_GCC_VERSION || defined(__clang__)
-# define FMT_VISIBILITY(value) __attribute__((visibility(value)))
+// Visibility when compiled as a shared library/object.
+#if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
+# define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value)
#else
-# define FMT_VISIBILITY(value)
+# define FMT_SO_VISIBILITY(value)
#endif
#ifdef __has_builtin
#ifndef FMT_USE_USER_DEFINED_LITERALS
// EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs.
-# if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \
+//
+// GCC before 4.9 requires a space in `operator"" _a` which is invalid in later
+// compiler versions.
+# if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 409 || \
FMT_MSC_VERSION >= 1900) && \
(!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480)
# define FMT_USE_USER_DEFINED_LITERALS 1
#endif
FMT_BEGIN_NAMESPACE
-
-template <typename...> struct disjunction : std::false_type {};
-template <typename P> struct disjunction<P> : P {};
-template <typename P1, typename... Pn>
-struct disjunction<P1, Pn...>
- : conditional_t<bool(P1::value), P1, disjunction<Pn...>> {};
-
-template <typename...> struct conjunction : std::true_type {};
-template <typename P> struct conjunction<P> : P {};
-template <typename P1, typename... Pn>
-struct conjunction<P1, Pn...>
- : conditional_t<bool(P1::value), conjunction<Pn...>, P1> {};
-
namespace detail {
FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
constexpr CharT string_literal<CharT, C...>::value[sizeof...(C)];
#endif
-template <typename Streambuf> class formatbuf : public Streambuf {
- private:
- using char_type = typename Streambuf::char_type;
- using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
- using int_type = typename Streambuf::int_type;
- using traits_type = typename Streambuf::traits_type;
-
- buffer<char_type>& buffer_;
-
- public:
- explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
-
- protected:
- // The put area is always empty. This makes the implementation simpler and has
- // the advantage that the streambuf and the buffer are always in sync and
- // sputc never writes into uninitialized memory. A disadvantage is that each
- // call to sputc always results in a (virtual) call to overflow. There is no
- // disadvantage here for sputn since this always results in a call to xsputn.
-
- auto overflow(int_type ch) -> int_type override {
- if (!traits_type::eq_int_type(ch, traits_type::eof()))
- buffer_.push_back(static_cast<char_type>(ch));
- return ch;
- }
-
- auto xsputn(const char_type* s, streamsize count) -> streamsize override {
- buffer_.append(s, s + count);
- return count;
- }
-};
-
// Implementation of std::bit_cast for pre-C++20.
template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) == sizeof(From))>
FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To {
constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {}
constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {}
- constexpr uint64_t high() const noexcept { return hi_; }
- constexpr uint64_t low() const noexcept { return lo_; }
+ constexpr auto high() const noexcept -> uint64_t { return hi_; }
+ constexpr auto low() const noexcept -> uint64_t { return lo_; }
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
constexpr explicit operator T() const {
hi_ &= n.hi_;
}
- FMT_CONSTEXPR20 uint128_fallback& operator+=(uint64_t n) noexcept {
+ FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& {
if (is_constant_evaluated()) {
lo_ += n;
hi_ += (lo_ < n ? 1 : 0);
}
// Computes approximate display width of a UTF-8 string.
-FMT_CONSTEXPR inline size_t compute_width(string_view s) {
+FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t {
size_t num_code_points = 0;
// It is not a lambda for compatibility with C++14.
struct count_code_points {
// Calculates the index of the nth code point in a UTF-8 string.
inline auto code_point_index(string_view s, size_t n) -> size_t {
- const char* data = s.data();
- size_t num_code_points = 0;
- for (size_t i = 0, size = s.size(); i != size; ++i) {
- if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) return i;
- }
- return s.size();
+ size_t result = s.size();
+ const char* begin = s.begin();
+ for_each_codepoint(s, [begin, &n, &result](uint32_t, string_view sv) {
+ if (n != 0) {
+ --n;
+ return true;
+ }
+ result = to_unsigned(sv.begin() - begin);
+ return false;
+ });
+ return result;
}
inline auto code_point_index(basic_string_view<char8_type> s, size_t n)
**Example**::
auto out = fmt::memory_buffer();
- format_to(std::back_inserter(out), "The answer is {}.", 42);
+ fmt::format_to(std::back_inserter(out), "The answer is {}.", 42);
This will append the following output to the ``out`` object:
/** Increases the buffer capacity to *new_capacity*. */
void reserve(size_t new_capacity) { this->try_reserve(new_capacity); }
- // Directly append data into the buffer
using detail::buffer<T>::append;
template <typename ContiguousRange>
void append(const ContiguousRange& range) {
FMT_END_EXPORT
namespace detail {
-FMT_API bool write_console(std::FILE* f, string_view text);
+FMT_API auto write_console(int fd, string_view text) -> bool;
+FMT_API auto write_console(std::FILE* f, string_view text) -> bool;
FMT_API void print(std::FILE*, string_view);
} // namespace detail
#endif
/** An error reported from a formatting function. */
-class FMT_VISIBILITY("default") format_error : public std::runtime_error {
+class FMT_SO_VISIBILITY("default") format_error : public std::runtime_error {
public:
using std::runtime_error::runtime_error;
};
template <typename T>
using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>;
-#define FMT_POWERS_OF_10(factor) \
- factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
- (factor)*1000000, (factor)*10000000, (factor)*100000000, \
- (factor)*1000000000
+#define FMT_POWERS_OF_10(factor) \
+ factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
+ (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
+ (factor) * 100000000, (factor) * 1000000000
// Converts value in the range [0, 100) to a string.
-constexpr const char* digits2(size_t value) {
+constexpr auto digits2(size_t value) -> const char* {
// GCC generates slightly better code when value is pointer-size.
return &"0001020304050607080910111213141516171819"
"2021222324252627282930313233343536373839"
}
// Sign is a template parameter to workaround a bug in gcc 4.8.
-template <typename Char, typename Sign> constexpr Char sign(Sign s) {
+template <typename Char, typename Sign> constexpr auto sign(Sign s) -> Char {
#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 604
static_assert(std::is_same<Sign, sign_t>::value, "");
#endif
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
- char buffer[num_bits<UInt>() / BASE_BITS + 1];
+ char buffer[num_bits<UInt>() / BASE_BITS + 1] = {};
format_uint<BASE_BITS>(buffer, value, num_digits, upper);
return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out);
}
: "invalid utf32"));
}
operator string_view() const { return string_view(&buffer_[0], size()); }
- size_t size() const { return buffer_.size() - 1; }
- const char* c_str() const { return &buffer_[0]; }
- std::string str() const { return std::string(&buffer_[0], size()); }
+ auto size() const -> size_t { return buffer_.size() - 1; }
+ auto c_str() const -> const char* { return &buffer_[0]; }
+ auto str() const -> std::string { return std::string(&buffer_[0], size()); }
// Performs conversion returning a bool instead of throwing exception on
// conversion error. This method may still throw in case of memory allocation
// error.
- bool convert(basic_string_view<WChar> s,
- to_utf8_error_policy policy = to_utf8_error_policy::abort) {
+ auto convert(basic_string_view<WChar> s,
+ to_utf8_error_policy policy = to_utf8_error_policy::abort)
+ -> bool {
if (!convert(buffer_, s, policy)) return false;
buffer_.push_back(0);
return true;
}
- static bool convert(
- Buffer& buf, basic_string_view<WChar> s,
- to_utf8_error_policy policy = to_utf8_error_policy::abort) {
+ static auto convert(Buffer& buf, basic_string_view<WChar> s,
+ to_utf8_error_policy policy = to_utf8_error_policy::abort)
+ -> bool {
for (auto p = s.begin(); p != s.end(); ++p) {
uint32_t c = static_cast<uint32_t>(*p);
if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) {
};
// Computes 128-bit result of multiplication of two 64-bit unsigned integers.
-inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept {
+inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback {
#if FMT_USE_INT128
auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
namespace dragonbox {
// Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from
// https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1.
-inline int floor_log10_pow2(int e) noexcept {
+inline auto floor_log10_pow2(int e) noexcept -> int {
FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
return (e * 315653) >> 20;
}
-inline int floor_log2_pow10(int e) noexcept {
+inline auto floor_log2_pow10(int e) noexcept -> int {
FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
return (e * 1741647) >> 19;
}
// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
-inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept {
+inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t {
#if FMT_USE_INT128
auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
return static_cast<uint64_t>(p >> 64);
// Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a
// 128-bit unsigned integer.
-inline uint128_fallback umul192_upper128(uint64_t x,
- uint128_fallback y) noexcept {
+inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept
+ -> uint128_fallback {
uint128_fallback r = umul128(x, y.high());
r += umul128_upper64(x, y.low());
return r;
}
-FMT_API uint128_fallback get_cached_power(int k) noexcept;
+FMT_API auto get_cached_power(int k) noexcept -> uint128_fallback;
// Type-specific information that Dragonbox uses.
template <typename T, typename Enable = void> struct float_info;
} // namespace dragonbox
// Returns true iff Float has the implicit bit which is not stored.
-template <typename Float> constexpr bool has_implicit_bit() {
+template <typename Float> constexpr auto has_implicit_bit() -> bool {
// An 80-bit FP number has a 64-bit significand an no implicit bit.
return std::numeric_limits<Float>::digits != 64;
}
// Returns the number of significand bits stored in Float. The implicit bit is
// not counted since it is not stored.
-template <typename Float> constexpr int num_significand_bits() {
+template <typename Float> constexpr auto num_significand_bits() -> int {
// std::numeric_limits may not support __float128.
return is_float128<Float>() ? 112
: (std::numeric_limits<Float>::digits -
// Normalizes the value converted from double and multiplied by (1 << SHIFT).
template <int SHIFT = 0, typename F>
-FMT_CONSTEXPR basic_fp<F> normalize(basic_fp<F> value) {
+FMT_CONSTEXPR auto normalize(basic_fp<F> value) -> basic_fp<F> {
// Handle subnormals.
const auto implicit_bit = F(1) << num_significand_bits<double>();
const auto shifted_implicit_bit = implicit_bit << SHIFT;
}
// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
-FMT_CONSTEXPR inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
+FMT_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t {
#if FMT_USE_INT128
auto product = static_cast<__uint128_t>(lhs) * rhs;
auto f = static_cast<uint64_t>(product >> 64);
#endif
}
-FMT_CONSTEXPR inline fp operator*(fp x, fp y) {
+FMT_CONSTEXPR inline auto operator*(fp x, fp y) -> fp {
return {multiply(x.f, y.f), x.e + y.e + 64};
}
-template <typename T = void> struct basic_data {
- // For checking rounding thresholds.
- // The kth entry is chosen to be the smallest integer such that the
- // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k.
- static constexpr uint32_t fractional_part_rounding_thresholds[8] = {
- 2576980378U, // ceil(2^31 + 2^32/10^1)
- 2190433321U, // ceil(2^31 + 2^32/10^2)
- 2151778616U, // ceil(2^31 + 2^32/10^3)
- 2147913145U, // ceil(2^31 + 2^32/10^4)
- 2147526598U, // ceil(2^31 + 2^32/10^5)
- 2147487943U, // ceil(2^31 + 2^32/10^6)
- 2147484078U, // ceil(2^31 + 2^32/10^7)
- 2147483691U // ceil(2^31 + 2^32/10^8)
- };
-};
-// This is a struct rather than an alias to avoid shadowing warnings in gcc.
-struct data : basic_data<> {};
-
-#if FMT_CPLUSPLUS < 201703L
-template <typename T>
-constexpr uint32_t basic_data<T>::fractional_part_rounding_thresholds[];
-#endif
-
template <typename T, bool doublish = num_bits<T>() == num_bits<double>()>
using convert_float_result =
conditional_t<std::is_same<T, float>::value || doublish, double, T>;
template <typename Char, typename OutputIt>
auto write_escaped_char(OutputIt out, Char v) -> OutputIt {
+ Char v_array[1] = {v};
*out++ = static_cast<Char>('\'');
if ((needs_escape(static_cast<uint32_t>(v)) && v != static_cast<Char>('"')) ||
v == static_cast<Char>('\'')) {
- out = write_escaped_cp(
- out, find_escape_result<Char>{&v, &v + 1, static_cast<uint32_t>(v)});
+ out = write_escaped_cp(out,
+ find_escape_result<Char>{v_array, v_array + 1,
+ static_cast<uint32_t>(v)});
} else {
*out++ = v;
}
std::string::const_iterator group;
int pos;
};
- next_state initial_state() const { return {grouping_.begin(), 0}; }
+ auto initial_state() const -> next_state { return {grouping_.begin(), 0}; }
// Returns the next digit group separator position.
- int next(next_state& state) const {
+ auto next(next_state& state) const -> int {
if (thousands_sep_.empty()) return max_value<int>();
if (state.group == grouping_.end()) return state.pos += grouping_.back();
if (*state.group <= 0 || *state.group == max_value<char>())
digit_grouping(std::string grouping, std::basic_string<Char> sep)
: grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {}
- bool has_separator() const { return !thousands_sep_.empty(); }
+ auto has_separator() const -> bool { return !thousands_sep_.empty(); }
- int count_separators(int num_digits) const {
+ auto count_separators(int num_digits) const -> int {
int count = 0;
auto state = initial_state();
while (num_digits > next(state)) ++count;
// Applies grouping to digits and write the output to out.
template <typename Out, typename C>
- Out apply(Out out, basic_string_view<C> digits) const {
+ auto apply(Out out, basic_string_view<C> digits) const -> Out {
auto num_digits = static_cast<int>(digits.size());
auto separators = basic_memory_buffer<int>();
separators.push_back(0);
}
};
+FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {
+ prefix |= prefix != 0 ? value << 8 : value;
+ prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
+}
+
// Writes a decimal integer with digit grouping.
template <typename OutputIt, typename UInt, typename Char>
auto write_int(OutputIt out, UInt value, unsigned prefix,
const format_specs<Char>& specs,
const digit_grouping<Char>& grouping) -> OutputIt {
static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
- int num_digits = count_digits(value);
- char digits[40];
- format_decimal(digits, value, num_digits);
- unsigned size = to_unsigned((prefix != 0 ? 1 : 0) + num_digits +
- grouping.count_separators(num_digits));
+ int num_digits = 0;
+ auto buffer = memory_buffer();
+ switch (specs.type) {
+ case presentation_type::none:
+ case presentation_type::dec: {
+ num_digits = count_digits(value);
+ format_decimal<char>(appender(buffer), value, num_digits);
+ break;
+ }
+ case presentation_type::hex_lower:
+ case presentation_type::hex_upper: {
+ bool upper = specs.type == presentation_type::hex_upper;
+ if (specs.alt)
+ prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
+ num_digits = count_digits<4>(value);
+ format_uint<4, char>(appender(buffer), value, num_digits, upper);
+ break;
+ }
+ case presentation_type::bin_lower:
+ case presentation_type::bin_upper: {
+ bool upper = specs.type == presentation_type::bin_upper;
+ if (specs.alt)
+ prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
+ num_digits = count_digits<1>(value);
+ format_uint<1, char>(appender(buffer), value, num_digits);
+ break;
+ }
+ case presentation_type::oct: {
+ num_digits = count_digits<3>(value);
+ // Octal prefix '0' is counted as a digit, so only add it if precision
+ // is not greater than the number of digits.
+ if (specs.alt && specs.precision <= num_digits && value != 0)
+ prefix_append(prefix, '0');
+ format_uint<3, char>(appender(buffer), value, num_digits);
+ break;
+ }
+ case presentation_type::chr:
+ return write_char(out, static_cast<Char>(value), specs);
+ default:
+ throw_format_error("invalid format specifier");
+ }
+
+ unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) +
+ to_unsigned(grouping.count_separators(num_digits));
return write_padded<align::right>(
out, specs, size, size, [&](reserve_iterator<OutputIt> it) {
- if (prefix != 0) {
- char sign = static_cast<char>(prefix);
- *it++ = static_cast<Char>(sign);
- }
- return grouping.apply(it, string_view(digits, to_unsigned(num_digits)));
+ for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
+ *it++ = static_cast<Char>(p & 0xff);
+ return grouping.apply(it, string_view(buffer.data(), buffer.size()));
});
}
return false;
}
-FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {
- prefix |= prefix != 0 ? value << 8 : value;
- prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
-}
-
template <typename UInt> struct write_int_arg {
UInt abs_value;
unsigned prefix;
FMT_CONSTEXPR counting_iterator() : count_(0) {}
- FMT_CONSTEXPR size_t count() const { return count_; }
+ FMT_CONSTEXPR auto count() const -> size_t { return count_; }
- FMT_CONSTEXPR counting_iterator& operator++() {
+ FMT_CONSTEXPR auto operator++() -> counting_iterator& {
++count_;
return *this;
}
- FMT_CONSTEXPR counting_iterator operator++(int) {
+ FMT_CONSTEXPR auto operator++(int) -> counting_iterator {
auto it = *this;
++*this;
return it;
}
- FMT_CONSTEXPR friend counting_iterator operator+(counting_iterator it,
- difference_type n) {
+ FMT_CONSTEXPR friend auto operator+(counting_iterator it, difference_type n)
+ -> counting_iterator {
it.count_ += static_cast<size_t>(n);
return it;
}
- FMT_CONSTEXPR value_type operator*() const { return {}; }
+ FMT_CONSTEXPR auto operator*() const -> value_type { return {}; }
};
template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out, const Char* s,
const format_specs<Char>& specs, locale_ref)
-> OutputIt {
- return specs.type != presentation_type::pointer
- ? write(out, basic_string_view<Char>(s), specs, {})
- : write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs);
+ if (specs.type == presentation_type::pointer)
+ return write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs);
+ if (!s) throw_format_error("string pointer is null");
+ return write(out, basic_string_view<Char>(s), specs, {});
}
template <typename Char, typename OutputIt, typename T,
bool showpoint : 1;
};
-template <typename ErrorHandler = error_handler, typename Char>
-FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs,
- ErrorHandler&& eh = {})
+template <typename Char>
+FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs)
-> float_specs {
auto result = float_specs();
result.showpoint = specs.alt;
result.format = float_format::hex;
break;
default:
- eh.on_error("invalid format specifier");
+ throw_format_error("invalid format specifier");
break;
}
return result;
public:
constexpr fallback_digit_grouping(locale_ref, bool) {}
- constexpr bool has_separator() const { return false; }
+ constexpr auto has_separator() const -> bool { return false; }
- constexpr int count_separators(int) const { return 0; }
+ constexpr auto count_separators(int) const -> int { return 0; }
template <typename Out, typename C>
- constexpr Out apply(Out out, basic_string_view<C>) const {
+ constexpr auto apply(Out out, basic_string_view<C>) const -> Out {
return out;
}
};
}
}
-template <typename T> constexpr bool isnan(T value) {
+template <typename T> constexpr auto isnan(T value) -> bool {
return !(value >= value); // std::isnan doesn't support __float128.
}
template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value&&
has_isfinite<T>::value)>
-FMT_CONSTEXPR20 bool isfinite(T value) {
+FMT_CONSTEXPR20 auto isfinite(T value) -> bool {
constexpr T inf = T(std::numeric_limits<double>::infinity());
if (is_constant_evaluated())
return !detail::isnan(value) && value < inf && value > -inf;
return std::isfinite(value);
}
template <typename T, FMT_ENABLE_IF(!has_isfinite<T>::value)>
-FMT_CONSTEXPR bool isfinite(T value) {
+FMT_CONSTEXPR auto isfinite(T value) -> bool {
T inf = T(std::numeric_limits<double>::infinity());
// std::isfinite doesn't support __float128.
return !detail::isnan(value) && value < inf && value > -inf;
basic_memory_buffer<bigit, bigits_capacity> bigits_;
int exp_;
- FMT_CONSTEXPR20 bigit operator[](int index) const {
+ FMT_CONSTEXPR20 auto operator[](int index) const -> bigit {
return bigits_[to_unsigned(index)];
}
- FMT_CONSTEXPR20 bigit& operator[](int index) {
+ FMT_CONSTEXPR20 auto operator[](int index) -> bigit& {
return bigits_[to_unsigned(index)];
}
assign(uint64_or_128_t<Int>(n));
}
- FMT_CONSTEXPR20 int num_bigits() const {
+ FMT_CONSTEXPR20 auto num_bigits() const -> int {
return static_cast<int>(bigits_.size()) + exp_;
}
- FMT_NOINLINE FMT_CONSTEXPR20 bigint& operator<<=(int shift) {
+ FMT_NOINLINE FMT_CONSTEXPR20 auto operator<<=(int shift) -> bigint& {
FMT_ASSERT(shift >= 0, "");
exp_ += shift / bigit_bits;
shift %= bigit_bits;
return *this;
}
- template <typename Int> FMT_CONSTEXPR20 bigint& operator*=(Int value) {
+ template <typename Int>
+ FMT_CONSTEXPR20 auto operator*=(Int value) -> bigint& {
FMT_ASSERT(value > 0, "");
multiply(uint32_or_64_or_128_t<Int>(value));
return *this;
}
- friend FMT_CONSTEXPR20 int compare(const bigint& lhs, const bigint& rhs) {
+ friend FMT_CONSTEXPR20 auto compare(const bigint& lhs, const bigint& rhs)
+ -> int {
int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
if (num_lhs_bigits != num_rhs_bigits)
return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
}
// Returns compare(lhs1 + lhs2, rhs).
- friend FMT_CONSTEXPR20 int add_compare(const bigint& lhs1, const bigint& lhs2,
- const bigint& rhs) {
+ friend FMT_CONSTEXPR20 auto add_compare(const bigint& lhs1,
+ const bigint& lhs2, const bigint& rhs)
+ -> int {
auto minimum = [](int a, int b) { return a < b ? a : b; };
auto maximum = [](int a, int b) { return a > b ? a : b; };
int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits());
bigits_.resize(to_unsigned(num_bigits + exp_difference));
for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
bigits_[j] = bigits_[i];
- std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
+ std::uninitialized_fill_n(bigits_.data(), exp_difference, 0u);
exp_ -= exp_difference;
}
// Divides this bignum by divisor, assigning the remainder to this and
// returning the quotient.
- FMT_CONSTEXPR20 int divmod_assign(const bigint& divisor) {
+ FMT_CONSTEXPR20 auto divmod_assign(const bigint& divisor) -> int {
FMT_ASSERT(this != &divisor, "");
if (compare(*this, divisor) < 0) return 0;
FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
}
if (buf[0] == overflow) {
buf[0] = '1';
- if ((flags & dragon::fixed) != 0) buf.push_back('0');
- else ++exp10;
+ if ((flags & dragon::fixed) != 0)
+ buf.push_back('0');
+ else
+ ++exp10;
}
return;
}
format_hexfloat(static_cast<double>(value), precision, specs, buf);
}
+constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t {
+ // For checking rounding thresholds.
+ // The kth entry is chosen to be the smallest integer such that the
+ // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k.
+ // It is equal to ceil(2^31 + 2^32/10^(k + 1)).
+ // These are stored in a string literal because we cannot have static arrays
+ // in constexpr functions and non-static ones are poorly optimized.
+ return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7"
+ U"\x800001ae\x8000002b"[index];
+}
+
template <typename Float>
FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs,
buffer<char>& buf) -> int {
// fractional part is strictly larger than 1/2.
if (precision < 9) {
uint32_t fractional_part = static_cast<uint32_t>(prod);
- should_round_up = fractional_part >=
- data::fractional_part_rounding_thresholds
- [8 - number_of_digits_to_print] ||
- ((fractional_part >> 31) &
- ((digits & 1) | (second_third_subsegments != 0) |
- has_more_segments)) != 0;
+ should_round_up =
+ fractional_part >= fractional_part_rounding_thresholds(
+ 8 - number_of_digits_to_print) ||
+ ((fractional_part >> 31) &
+ ((digits & 1) | (second_third_subsegments != 0) |
+ has_more_segments)) != 0;
}
// Rounding at the subsegment boundary.
// In this case, the fractional part is at least 1/2 if and only if
// of 19 digits, so in this case the third segment should be
// consisting of a genuine digit from the input.
uint32_t fractional_part = static_cast<uint32_t>(prod);
- should_round_up = fractional_part >=
- data::fractional_part_rounding_thresholds
- [8 - number_of_digits_to_print] ||
- ((fractional_part >> 31) &
- ((digits & 1) | (third_subsegment != 0) |
- has_more_segments)) != 0;
+ should_round_up =
+ fractional_part >= fractional_part_rounding_thresholds(
+ 8 - number_of_digits_to_print) ||
+ ((fractional_part >> 31) &
+ ((digits & 1) | (third_subsegment != 0) |
+ has_more_segments)) != 0;
}
// Rounding at the subsegment boundary.
else {
FMT_CONSTEXPR auto write(OutputIt out, const T& value)
-> enable_if_t<mapped_type_constant<T, Context>::value == type::custom_type,
OutputIt> {
+ auto formatter = typename Context::template formatter_type<T>();
+ auto parse_ctx = typename Context::parse_context_type({});
+ formatter.parse(parse_ctx);
auto ctx = Context(out, {}, {});
- return typename Context::template formatter_type<T>().format(value, ctx);
+ return formatter.format(value, ctx);
}
// An argument visitor that formats the argument and writes it via the output
}
};
-template <typename Char> struct custom_formatter {
- basic_format_parse_context<Char>& parse_ctx;
- buffer_context<Char>& ctx;
-
- void operator()(
- typename basic_format_arg<buffer_context<Char>>::handle h) const {
- h.format(parse_ctx, ctx);
- }
- template <typename T> void operator()(T) const {}
-};
-
-template <typename ErrorHandler> class width_checker {
- public:
- explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}
-
+struct width_checker {
template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
- if (is_negative(value)) handler_.on_error("negative width");
+ if (is_negative(value)) throw_format_error("negative width");
return static_cast<unsigned long long>(value);
}
template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
- handler_.on_error("width is not integer");
+ throw_format_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) {}
-
+struct precision_checker {
template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
- if (is_negative(value)) handler_.on_error("negative precision");
+ if (is_negative(value)) throw_format_error("negative precision");
return static_cast<unsigned long long>(value);
}
template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
- handler_.on_error("precision is not integer");
+ throw_format_error("precision is not integer");
return 0;
}
-
- private:
- ErrorHandler& handler_;
};
-template <template <typename> class Handler, typename FormatArg,
- typename ErrorHandler>
-FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg, ErrorHandler eh) -> int {
- 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");
+template <typename Handler, typename FormatArg>
+FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg) -> int {
+ unsigned long long value = visit_format_arg(Handler(), arg);
+ if (value > to_unsigned(max_value<int>()))
+ throw_format_error("number is too big");
return static_cast<int>(value);
}
return arg;
}
-template <template <typename> class Handler, typename Context>
+template <typename Handler, typename Context>
FMT_CONSTEXPR void handle_dynamic_spec(int& value,
arg_ref<typename Context::char_type> ref,
Context& ctx) {
case arg_id_kind::none:
break;
case arg_id_kind::index:
- value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.index),
- ctx.error_handler());
+ value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.index));
break;
case arg_id_kind::name:
- value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.name),
- ctx.error_handler());
+ value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.name));
break;
}
}
template <typename T, typename Char>
struct formatter<T, Char, enable_if_t<detail::has_format_as<T>::value>>
- : private formatter<detail::format_as_t<T>, Char> {
- using base = formatter<detail::format_as_t<T>, Char>;
- using base::parse;
-
+ : formatter<detail::format_as_t<T>, Char> {
template <typename FormatContext>
auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) {
+ using base = formatter<detail::format_as_t<T>, Char>;
return base::format(format_as(value), ctx);
}
};
}
};
+template <typename T> struct nested_view {
+ const formatter<T>* fmt;
+ const T* value;
+};
+
+template <typename T> struct formatter<nested_view<T>> {
+ FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* {
+ return ctx.begin();
+ }
+ auto format(nested_view<T> view, format_context& ctx) const
+ -> decltype(ctx.out()) {
+ return view.fmt->format(*view.value, ctx);
+ }
+};
+
+template <typename T> struct nested_formatter {
+ private:
+ int width_;
+ detail::fill_t<char> fill_;
+ align_t align_ : 4;
+ formatter<T> formatter_;
+
+ public:
+ constexpr nested_formatter() : width_(0), align_(align_t::none) {}
+
+ FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* {
+ auto specs = detail::dynamic_format_specs<char>();
+ auto it = parse_format_specs(ctx.begin(), ctx.end(), specs, ctx,
+ detail::type::none_type);
+ width_ = specs.width;
+ fill_ = specs.fill;
+ align_ = specs.align;
+ ctx.advance_to(it);
+ return formatter_.parse(ctx);
+ }
+
+ template <typename F>
+ auto write_padded(format_context& ctx, F write) const -> decltype(ctx.out()) {
+ if (width_ == 0) return write(ctx.out());
+ auto buf = memory_buffer();
+ write(std::back_inserter(buf));
+ auto specs = format_specs<>();
+ specs.width = width_;
+ specs.fill = fill_;
+ specs.align = align_;
+ return detail::write(ctx.out(), string_view(buf.data(), buf.size()), specs);
+ }
+
+ auto nested(const T& value) const -> nested_view<T> {
+ return nested_view<T>{&formatter_, &value};
+ }
+};
+
// DEPRECATED! join_view will be moved to ranges.h.
template <typename It, typename Sentinel, typename Char = char>
struct join_view : detail::view {
auto out = buffer_appender<Char>(buf);
if (fmt.size() == 2 && equal2(fmt.data(), "{}")) {
auto arg = args.get(0);
- if (!arg) error_handler().on_error("argument not found");
+ if (!arg) throw_format_error("argument not found");
visit_format_arg(default_arg_formatter<Char>{out, args, loc}, arg);
return;
}
}
FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
int arg_id = context.arg_id(id);
- if (arg_id < 0) on_error("argument not found");
+ if (arg_id < 0) throw_format_error("argument not found");
return arg_id;
}
auto on_format_specs(int id, const Char* begin, const Char* end)
-> const Char* {
auto arg = get_arg(context, id);
- if (arg.type() == type::custom_type) {
- parse_context.advance_to(begin);
- visit_format_arg(custom_formatter<Char>{parse_context, context}, arg);
+ // Not using a visitor for custom types gives better codegen.
+ if (arg.format_custom(begin, parse_context, context))
return parse_context.begin();
- }
auto specs = detail::dynamic_format_specs<Char>();
begin = parse_format_specs(begin, end, specs, parse_context, arg.type());
detail::handle_dynamic_spec<detail::width_checker>(
detail::handle_dynamic_spec<detail::precision_checker>(
specs.precision, specs.precision_ref, context);
if (begin == end || *begin != '}')
- on_error("missing '}' in format string");
+ throw_format_error("missing '}' in format string");
auto f = arg_formatter<Char>{context.out(), specs, context.locale()};
context.advance_to(visit_format_arg(f, arg));
return begin;
return detail::udl_arg<char_t, sizeof(Str.data) / sizeof(char_t), Str>();
}
# else
-constexpr auto operator"" _a(const char* s, size_t) -> detail::udl_arg<char> {
+constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg<char> {
return {s};
}
# endif
detail::type::custom_type>>::format(const T& val,
FormatContext& ctx)
const -> decltype(ctx.out()) {
- if (specs_.width_ref.kind != detail::arg_id_kind::none ||
- specs_.precision_ref.kind != detail::arg_id_kind::none) {
- auto specs = specs_;
- detail::handle_dynamic_spec<detail::width_checker>(specs.width,
- specs.width_ref, ctx);
- detail::handle_dynamic_spec<detail::precision_checker>(
- specs.precision, specs.precision_ref, ctx);
- return detail::write<Char>(ctx.out(), val, specs, ctx.locale());
- }
- return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
+ if (specs_.width_ref.kind == detail::arg_id_kind::none &&
+ specs_.precision_ref.kind == detail::arg_id_kind::none) {
+ return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
+ }
+ auto specs = specs_;
+ detail::handle_dynamic_spec<detail::width_checker>(specs.width,
+ specs.width_ref, ctx);
+ detail::handle_dynamic_spec<detail::precision_checker>(
+ specs.precision, specs.precision_ref, ctx);
+ return detail::write<Char>(ctx.out(), val, specs, ctx.locale());
}
FMT_END_NAMESPACE
#include <fstream> // std::filebuf
-#if defined(_WIN32) && defined(__GLIBCXX__)
-# include <ext/stdio_filebuf.h>
-# include <ext/stdio_sync_filebuf.h>
-#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
-# include <__std_stream>
+#ifdef _WIN32
+# ifdef __GLIBCXX__
+# include <ext/stdio_filebuf.h>
+# include <ext/stdio_sync_filebuf.h>
+# endif
+# include <io.h>
#endif
#include "format.h"
FMT_BEGIN_NAMESPACE
-
namespace detail {
+template <typename Streambuf> class formatbuf : public Streambuf {
+ private:
+ using char_type = typename Streambuf::char_type;
+ using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
+ using int_type = typename Streambuf::int_type;
+ using traits_type = typename Streambuf::traits_type;
+
+ buffer<char_type>& buffer_;
+
+ public:
+ explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
+
+ protected:
+ // The put area is always empty. This makes the implementation simpler and has
+ // the advantage that the streambuf and the buffer are always in sync and
+ // sputc never writes into uninitialized memory. A disadvantage is that each
+ // call to sputc always results in a (virtual) call to overflow. There is no
+ // disadvantage here for sputn since this always results in a call to xsputn.
+
+ auto overflow(int_type ch) -> int_type override {
+ if (!traits_type::eq_int_type(ch, traits_type::eof()))
+ buffer_.push_back(static_cast<char_type>(ch));
+ return ch;
+ }
+
+ auto xsputn(const char_type* s, streamsize count) -> streamsize override {
+ buffer_.append(s, s + count);
+ return count;
+ }
+};
+
// Generate a unique explicit instantion in every translation unit using a tag
// type in an anonymous namespace.
namespace {
template class file_access<file_access_tag, std::filebuf,
&std::filebuf::_Myfile>;
auto get_file(std::filebuf&) -> FILE*;
-#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
-template class file_access<file_access_tag, std::__stdoutbuf<char>,
- &std::__stdoutbuf<char>::__file_>;
-auto get_file(std::__stdoutbuf<char>&) -> FILE*;
#endif
-inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) {
+inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data)
+ -> bool {
+ FILE* f = nullptr;
#if FMT_MSC_VERSION
if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
- if (FILE* f = get_file(*buf)) return write_console(f, data);
+ f = get_file(*buf);
+ else
+ return false;
#elif defined(_WIN32) && defined(__GLIBCXX__)
auto* rdbuf = os.rdbuf();
- FILE* c_file;
if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
- c_file = sfbuf->file();
+ f = sfbuf->file();
else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
- c_file = fbuf->file();
+ f = fbuf->file();
else
return false;
- if (c_file) return write_console(c_file, data);
-#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
- if (auto* buf = dynamic_cast<std::__stdoutbuf<char>*>(os.rdbuf()))
- if (FILE* f = get_file(*buf)) return write_console(f, data);
#else
- ignore_unused(os, data);
+ ignore_unused(os, data, f);
+#endif
+#ifdef _WIN32
+ if (f) {
+ int fd = _fileno(f);
+ if (_isatty(fd)) {
+ os.flush();
+ return write_console(fd, data);
+ }
+ }
#endif
return false;
}
-inline bool write_ostream_unicode(std::wostream&,
- fmt::basic_string_view<wchar_t>) {
+inline auto write_ostream_unicode(std::wostream&,
+ fmt::basic_string_view<wchar_t>) -> bool {
return false;
}
}
template <typename Char, typename T>
-void format_value(buffer<Char>& buf, const T& value,
- locale_ref loc = locale_ref()) {
+void format_value(buffer<Char>& buf, const T& value) {
auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
auto&& output = std::basic_ostream<Char>(&format_buf);
#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
- if (loc) output.imbue(loc.get<std::locale>());
+ output.imbue(std::locale::classic()); // The default is always unlocalized.
#endif
output << value;
output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
}
-template <typename T> struct streamed_view { const T& value; };
+template <typename T> struct streamed_view {
+ const T& value;
+};
} // namespace detail
auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
-> OutputIt {
auto buffer = basic_memory_buffer<Char>();
- detail::format_value(buffer, value, ctx.locale());
+ detail::format_value(buffer, value);
return formatter<basic_string_view<Char>, Char>::format(
{buffer.data(), buffer.size()}, ctx);
}
\endrst
*/
template <typename T>
-auto streamed(const T& value) -> detail::streamed_view<T> {
+constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
return {value};
}
# endif
#endif
+#if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
+# include <source_location>
+#endif
+
// GCC 4 does not support FMT_HAS_INCLUDE.
#if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
# include <cxxabi.h>
# endif
#endif
-#ifdef __cpp_lib_filesystem
+// For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
+#ifndef FMT_CPP_LIB_FILESYSTEM
+# ifdef __cpp_lib_filesystem
+# define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem
+# else
+# define FMT_CPP_LIB_FILESYSTEM 0
+# endif
+#endif
+
+#ifndef FMT_CPP_LIB_VARIANT
+# ifdef __cpp_lib_variant
+# define FMT_CPP_LIB_VARIANT __cpp_lib_variant
+# else
+# define FMT_CPP_LIB_VARIANT 0
+# endif
+#endif
+
+#if FMT_CPP_LIB_FILESYSTEM
FMT_BEGIN_NAMESPACE
namespace detail {
-template <typename Char> auto get_path_string(const std::filesystem::path& p) {
- return p.string<Char>();
+template <typename Char, typename PathChar>
+auto get_path_string(const std::filesystem::path& p,
+ const std::basic_string<PathChar>& native) {
+ if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
+ return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
+ else
+ return p.string<Char>();
}
-template <typename Char>
+template <typename Char, typename PathChar>
void write_escaped_path(basic_memory_buffer<Char>& quoted,
- const std::filesystem::path& p) {
- write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
-}
-
-# ifdef _WIN32
-template <>
-inline auto get_path_string<char>(const std::filesystem::path& p) {
- return to_utf8<wchar_t>(p.native(), to_utf8_error_policy::replace);
-}
-
-template <>
-inline void write_escaped_path<char>(memory_buffer& quoted,
- const std::filesystem::path& p) {
- auto buf = basic_memory_buffer<wchar_t>();
- write_escaped_string<wchar_t>(std::back_inserter(buf), p.native());
- bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
- FMT_ASSERT(valid, "invalid utf16");
-}
-# endif // _WIN32
-
-template <>
-inline void write_escaped_path<std::filesystem::path::value_type>(
- basic_memory_buffer<std::filesystem::path::value_type>& quoted,
- const std::filesystem::path& p) {
- write_escaped_string<std::filesystem::path::value_type>(
- std::back_inserter(quoted), p.native());
+ const std::filesystem::path& p,
+ const std::basic_string<PathChar>& native) {
+ if constexpr (std::is_same_v<Char, char> &&
+ std::is_same_v<PathChar, wchar_t>) {
+ auto buf = basic_memory_buffer<wchar_t>();
+ write_escaped_string<wchar_t>(std::back_inserter(buf), native);
+ bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
+ FMT_ASSERT(valid, "invalid utf16");
+ } else if constexpr (std::is_same_v<Char, PathChar>) {
+ write_escaped_string<std::filesystem::path::value_type>(
+ std::back_inserter(quoted), native);
+ } else {
+ write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
+ }
}
} // namespace detail
format_specs<Char> specs_;
detail::arg_ref<Char> width_ref_;
bool debug_ = false;
+ char path_type_ = 0;
public:
FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
debug_ = true;
++it;
}
+ if (it != end && (*it == 'g')) path_type_ = *it++;
return it;
}
template <typename FormatContext>
auto format(const std::filesystem::path& p, FormatContext& ctx) const {
auto specs = specs_;
+# ifdef _WIN32
+ auto path_string = !path_type_ ? p.native() : p.generic_wstring();
+# else
+ auto path_string = !path_type_ ? p.native() : p.generic_string();
+# endif
+
detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
ctx);
if (!debug_) {
- auto s = detail::get_path_string<Char>(p);
+ auto s = detail::get_path_string<Char>(p, path_string);
return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
}
auto quoted = basic_memory_buffer<Char>();
- detail::write_escaped_path(quoted, p);
+ detail::write_escaped_path(quoted, p, path_string);
return detail::write(ctx.out(),
basic_string_view<Char>(quoted.data(), quoted.size()),
specs);
}
};
FMT_END_NAMESPACE
-#endif
+#endif // FMT_CPP_LIB_FILESYSTEM
FMT_BEGIN_NAMESPACE
+FMT_EXPORT
+template <std::size_t N, typename Char>
+struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
+ private:
+ // Functor because C++11 doesn't support generic lambdas.
+ struct writer {
+ const std::bitset<N>& bs;
+
+ template <typename OutputIt>
+ FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {
+ for (auto pos = N; pos > 0; --pos) {
+ out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
+ }
+
+ return out;
+ }
+ };
+
+ public:
+ template <typename FormatContext>
+ auto format(const std::bitset<N>& bs, FormatContext& ctx) const
+ -> decltype(ctx.out()) {
+ return write_padded(ctx, writer{bs});
+ }
+};
+
FMT_EXPORT
template <typename Char>
struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
}
template <typename FormatContext>
- auto format(std::optional<T> const& opt, FormatContext& ctx) const
+ auto format(const std::optional<T>& opt, FormatContext& ctx) const
-> decltype(ctx.out()) {
if (!opt) return detail::write<Char>(ctx.out(), none);
FMT_END_NAMESPACE
#endif // __cpp_lib_optional
-#ifdef __cpp_lib_variant
+#ifdef __cpp_lib_source_location
+FMT_BEGIN_NAMESPACE
+FMT_EXPORT
+template <> struct formatter<std::source_location> {
+ template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
+ return ctx.begin();
+ }
+
+ template <typename FormatContext>
+ auto format(const std::source_location& loc, FormatContext& ctx) const
+ -> decltype(ctx.out()) {
+ auto out = ctx.out();
+ out = detail::write(out, loc.file_name());
+ out = detail::write(out, ':');
+ out = detail::write<char>(out, loc.line());
+ out = detail::write(out, ':');
+ out = detail::write<char>(out, loc.column());
+ out = detail::write(out, ": ");
+ out = detail::write(out, loc.function_name());
+ return out;
+ }
+};
+FMT_END_NAMESPACE
+#endif
+
+#if FMT_CPP_LIB_VARIANT
FMT_BEGIN_NAMESPACE
namespace detail {
}
};
FMT_END_NAMESPACE
-#endif // __cpp_lib_variant
+#endif // FMT_CPP_LIB_VARIANT
FMT_BEGIN_NAMESPACE
FMT_EXPORT
FMT_EXPORT
template <typename T, typename Char>
struct formatter<
- T, Char,
+ T, Char, // DEPRECATED! Mixing code unit types.
typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
private:
bool with_typename_ = false;
# ifdef FMT_HAS_ABI_CXA_DEMANGLE
int status = 0;
std::size_t size = 0;
- std::unique_ptr<char, decltype(&std::free)> demangled_name_ptr(
+ std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
string_view demangled_name_view;
#ifdef __cpp_lib_atomic_flag_test
FMT_EXPORT
template <typename Char>
-struct formatter<std::atomic_flag, Char>
- : formatter<bool, Char> {
+struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
template <typename FormatContext>
auto format(const std::atomic_flag& v, FormatContext& ctx) const
-> decltype(ctx.out()) {
return formatter<bool, Char>::format(v.test(), ctx);
}
};
-#endif // __cpp_lib_atomic_flag_test
+#endif // __cpp_lib_atomic_flag_test
FMT_END_NAMESPACE
#endif // FMT_STD_H_
projects / thirdparty / ccache.git / commitdiff
