ouch/inspircd
2
0
Fork 0
mirror of https://github.com/inspircd/inspircd.git synced 2025-03-09 10:39:02 -04:00
Code Issues Packages Projects Releases Wiki Activity

Update fmtlib.

Browse Source
This commit is contained in:
Sadie Powell 2025-02-26 19:01:09 +00:00
parent 55a7690b50
commit 7058e49247
10 changed files with 119 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vendor/README.md vendored
View File

@ -18,7 +18,7 @@ This directory contains vendored dependencies that are shipped with InspIRCd to
**License** — MIT License **License** — MIT License
**Version** — 11.1.1 **Version** — 11.1.4
**Website** — [https://github.com/fmtlib/fmt/](https://github.com/fmtlib/fmt/) **Website** — [https://github.com/fmtlib/fmt/](https://github.com/fmtlib/fmt/)

46
vendor/fmt/base.h vendored
View File

@ -21,7 +21,7 @@
#endif #endif
// The fmt library version in the form major * 10000 + minor * 100 + patch. // The fmt library version in the form major * 10000 + minor * 100 + patch.
#define FMT_VERSION 110101 #define FMT_VERSION 110104
// Detect compiler versions. // Detect compiler versions.
#if defined(__clang__) && !defined(__ibmxl__) #if defined(__clang__) && !defined(__ibmxl__)
@ -96,9 +96,9 @@
// Detect C++14 relaxed constexpr. // Detect C++14 relaxed constexpr.
#ifdef FMT_USE_CONSTEXPR #ifdef FMT_USE_CONSTEXPR
// Use the provided definition. // Use the provided definition.
#elif FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L #elif FMT_GCC_VERSION >= 702 && FMT_CPLUSPLUS >= 201402L
// GCC only allows throw in constexpr since version 6: // GCC only allows constexpr member functions in non-literal types since 7.2:
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67371. // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66297.
# define FMT_USE_CONSTEXPR 1 # define FMT_USE_CONSTEXPR 1
#elif FMT_ICC_VERSION #elif FMT_ICC_VERSION
# define FMT_USE_CONSTEXPR 0 // https://github.com/fmtlib/fmt/issues/1628 # define FMT_USE_CONSTEXPR 0 // https://github.com/fmtlib/fmt/issues/1628
@ -294,12 +294,12 @@
#endif #endif
#define FMT_APPLY_VARIADIC(expr) \ #define FMT_APPLY_VARIADIC(expr) \
using ignore = int[]; \ using unused = int[]; \
(void)ignore { 0, (expr, 0)... } (void)unused { 0, (expr, 0)... }
// Enable minimal optimizations for more compact code in debug mode. // Enable minimal optimizations for more compact code in debug mode.
FMT_PRAGMA_GCC(push_options) FMT_PRAGMA_GCC(push_options)
#if !defined(__OPTIMIZE__) && !defined(__CUDACC__) #if !defined(__OPTIMIZE__) && !defined(__CUDACC__) && !defined(FMT_MODULE)
FMT_PRAGMA_GCC(optimize("Og")) FMT_PRAGMA_GCC(optimize("Og"))
#endif #endif
FMT_PRAGMA_CLANG(diagnostic push) FMT_PRAGMA_CLANG(diagnostic push)
@ -537,7 +537,7 @@ template <typename Char> class basic_string_view {
FMT_ALWAYS_INLINE FMT_ALWAYS_INLINE
#endif #endif
FMT_CONSTEXPR20 basic_string_view(const Char* s) : data_(s) { FMT_CONSTEXPR20 basic_string_view(const Char* s) : data_(s) {
#if FMT_HAS_BUILTIN(__buitin_strlen) || FMT_GCC_VERSION || FMT_CLANG_VERSION #if FMT_HAS_BUILTIN(__builtin_strlen) || FMT_GCC_VERSION || FMT_CLANG_VERSION
if (std::is_same<Char, char>::value) { if (std::is_same<Char, char>::value) {
size_ = __builtin_strlen(detail::narrow(s)); size_ = __builtin_strlen(detail::narrow(s));
return; return;
@ -739,13 +739,15 @@ class basic_specs {
max_fill_size = 4 max_fill_size = 4
}; };
size_t data_ = 1 << fill_size_shift; unsigned data_ = 1 << fill_size_shift;
static_assert(sizeof(basic_specs::data_) * CHAR_BIT >= 18, "");
// Character (code unit) type is erased to prevent template bloat. // Character (code unit) type is erased to prevent template bloat.
char fill_data_[max_fill_size] = {' '}; char fill_data_[max_fill_size] = {' '};
FMT_CONSTEXPR void set_fill_size(size_t size) { FMT_CONSTEXPR void set_fill_size(size_t size) {
data_ = (data_ & ~fill_size_mask) | (size << fill_size_shift); data_ = (data_ & ~fill_size_mask) |
(static_cast<unsigned>(size) << fill_size_shift);
} }
public: public:
@ -842,6 +844,12 @@ class basic_specs {
for (size_t i = 0; i < size; ++i) for (size_t i = 0; i < size; ++i)
fill_data_[i & 3] = static_cast<char>(s[i]); fill_data_[i & 3] = static_cast<char>(s[i]);
} }
FMT_CONSTEXPR void copy_fill_from(const basic_specs& specs) {
set_fill_size(specs.fill_size());
for (size_t i = 0; i < max_fill_size; ++i)
fill_data_[i] = specs.fill_data_[i];
}
}; };
// Format specifiers for built-in and string types. // Format specifiers for built-in and string types.
@ -1113,7 +1121,7 @@ using use_formatter =
bool_constant<(std::is_class<T>::value || std::is_enum<T>::value || bool_constant<(std::is_class<T>::value || std::is_enum<T>::value ||
std::is_union<T>::value || std::is_array<T>::value) && std::is_union<T>::value || std::is_array<T>::value) &&
!has_to_string_view<T>::value && !is_named_arg<T>::value && !has_to_string_view<T>::value && !is_named_arg<T>::value &&
!use_format_as<T>::value && !use_format_as_member<T>::value>; !use_format_as<T>::value && !use_format_as_member<U>::value>;
template <typename Char, typename T, typename U = remove_const_t<T>> template <typename Char, typename T, typename U = remove_const_t<T>>
auto has_formatter_impl(T* p, buffered_context<Char>* ctx = nullptr) auto has_formatter_impl(T* p, buffered_context<Char>* ctx = nullptr)
@ -2255,28 +2263,27 @@ template <> struct is_output_iterator<appender, char> : std::true_type {};
template <typename It, typename T> template <typename It, typename T>
struct is_output_iterator< struct is_output_iterator<
It, T, It, T,
void_t<decltype(*std::declval<decay_t<It>&>()++ = std::declval<T>())>> enable_if_t<std::is_assignable<decltype(*std::declval<decay_t<It>&>()++),
: std::true_type {}; T>::value>> : std::true_type {};
#ifndef FMT_USE_LOCALE #ifndef FMT_USE_LOCALE
# define FMT_USE_LOCALE (FMT_OPTIMIZE_SIZE <= 1) # define FMT_USE_LOCALE (FMT_OPTIMIZE_SIZE <= 1)
#endif #endif
// A type-erased reference to an std::locale to avoid a heavy <locale> include. // A type-erased reference to an std::locale to avoid a heavy <locale> include.
struct locale_ref { class locale_ref {
#if FMT_USE_LOCALE #if FMT_USE_LOCALE
private: private:
const void* locale_; // A type-erased pointer to std::locale. const void* locale_; // A type-erased pointer to std::locale.
public: public:
constexpr locale_ref() : locale_(nullptr) {} constexpr locale_ref() : locale_(nullptr) {}
template <typename Locale> locale_ref(const Locale& loc);
template <typename Locale, FMT_ENABLE_IF(sizeof(Locale::collate) != 0)>
locale_ref(const Locale& loc);
inline explicit operator bool() const noexcept { return locale_ != nullptr; } inline explicit operator bool() const noexcept { return locale_ != nullptr; }
#endif // FMT_USE_LOCALE #endif // FMT_USE_LOCALE
public:
template <typename Locale> auto get() const -> Locale; template <typename Locale> auto get() const -> Locale;
}; };
@ -2650,6 +2657,7 @@ class context {
FMT_CONSTEXPR auto arg_id(string_view name) const -> int { FMT_CONSTEXPR auto arg_id(string_view name) const -> int {
return args_.get_id(name); return args_.get_id(name);
} }
auto args() const -> const format_args& { return args_; }
// Returns an iterator to the beginning of the output range. // Returns an iterator to the beginning of the output range.
FMT_CONSTEXPR auto out() const -> iterator { return out_; } FMT_CONSTEXPR auto out() const -> iterator { return out_; }
@ -2722,9 +2730,9 @@ template <typename... T> struct fstring {
std::is_same<typename S::char_type, char>::value)> std::is_same<typename S::char_type, char>::value)>
FMT_ALWAYS_INLINE fstring(const S&) : str(S()) { FMT_ALWAYS_INLINE fstring(const S&) : str(S()) {
FMT_CONSTEXPR auto sv = string_view(S()); FMT_CONSTEXPR auto sv = string_view(S());
FMT_CONSTEXPR int ignore = FMT_CONSTEXPR int unused =
(parse_format_string(sv, checker(sv, arg_pack())), 0); (parse_format_string(sv, checker(sv, arg_pack())), 0);
detail::ignore_unused(ignore); detail::ignore_unused(unused);
} }
fstring(runtime_format_string<> fmt) : str(fmt.str) {} fstring(runtime_format_string<> fmt) : str(fmt.str) {}

4
vendor/fmt/chrono.h vendored
View File

@ -261,7 +261,7 @@ namespace detail {
using utc_clock = std::chrono::utc_clock; using utc_clock = std::chrono::utc_clock;
#else #else
struct utc_clock { struct utc_clock {
void to_sys(); template <typename T> void to_sys(T);
}; };
#endif #endif
@ -364,7 +364,7 @@ void write_codecvt(codecvt_result<CodeUnit>& out, string_view in,
template <typename OutputIt> template <typename OutputIt>
auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc) auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc)
-> OutputIt { -> OutputIt {
if (detail::use_utf8 && loc != get_classic_locale()) { if (const_check(detail::use_utf8) && loc != get_classic_locale()) {
// char16_t and char32_t codecvts are broken in MSVC (linkage errors) and // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and
// gcc-4. // gcc-4.
#if FMT_MSC_VERSION != 0 || \ #if FMT_MSC_VERSION != 0 || \

32
vendor/fmt/compile.h vendored
View File

@ -19,11 +19,11 @@ FMT_BEGIN_NAMESPACE
// A compile-time string which is compiled into fast formatting code. // A compile-time string which is compiled into fast formatting code.
FMT_EXPORT class compiled_string {}; FMT_EXPORT class compiled_string {};
namespace detail {
template <typename S> template <typename S>
struct is_compiled_string : std::is_base_of<compiled_string, S> {}; struct is_compiled_string : std::is_base_of<compiled_string, S> {};
namespace detail {
/** /**
* Converts a string literal `s` into a format string that will be parsed at * Converts a string literal `s` into a format string that will be parsed at
* compile time and converted into efficient formatting code. Requires C++17 * compile time and converted into efficient formatting code. Requires C++17
@ -41,16 +41,6 @@ struct is_compiled_string : std::is_base_of<compiled_string, S> {};
# define FMT_COMPILE(s) FMT_STRING(s) # define FMT_COMPILE(s) FMT_STRING(s)
#endif #endif
#if FMT_USE_NONTYPE_TEMPLATE_ARGS
template <typename Char, size_t N, fmt::detail::fixed_string<Char, N> Str>
struct udl_compiled_string : compiled_string {
using char_type = Char;
constexpr explicit operator basic_string_view<char_type>() const {
return {Str.data, N - 1};
}
};
#endif
template <typename T, typename... Tail> template <typename T, typename... Tail>
auto first(const T& value, const Tail&...) -> const T& { auto first(const T& value, const Tail&...) -> const T& {
return value; return value;
@ -425,7 +415,7 @@ constexpr auto compile_format_string(S fmt) {
} }
template <typename... Args, typename S, template <typename... Args, typename S,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> FMT_ENABLE_IF(is_compiled_string<S>::value)>
constexpr auto compile(S fmt) { constexpr auto compile(S fmt) {
constexpr auto str = basic_string_view<typename S::char_type>(fmt); constexpr auto str = basic_string_view<typename S::char_type>(fmt);
if constexpr (str.size() == 0) { if constexpr (str.size() == 0) {
@ -461,7 +451,7 @@ constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
} }
template <typename S, typename... Args, template <typename S, typename... Args,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> FMT_ENABLE_IF(is_compiled_string<S>::value)>
FMT_INLINE std::basic_string<typename S::char_type> format(const S&, FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
Args&&... args) { Args&&... args) {
if constexpr (std::is_same<typename S::char_type, char>::value) { if constexpr (std::is_same<typename S::char_type, char>::value) {
@ -488,7 +478,7 @@ FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
} }
template <typename OutputIt, typename S, typename... Args, template <typename OutputIt, typename S, typename... Args,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> FMT_ENABLE_IF(is_compiled_string<S>::value)>
FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) { FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
constexpr auto compiled = detail::compile<Args...>(S()); constexpr auto compiled = detail::compile<Args...>(S());
if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>, if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
@ -503,7 +493,7 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
#endif #endif
template <typename OutputIt, typename S, typename... Args, template <typename OutputIt, typename S, typename... Args,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> FMT_ENABLE_IF(is_compiled_string<S>::value)>
auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args) auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args)
-> format_to_n_result<OutputIt> { -> format_to_n_result<OutputIt> {
using traits = detail::fixed_buffer_traits; using traits = detail::fixed_buffer_traits;
@ -513,7 +503,7 @@ auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args)
} }
template <typename S, typename... Args, template <typename S, typename... Args,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> FMT_ENABLE_IF(is_compiled_string<S>::value)>
FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args) FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args)
-> size_t { -> size_t {
auto buf = detail::counting_buffer<>(); auto buf = detail::counting_buffer<>();
@ -522,7 +512,7 @@ FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args)
} }
template <typename S, typename... Args, template <typename S, typename... Args,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> FMT_ENABLE_IF(is_compiled_string<S>::value)>
void print(std::FILE* f, const S& fmt, const Args&... args) { void print(std::FILE* f, const S& fmt, const Args&... args) {
auto buf = memory_buffer(); auto buf = memory_buffer();
fmt::format_to(appender(buf), fmt, args...); fmt::format_to(appender(buf), fmt, args...);
@ -530,7 +520,7 @@ void print(std::FILE* f, const S& fmt, const Args&... args) {
} }
template <typename S, typename... Args, template <typename S, typename... Args,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> FMT_ENABLE_IF(is_compiled_string<S>::value)>
void print(const S& fmt, const Args&... args) { void print(const S& fmt, const Args&... args) {
print(stdout, fmt, args...); print(stdout, fmt, args...);
} }
@ -538,9 +528,7 @@ void print(const S& fmt, const Args&... args) {
#if FMT_USE_NONTYPE_TEMPLATE_ARGS #if FMT_USE_NONTYPE_TEMPLATE_ARGS
inline namespace literals { inline namespace literals {
template <detail::fixed_string Str> constexpr auto operator""_cf() { template <detail::fixed_string Str> constexpr auto operator""_cf() {
using char_t = remove_cvref_t<decltype(Str.data[0])>; return FMT_COMPILE(Str.data);
return detail::udl_compiled_string<char_t, sizeof(Str.data) / sizeof(char_t),
Str>();
} }
} // namespace literals } // namespace literals
#endif #endif

6
vendor/fmt/format-inl.h vendored
View File

@ -84,7 +84,7 @@ using std::locale;
using std::numpunct; using std::numpunct;
using std::use_facet; using std::use_facet;
template <typename Locale, enable_if_t<(sizeof(Locale::collate) != 0), int>> template <typename Locale>
locale_ref::locale_ref(const Locale& loc) : locale_(&loc) { locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
static_assert(std::is_same<Locale, locale>::value, ""); static_assert(std::is_same<Locale, locale>::value, "");
} }
@ -134,7 +134,9 @@ FMT_FUNC auto write_loc(appender out, loc_value value,
FMT_FUNC void report_error(const char* message) { FMT_FUNC void report_error(const char* message) {
#if FMT_USE_EXCEPTIONS #if FMT_USE_EXCEPTIONS
throw format_error(message); // Use FMT_THROW instead of throw to avoid bogus unreachable code warnings
// from MSVC.
FMT_THROW(format_error(message));
#else #else
fputs(message, stderr); fputs(message, stderr);
abort(); abort();

78
vendor/fmt/format.h vendored
View File

@ -227,7 +227,9 @@ FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
#if defined(FMT_USE_STRING_VIEW) #if defined(FMT_USE_STRING_VIEW)
template <typename Char> using std_string_view = std::basic_string_view<Char>; template <typename Char> using std_string_view = std::basic_string_view<Char>;
#else #else
template <typename T> struct std_string_view {}; template <typename Char> struct std_string_view {
operator basic_string_view<Char>() const;
};
#endif #endif
template <typename Char, Char... C> struct string_literal { template <typename Char, Char... C> struct string_literal {
@ -1203,7 +1205,7 @@ FMT_CONSTEXPR FMT_INLINE auto format_decimal(Char* out, UInt value,
} }
template <typename Char, typename UInt, typename OutputIt, template <typename Char, typename UInt, typename OutputIt,
FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value)> FMT_ENABLE_IF(!std::is_pointer<remove_cvref_t<OutputIt>>::value)>
FMT_CONSTEXPR auto format_decimal(OutputIt out, UInt value, int num_digits) FMT_CONSTEXPR auto format_decimal(OutputIt out, UInt value, int num_digits)
-> OutputIt { -> OutputIt {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) { if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
@ -1839,7 +1841,9 @@ template <typename Char> class digit_grouping {
} }
public: public:
explicit digit_grouping(locale_ref loc, bool localized = true) { template <typename Locale,
FMT_ENABLE_IF(std::is_same<Locale, locale_ref>::value)>
explicit digit_grouping(Locale loc, bool localized = true) {
if (!localized) return; if (!localized) return;
auto sep = thousands_sep<Char>(loc); auto sep = thousands_sep<Char>(loc);
grouping_ = sep.grouping; grouping_ = sep.grouping;
@ -2328,7 +2332,7 @@ template <typename Char, typename OutputIt, typename DecimalFP,
typename Grouping = digit_grouping<Char>> typename Grouping = digit_grouping<Char>>
FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
const format_specs& specs, sign s, const format_specs& specs, sign s,
locale_ref loc) -> OutputIt { int exp_upper, locale_ref loc) -> OutputIt {
auto significand = f.significand; auto significand = f.significand;
int significand_size = get_significand_size(f); int significand_size = get_significand_size(f);
const Char zero = static_cast<Char>('0'); const Char zero = static_cast<Char>('0');
@ -2344,7 +2348,7 @@ FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
if (specs.type() == presentation_type::fixed) return false; if (specs.type() == presentation_type::fixed) return false;
// Use the fixed notation if the exponent is in [exp_lower, exp_upper), // Use the fixed notation if the exponent is in [exp_lower, exp_upper),
// e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation. // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
const int exp_lower = -4, exp_upper = 16; const int exp_lower = -4;
return output_exp < exp_lower || return output_exp < exp_lower ||
output_exp >= (specs.precision > 0 ? specs.precision : exp_upper); output_exp >= (specs.precision > 0 ? specs.precision : exp_upper);
}; };
@ -2447,12 +2451,13 @@ template <typename Char> class fallback_digit_grouping {
template <typename Char, typename OutputIt, typename DecimalFP> template <typename Char, typename OutputIt, typename DecimalFP>
FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f, FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f,
const format_specs& specs, sign s, const format_specs& specs, sign s,
locale_ref loc) -> OutputIt { int exp_upper, locale_ref loc) -> OutputIt {
if (is_constant_evaluated()) { if (is_constant_evaluated()) {
return do_write_float<Char, OutputIt, DecimalFP, return do_write_float<Char, OutputIt, DecimalFP,
fallback_digit_grouping<Char>>(out, f, specs, s, loc); fallback_digit_grouping<Char>>(out, f, specs, s,
exp_upper, loc);
} else { } else {
return do_write_float<Char>(out, f, specs, s, loc); return do_write_float<Char>(out, f, specs, s, exp_upper, loc);
} }
} }
@ -3284,6 +3289,14 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision,
return exp; return exp;
} }
// Numbers with exponents greater or equal to the returned value will use
// the exponential notation.
template <typename T> constexpr auto exp_upper() -> int {
return std::numeric_limits<T>::digits10 != 0
? min_of(16, std::numeric_limits<T>::digits10 + 1)
: 16;
}
template <typename Char, typename OutputIt, typename T> template <typename Char, typename OutputIt, typename T>
FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, format_specs specs, FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, format_specs specs,
locale_ref loc) -> OutputIt { locale_ref loc) -> OutputIt {
@ -3299,6 +3312,7 @@ FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, format_specs specs,
if (specs.width != 0) --specs.width; if (specs.width != 0) --specs.width;
} }
constexpr int exp_upper = detail::exp_upper<T>();
int precision = specs.precision; int precision = specs.precision;
if (precision < 0) { if (precision < 0) {
if (specs.type() != presentation_type::none) { if (specs.type() != presentation_type::none) {
@ -3307,7 +3321,7 @@ FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, format_specs specs,
// Use Dragonbox for the shortest format. // Use Dragonbox for the shortest format.
using floaty = conditional_t<sizeof(T) >= sizeof(double), double, float>; using floaty = conditional_t<sizeof(T) >= sizeof(double), double, float>;
auto dec = dragonbox::to_decimal(static_cast<floaty>(value)); auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
return write_float<Char>(out, dec, specs, s, loc); return write_float<Char>(out, dec, specs, s, exp_upper, loc);
} }
} }
@ -3335,7 +3349,7 @@ FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, format_specs specs,
specs.precision = precision; specs.precision = precision;
auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp}; auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
return write_float<Char>(out, f, specs, s, loc); return write_float<Char>(out, f, specs, s, exp_upper, loc);
} }
template <typename Char, typename OutputIt, typename T, template <typename Char, typename OutputIt, typename T,
@ -3362,7 +3376,7 @@ FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
return write_nonfinite<Char>(out, std::isnan(value), specs, s); return write_nonfinite<Char>(out, std::isnan(value), specs, s);
auto dec = dragonbox::to_decimal(static_cast<floaty>(value)); auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
return write_float<Char>(out, dec, specs, s, {}); return write_float<Char>(out, dec, specs, s, exp_upper<T>(), {});
} }
template <typename Char, typename OutputIt, typename T, template <typename Char, typename OutputIt, typename T,
@ -3639,6 +3653,12 @@ FMT_CONSTEXPR auto native_formatter<T, Char, TYPE>::format(
return write<Char>(ctx.out(), val, specs, ctx.locale()); return write<Char>(ctx.out(), val, specs, ctx.locale());
} }
// DEPRECATED! https://github.com/fmtlib/fmt/issues/4292.
template <typename T, typename Enable = void>
struct is_locale : std::false_type {};
template <typename T>
struct is_locale<T, void_t<decltype(T::classic())>> : std::true_type {};
// DEPRECATED! // DEPRECATED!
template <typename Char = char> struct vformat_args { template <typename Char = char> struct vformat_args {
using type = basic_format_args<buffered_context<Char>>; using type = basic_format_args<buffered_context<Char>>;
@ -3960,8 +3980,7 @@ template <typename T, typename Char = char> struct nested_formatter {
write(basic_appender<Char>(buf)); write(basic_appender<Char>(buf));
auto specs = format_specs(); auto specs = format_specs();
specs.width = width_; specs.width = width_;
specs.set_fill( specs.copy_fill_from(specs_);
basic_string_view<Char>(specs_.fill<Char>(), specs_.fill_size()));
specs.set_align(specs_.align()); specs.set_align(specs_.align());
return detail::write<Char>( return detail::write<Char>(
ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs); ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
@ -4121,41 +4140,46 @@ FMT_API void format_system_error(detail::buffer<char>& out, int error_code,
// Can be used to report errors from destructors. // Can be used to report errors from destructors.
FMT_API void report_system_error(int error_code, const char* message) noexcept; FMT_API void report_system_error(int error_code, const char* message) noexcept;
inline auto vformat(detail::locale_ref loc, string_view fmt, format_args args) template <typename Locale, FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
inline auto vformat(const Locale& loc, string_view fmt, format_args args)
-> std::string { -> std::string {
auto buf = memory_buffer(); auto buf = memory_buffer();
detail::vformat_to(buf, fmt, args, loc); detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
return {buf.data(), buf.size()}; return {buf.data(), buf.size()};
} }
template <typename... T> template <typename Locale, typename... T,
FMT_INLINE auto format(detail::locale_ref loc, format_string<T...> fmt, FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
T&&... args) -> std::string { FMT_INLINE auto format(const Locale& loc, format_string<T...> fmt, T&&... args)
-> std::string {
return vformat(loc, fmt.str, vargs<T...>{{args...}}); return vformat(loc, fmt.str, vargs<T...>{{args...}});
} }
template <typename OutputIt, template <typename OutputIt, typename Locale,
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
auto vformat_to(OutputIt out, detail::locale_ref loc, string_view fmt, auto vformat_to(OutputIt out, const Locale& loc, string_view fmt,
format_args args) -> OutputIt { format_args args) -> OutputIt {
auto&& buf = detail::get_buffer<char>(out); auto&& buf = detail::get_buffer<char>(out);
detail::vformat_to(buf, fmt, args, loc); detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
return detail::get_iterator(buf, out); return detail::get_iterator(buf, out);
} }
template <typename OutputIt, typename... T, template <typename OutputIt, typename Locale, typename... T,
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value&&
FMT_INLINE auto format_to(OutputIt out, detail::locale_ref loc, detail::is_locale<Locale>::value)>
FMT_INLINE auto format_to(OutputIt out, const Locale& loc,
format_string<T...> fmt, T&&... args) -> OutputIt { format_string<T...> fmt, T&&... args) -> OutputIt {
return fmt::vformat_to(out, loc, fmt.str, vargs<T...>{{args...}}); return fmt::vformat_to(out, loc, fmt.str, vargs<T...>{{args...}});
} }
template <typename... T> template <typename Locale, typename... T,
FMT_NODISCARD FMT_INLINE auto formatted_size(detail::locale_ref loc, FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
FMT_NODISCARD FMT_INLINE auto formatted_size(const Locale& loc,
format_string<T...> fmt, format_string<T...> fmt,
T&&... args) -> size_t { T&&... args) -> size_t {
auto buf = detail::counting_buffer<>(); auto buf = detail::counting_buffer<>();
detail::vformat_to(buf, fmt.str, vargs<T...>{{args...}}, loc); detail::vformat_to(buf, fmt.str, vargs<T...>{{args...}},
detail::locale_ref(loc));
return buf.count(); return buf.count();
} }

2
vendor/fmt/ostream.h vendored
View File

@ -150,7 +150,7 @@ inline void vprint(std::ostream& os, string_view fmt, format_args args) {
FMT_EXPORT template <typename... T> FMT_EXPORT template <typename... T>
void print(std::ostream& os, format_string<T...> fmt, T&&... args) { void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
fmt::vargs<T...> vargs = {{args...}}; fmt::vargs<T...> vargs = {{args...}};
if (detail::use_utf8) return vprint(os, fmt.str, vargs); if (detail::const_check(detail::use_utf8)) return vprint(os, fmt.str, vargs);
auto buffer = memory_buffer(); auto buffer = memory_buffer();
detail::vformat_to(buffer, fmt.str, vargs); detail::vformat_to(buffer, fmt.str, vargs);
detail::write_buffer(os, buffer); detail::write_buffer(os, buffer);

4
vendor/fmt/ranges.h vendored
View File

@ -527,7 +527,9 @@ struct formatter<
template <typename R, typename Char> template <typename R, typename Char>
struct formatter< struct formatter<
R, Char, R, Char,
enable_if_t<range_format_kind<R, Char>::value == range_format::map>> { enable_if_t<conjunction<
bool_constant<range_format_kind<R, Char>::value == range_format::map>,
detail::is_formattable_delayed<R, Char>>::value>> {
private: private:
using map_type = detail::maybe_const_range<R>; using map_type = detail::maybe_const_range<R>;
using element_type = detail::uncvref_type<map_type>; using element_type = detail::uncvref_type<map_type>;

9
vendor/fmt/std.h vendored
View File

@ -184,7 +184,8 @@ FMT_END_NAMESPACE
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
FMT_EXPORT FMT_EXPORT
template <std::size_t N, typename Char> template <std::size_t N, typename Char>
struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> { struct formatter<std::bitset<N>, Char>
: nested_formatter<basic_string_view<Char>, Char> {
private: private:
// Functor because C++11 doesn't support generic lambdas. // Functor because C++11 doesn't support generic lambdas.
struct writer { struct writer {
@ -204,7 +205,7 @@ struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
template <typename FormatContext> template <typename FormatContext>
auto format(const std::bitset<N>& bs, FormatContext& ctx) const auto format(const std::bitset<N>& bs, FormatContext& ctx) const
-> decltype(ctx.out()) { -> decltype(ctx.out()) {
return write_padded(ctx, writer{bs}); return this->write_padded(ctx, writer{bs});
} }
}; };
@ -695,9 +696,7 @@ template <typename T, typename Char> struct formatter<std::complex<T>, Char> {
auto outer_specs = format_specs(); auto outer_specs = format_specs();
outer_specs.width = specs.width; outer_specs.width = specs.width;
auto fill = specs.template fill<Char>(); outer_specs.copy_fill_from(specs);
if (fill)
outer_specs.set_fill(basic_string_view<Char>(fill, specs.fill_size()));
outer_specs.set_align(specs.align()); outer_specs.set_align(specs.align());
specs.width = 0; specs.width = 0;

25
vendor/fmt/xchar.h vendored
View File

@ -191,9 +191,11 @@ auto format(const S& fmt, T&&... args) -> std::basic_string<Char> {
fmt::make_format_args<buffered_context<Char>>(args...)); fmt::make_format_args<buffered_context<Char>>(args...));
} }
template <typename S, typename Char = detail::format_string_char_t<S>, template <typename Locale, typename S,
FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)> typename Char = detail::format_string_char_t<S>,
inline auto vformat(detail::locale_ref loc, const S& fmt, FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
detail::is_exotic_char<Char>::value)>
inline auto vformat(const Locale& loc, const S& fmt,
typename detail::vformat_args<Char>::type args) typename detail::vformat_args<Char>::type args)
-> std::basic_string<Char> { -> std::basic_string<Char> {
auto buf = basic_memory_buffer<Char>(); auto buf = basic_memory_buffer<Char>();
@ -202,10 +204,11 @@ inline auto vformat(detail::locale_ref loc, const S& fmt,
return {buf.data(), buf.size()}; return {buf.data(), buf.size()};
} }
template <typename S, typename... T, template <typename Locale, typename S, typename... T,
typename Char = detail::format_string_char_t<S>, typename Char = detail::format_string_char_t<S>,
FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)> FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
inline auto format(detail::locale_ref loc, const S& fmt, T&&... args) detail::is_exotic_char<Char>::value)>
inline auto format(const Locale& loc, const S& fmt, T&&... args)
-> std::basic_string<Char> { -> std::basic_string<Char> {
return vformat(loc, detail::to_string_view(fmt), return vformat(loc, detail::to_string_view(fmt),
fmt::make_format_args<buffered_context<Char>>(args...)); fmt::make_format_args<buffered_context<Char>>(args...));
@ -232,11 +235,12 @@ inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
fmt::make_format_args<buffered_context<Char>>(args...)); fmt::make_format_args<buffered_context<Char>>(args...));
} }
template <typename S, typename OutputIt, typename... Args, template <typename Locale, typename S, typename OutputIt, typename... Args,
typename Char = detail::format_string_char_t<S>, typename Char = detail::format_string_char_t<S>,
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
detail::is_locale<Locale>::value&&
detail::is_exotic_char<Char>::value)> detail::is_exotic_char<Char>::value)>
inline auto vformat_to(OutputIt out, detail::locale_ref loc, const S& fmt, inline auto vformat_to(OutputIt out, const Locale& loc, const S& fmt,
typename detail::vformat_args<Char>::type args) typename detail::vformat_args<Char>::type args)
-> OutputIt { -> OutputIt {
auto&& buf = detail::get_buffer<Char>(out); auto&& buf = detail::get_buffer<Char>(out);
@ -244,11 +248,12 @@ inline auto vformat_to(OutputIt out, detail::locale_ref loc, const S& fmt,
return detail::get_iterator(buf, out); return detail::get_iterator(buf, out);
} }
template <typename OutputIt, typename S, typename... T, template <typename Locale, typename OutputIt, typename S, typename... T,
typename Char = detail::format_string_char_t<S>, typename Char = detail::format_string_char_t<S>,
bool enable = detail::is_output_iterator<OutputIt, Char>::value && bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
detail::is_locale<Locale>::value &&
detail::is_exotic_char<Char>::value> detail::is_exotic_char<Char>::value>
inline auto format_to(OutputIt out, detail::locale_ref loc, const S& fmt, inline auto format_to(OutputIt out, const Locale& loc, const S& fmt,
T&&... args) -> T&&... args) ->
typename std::enable_if<enable, OutputIt>::type { typename std::enable_if<enable, OutputIt>::type {
return vformat_to(out, loc, detail::to_string_view(fmt), return vformat_to(out, loc, detail::to_string_view(fmt),