Revert "Updated bundled fmt to version 10.0.0"

This reverts commit 62e55e7a7f.

include/spdlog/fmt/bundled/color.h

@@ -11,7 +11,7 @@
 #include "format.h"
 
 FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN
 
 enum class color : uint32_t {
   alice_blue = 0xF0F8FF,               // rgb(240,248,255)
@@ -423,6 +423,26 @@ FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept {
   return ansi_color_escape<Char>(em);
 }
 
+template <typename Char> inline void fputs(const Char* chars, FILE* stream) {
+  int result = std::fputs(chars, stream);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+template <> inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) {
+  int result = std::fputws(chars, stream);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+template <typename Char> inline void reset_color(FILE* stream) {
+  fputs("\x1b[0m", stream);
+}
+
+template <> inline void reset_color<wchar_t>(FILE* stream) {
+  fputs(L"\x1b[0m", stream);
+}
+
 template <typename Char> inline void reset_color(buffer<Char>& buffer) {
   auto reset_color = string_view("\x1b[0m");
   buffer.append(reset_color.begin(), reset_color.end());
@@ -459,19 +479,17 @@ void vformat_to(buffer<Char>& buf, const text_style& ts,
 
 FMT_END_DETAIL_NAMESPACE
 
-inline void vprint(std::FILE* f, const text_style& ts, string_view fmt,
+template <typename S, typename Char = char_t<S>>
-                   format_args args) {
+void vprint(std::FILE* f, const text_style& ts, const S& format,
-  // Legacy wide streams are not supported.
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
-  auto buf = memory_buffer();
+  basic_memory_buffer<Char> buf;
-  detail::vformat_to(buf, ts, fmt, args);
+  detail::vformat_to(buf, ts, detail::to_string_view(format), args);
   if (detail::is_utf8()) {
-    detail::print(f, string_view(buf.begin(), buf.size()));
+    detail::print(f, basic_string_view<Char>(buf.begin(), buf.size()));
-    return;
+  } else {
+    buf.push_back(Char(0));
+    detail::fputs(buf.data(), f);
   }
-  buf.push_back('\0');
-  int result = std::fputs(buf.data(), f);
-  if (result < 0)
-    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
 
 /**
@@ -548,7 +566,7 @@ OutputIt vformat_to(
     basic_format_args<buffer_context<type_identity_t<Char>>> args) {
   auto&& buf = detail::get_buffer<Char>(out);
   detail::vformat_to(buf, ts, format_str, args);
-  return detail::get_iterator(buf, out);
+  return detail::get_iterator(buf);
 }
 
 /**
@@ -627,7 +645,7 @@ FMT_CONSTEXPR auto styled(const T& value, text_style ts)
   return detail::styled_arg<remove_cvref_t<T>>{value, ts};
 }
 
-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_COLOR_H_

include/spdlog/fmt/bundled/compile.h

@@ -331,14 +331,14 @@ template <typename T, typename Char> struct parse_specs_result {
   int next_arg_id;
 };
 
-enum { manual_indexing_id = -1 };
+constexpr int manual_indexing_id = -1;
 
 template <typename T, typename Char>
 constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
                                                   size_t pos, int next_arg_id) {
   str.remove_prefix(pos);
-  auto ctx =
+  auto ctx = compile_parse_context<Char>(str, max_value<int>(), nullptr, {},
-      compile_parse_context<Char>(str, max_value<int>(), nullptr, next_arg_id);
+                                         next_arg_id);
   auto f = formatter<T, Char>();
   auto end = f.parse(ctx);
   return {f, pos + fmt::detail::to_unsigned(end - str.data()),
@@ -348,18 +348,22 @@ constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
 template <typename Char> struct arg_id_handler {
   arg_ref<Char> arg_id;
 
-  constexpr int on_auto() {
+  constexpr int operator()() {
     FMT_ASSERT(false, "handler cannot be used with automatic indexing");
     return 0;
   }
-  constexpr int on_index(int id) {
+  constexpr int operator()(int id) {
     arg_id = arg_ref<Char>(id);
     return 0;
   }
-  constexpr int on_name(basic_string_view<Char> id) {
+  constexpr int operator()(basic_string_view<Char> id) {
     arg_id = arg_ref<Char>(id);
     return 0;
   }
+
+  constexpr void on_error(const char* message) {
+    FMT_THROW(format_error(message));
+  }
 };
 
 template <typename Char> struct parse_arg_id_result {
@@ -497,7 +501,7 @@ constexpr auto compile(S format_str) {
 #endif  // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 }  // namespace detail
 
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN
 
 #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 
@@ -601,7 +605,7 @@ template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
 }  // namespace literals
 #endif
 
-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_COMPILE_H_

include/spdlog/fmt/bundled/format-inl.h

@@ -9,9 +9,13 @@
 #define FMT_FORMAT_INL_H_
 
 #include <algorithm>
+#include <cctype>
 #include <cerrno>  // errno
 #include <climits>
 #include <cmath>
+#include <cstdarg>
+#include <cstring>  // std::memmove
+#include <cwchar>
 #include <exception>
 
 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
@@ -111,43 +115,16 @@ template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
   return '.';
 }
 #endif
-
-FMT_FUNC auto write_loc(appender out, loc_value value,
-                        const format_specs<>& specs, locale_ref loc) -> bool {
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-  auto locale = loc.get<std::locale>();
-  // We cannot use the num_put<char> facet because it may produce output in
-  // a wrong encoding.
-  using facet = format_facet<std::locale>;
-  if (std::has_facet<facet>(locale))
-    return std::use_facet<facet>(locale).put(out, value, specs);
-  return facet(locale).put(out, value, specs);
-#endif
-  return false;
-}
 }  // namespace detail
 
-template <typename Locale> typename Locale::id format_facet<Locale>::id;
+#if !FMT_MSC_VERSION
-
+FMT_API FMT_FUNC format_error::~format_error() noexcept = default;
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) {
-  auto& numpunct = std::use_facet<std::numpunct<char>>(loc);
-  grouping_ = numpunct.grouping();
-  if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep());
-}
-
-template <>
-FMT_API FMT_FUNC auto format_facet<std::locale>::do_put(
-    appender out, loc_value val, const format_specs<>& specs) const -> bool {
-  return val.visit(
-      detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_});
-}
 #endif
 
-FMT_FUNC std::system_error vsystem_error(int error_code, string_view fmt,
+FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str,
                                          format_args args) {
   auto ec = std::error_code(error_code, std::generic_category());
-  return std::system_error(ec, vformat(fmt, args));
+  return std::system_error(ec, vformat(format_str, args));
 }
 
 namespace detail {
@@ -166,8 +143,58 @@ FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept {
   return (n >> r) | (n << (64 - r));
 }
 
+// Computes 128-bit result of multiplication of two 64-bit unsigned integers.
+inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept {
+#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)};
+#elif defined(_MSC_VER) && defined(_M_X64)
+  auto result = uint128_fallback();
+  result.lo_ = _umul128(x, y, &result.hi_);
+  return result;
+#else
+  const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
+
+  uint64_t a = x >> 32;
+  uint64_t b = x & mask;
+  uint64_t c = y >> 32;
+  uint64_t d = y & mask;
+
+  uint64_t ac = a * c;
+  uint64_t bc = b * c;
+  uint64_t ad = a * d;
+  uint64_t bd = b * d;
+
+  uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
+
+  return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
+          (intermediate << 32) + (bd & mask)};
+#endif
+}
+
 // Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
 namespace dragonbox {
+// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
+inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept {
+#if FMT_USE_INT128
+  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
+  return static_cast<uint64_t>(p >> 64);
+#elif defined(_MSC_VER) && defined(_M_X64)
+  return __umulh(x, y);
+#else
+  return umul128(x, y).high();
+#endif
+}
+
+// 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 {
+  uint128_fallback r = umul128(x, y.high());
+  r += umul128_upper64(x, y.low());
+  return r;
+}
+
 // 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 {
@@ -189,13 +216,25 @@ inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept {
   return x * y;
 }
 
+// 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 {
+  FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
+  static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
+  return (e * 315653) >> 20;
+}
+
 // Various fast log computations.
+inline int floor_log2_pow10(int e) noexcept {
+  FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
+  return (e * 1741647) >> 19;
+}
 inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept {
   FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
   return (e * 631305 - 261663) >> 21;
 }
 
-FMT_INLINE_VARIABLE constexpr struct {
+static constexpr struct {
   uint32_t divisor;
   int shift_amount;
 } div_small_pow10_infos[] = {{10, 16}, {100, 16}};
@@ -249,7 +288,7 @@ inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept {
 }
 
 // Various subroutines using pow10 cache
-template <typename T> struct cache_accessor;
+template <class T> struct cache_accessor;
 
 template <> struct cache_accessor<float> {
   using carrier_uint = float_info<float>::carrier_uint;
@@ -970,23 +1009,8 @@ template <> struct cache_accessor<double> {
       {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},
       {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},
       {0xc5a05277621be293, 0xc7098b7305241886},
-      {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8},
+      { 0xf70867153aa2db38,
-      {0x9a65406d44a5c903, 0x737f74f1dc043329},
+        0xb8cbee4fc66d1ea8 }
-      {0xc0fe908895cf3b44, 0x505f522e53053ff3},
-      {0xf13e34aabb430a15, 0x647726b9e7c68ff0},
-      {0x96c6e0eab509e64d, 0x5eca783430dc19f6},
-      {0xbc789925624c5fe0, 0xb67d16413d132073},
-      {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890},
-      {0x933e37a534cbaae7, 0x8e91b962f7b6f15a},
-      {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1},
-      {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d},
-      {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2},
-      {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e},
-      {0xe0accfa875af45a7, 0x93eb1b80a33b8606},
-      {0x8c6c01c9498d8b88, 0xbc72f130660533c4},
-      {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
-      { 0xdb68c2ca82ed2a05,
-        0xa67398db9f6820e2 }
 #else
       {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
       {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
@@ -1010,8 +1034,8 @@ template <> struct cache_accessor<double> {
       {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
       {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
       {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
-      {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
+      { 0x95527a5202df0ccb,
-      {0xf13e34aabb430a15, 0x647726b9e7c68ff0}
+        0x0f37801e0c43ebc9 }
 #endif
     };
 
@@ -1114,12 +1138,8 @@ template <> struct cache_accessor<double> {
   }
 };
 
-FMT_FUNC uint128_fallback get_cached_power(int k) noexcept {
-  return cache_accessor<double>::get_cached_power(k);
-}
-
 // Various integer checks
-template <typename T>
+template <class T>
 bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
   const int case_shorter_interval_left_endpoint_lower_threshold = 2;
   const int case_shorter_interval_left_endpoint_upper_threshold = 3;
@@ -1130,12 +1150,8 @@ bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
 // Remove trailing zeros from n and return the number of zeros removed (float)
 FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept {
   FMT_ASSERT(n != 0, "");
-  // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.
-  // See https://github.com/fmtlib/fmt/issues/3163 for more details.
   const uint32_t mod_inv_5 = 0xcccccccd;
-  // Casts are needed to workaround a bug in MSVC 19.22 and older.
+  const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
-  const uint32_t mod_inv_25 =
-      static_cast<uint32_t>(uint64_t(mod_inv_5) * mod_inv_5);
 
   int s = 0;
   while (true) {
@@ -1149,6 +1165,7 @@ FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept {
     n = q;
     s |= 1;
   }
+
   return s;
 }
 
@@ -1206,7 +1223,7 @@ FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
 }
 
 // The main algorithm for shorter interval case
-template <typename T>
+template <class T>
 FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
   decimal_fp<T> ret_value;
   // Compute k and beta
@@ -1377,6 +1394,17 @@ small_divisor_case_label:
   return ret_value;
 }
 }  // namespace dragonbox
+
+#ifdef _MSC_VER
+FMT_FUNC auto fmt_snprintf(char* buf, size_t size, const char* fmt, ...)
+    -> int {
+  auto args = va_list();
+  va_start(args, fmt);
+  int result = vsnprintf_s(buf, size, _TRUNCATE, fmt, args);
+  va_end(args);
+  return result;
+}
+#endif
 }  // namespace detail
 
 template <> struct formatter<detail::bigint> {
@@ -1385,8 +1413,9 @@ template <> struct formatter<detail::bigint> {
     return ctx.begin();
   }
 
-  auto format(const detail::bigint& n, format_context& ctx) const
+  template <typename FormatContext>
-      -> format_context::iterator {
+  auto format(const detail::bigint& n, FormatContext& ctx) const ->
+      typename FormatContext::iterator {
     auto out = ctx.out();
     bool first = true;
     for (auto i = n.bigits_.size(); i > 0; --i) {
@@ -1445,44 +1474,57 @@ FMT_FUNC std::string vformat(string_view fmt, format_args args) {
 }
 
 namespace detail {
-#ifndef _WIN32
+#ifdef _WIN32
-FMT_FUNC bool write_console(std::FILE*, string_view) { 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;
+  if (_isatty(fd)) {
-  auto u16 = utf8_to_utf16(text);
+    detail::utf8_to_utf16 u16(string_view(text.data(), text.size()));
-  auto written = dword();
+    auto written = detail::dword();
-  return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
+    if (detail::WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)),
-                       static_cast<uint32_t>(u16.size()), &written, nullptr);
+                              u16.c_str(), static_cast<uint32_t>(u16.size()),
+                              &written, nullptr)) {
+      return true;
+    }
+  }
+  // We return false if the file descriptor was not TTY, or it was but
+  // SetConsoleW failed which can happen if the output has been redirected to
+  // NUL. In both cases when we return false, we should attempt to do regular
+  // write via fwrite or std::ostream::write.
+  return false;
+}
+#endif
+
+FMT_FUNC void print(std::FILE* f, string_view text) {
+#ifdef _WIN32
+  if (write_console(f, text)) return;
+#endif
+  detail::fwrite_fully(text.data(), 1, text.size(), f);
+}
+}  // namespace detail
+
+FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
+  memory_buffer buffer;
+  detail::vformat_to(buffer, format_str, args);
+  detail::print(f, {buffer.data(), buffer.size()});
 }
 
+#ifdef _WIN32
 // Print assuming legacy (non-Unicode) encoding.
-FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
+FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str,
-  auto buffer = memory_buffer();
+                                      format_args args) {
-  detail::vformat_to(buffer, fmt,
+  memory_buffer buffer;
+  detail::vformat_to(buffer, format_str,
                      basic_format_args<buffer_context<char>>(args));
   fwrite_fully(buffer.data(), 1, buffer.size(), f);
 }
 #endif
 
-FMT_FUNC void print(std::FILE* f, string_view text) {
+FMT_FUNC void vprint(string_view format_str, format_args args) {
-  if (!write_console(f, text)) fwrite_fully(text.data(), 1, text.size(), f);
+  vprint(stdout, format_str, args);
-}
-}  // namespace detail
-
-FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) {
-  auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt, args);
-  detail::print(f, {buffer.data(), buffer.size()});
-}
-
-FMT_FUNC void vprint(string_view fmt, format_args args) {
-  vprint(stdout, fmt, args);
 }
 
 namespace detail {

include/spdlog/fmt/bundled/os.h

@@ -71,7 +71,7 @@
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
 
 FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN
 
 /**
   \rst
@@ -120,10 +120,48 @@ template <typename Char> class basic_cstring_view {
 using cstring_view = basic_cstring_view<char>;
 using wcstring_view = basic_cstring_view<wchar_t>;
 
+template <typename Char> struct formatter<std::error_code, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    out = detail::write_bytes(out, ec.category().name(),
+                              basic_format_specs<Char>());
+    out = detail::write<Char>(out, Char(':'));
+    out = detail::write<Char>(out, ec.value());
+    return out;
+  }
+};
+
 #ifdef _WIN32
 FMT_API const std::error_category& system_category() noexcept;
 
 FMT_BEGIN_DETAIL_NAMESPACE
+// A converter from UTF-16 to UTF-8.
+// It is only provided for Windows since other systems support UTF-8 natively.
+class utf16_to_utf8 {
+ private:
+  memory_buffer buffer_;
+
+ public:
+  utf16_to_utf8() {}
+  FMT_API explicit utf16_to_utf8(basic_string_view<wchar_t> s);
+  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()); }
+
+  // Performs conversion returning a system error code instead of
+  // throwing exception on conversion error. This method may still throw
+  // in case of memory allocation error.
+  FMT_API int convert(basic_string_view<wchar_t> s);
+};
+
 FMT_API void format_windows_error(buffer<char>& out, int error_code,
                                   const char* message) noexcept;
 FMT_END_DETAIL_NAMESPACE
@@ -317,12 +355,6 @@ class FMT_API file {
   // Creates a buffered_file object associated with this file and detaches
   // this file object from the file.
   buffered_file fdopen(const char* mode);
-
-#  if defined(_WIN32) && !defined(__MINGW32__)
-  // Opens a file and constructs a file object representing this file by
-  // wcstring_view filename. Windows only.
-  static file open_windows_file(wcstring_view path, int oflag);
-#  endif
 };
 
 // Returns the memory page size.
@@ -365,28 +397,6 @@ struct ostream_params {
 #  endif
 };
 
-class file_buffer final : public buffer<char> {
-  file file_;
-
-  FMT_API void grow(size_t) override;
-
- public:
-  FMT_API file_buffer(cstring_view path, const ostream_params& params);
-  FMT_API file_buffer(file_buffer&& other);
-  FMT_API ~file_buffer();
-
-  void flush() {
-    if (size() == 0) return;
-    file_.write(data(), size() * sizeof(data()[0]));
-    clear();
-  }
-
-  void close() {
-    flush();
-    file_.close();
-  }
-};
-
 FMT_END_DETAIL_NAMESPACE
 
 // Added {} below to work around default constructor error known to
@@ -394,32 +404,49 @@ FMT_END_DETAIL_NAMESPACE
 constexpr detail::buffer_size buffer_size{};
 
 /** A fast output stream which is not thread-safe. */
-class FMT_API ostream {
+class FMT_API ostream final : private detail::buffer<char> {
  private:
-  FMT_MSC_WARNING(suppress : 4251)
+  file file_;
-  detail::file_buffer buffer_;
+
+  void grow(size_t) override;
 
   ostream(cstring_view path, const detail::ostream_params& params)
-      : buffer_(path, params) {}
+      : file_(path, params.oflag) {
+    set(new char[params.buffer_size], params.buffer_size);
+  }
 
  public:
-  ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {}
+  ostream(ostream&& other)
+      : detail::buffer<char>(other.data(), other.size(), other.capacity()),
+        file_(std::move(other.file_)) {
+    other.clear();
+    other.set(nullptr, 0);
+  }
+  ~ostream() {
+    flush();
+    delete[] data();
+  }
 
-  ~ostream();
+  void flush() {
-
+    if (size() == 0) return;
-  void flush() { buffer_.flush(); }
+    file_.write(data(), size());
+    clear();
+  }
 
   template <typename... T>
   friend ostream output_file(cstring_view path, T... params);
 
-  void close() { buffer_.close(); }
+  void close() {
+    flush();
+    file_.close();
+  }
 
   /**
     Formats ``args`` according to specifications in ``fmt`` and writes the
     output to the file.
    */
   template <typename... T> void print(format_string<T...> fmt, T&&... args) {
-    vformat_to(detail::buffer_appender<char>(buffer_), fmt,
+    vformat_to(detail::buffer_appender<char>(*this), fmt,
                fmt::make_format_args(args...));
   }
 };
@@ -445,7 +472,7 @@ inline ostream output_file(cstring_view path, T... params) {
 }
 #endif  // FMT_USE_FCNTL
 
-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_OS_H_

include/spdlog/fmt/bundled/ostream.h

@@ -8,8 +8,8 @@
 #ifndef FMT_OSTREAM_H_
 #define FMT_OSTREAM_H_
 
-#include <fstream>  // std::filebuf
+#include <fstream>
-
+#include <ostream>
 #if defined(_WIN32) && defined(__GLIBCXX__)
 #  include <ext/stdio_filebuf.h>
 #  include <ext/stdio_sync_filebuf.h>
@@ -21,14 +21,48 @@
 
 FMT_BEGIN_NAMESPACE
 
+template <typename OutputIt, typename Char> class basic_printf_context;
+
 namespace detail {
 
+// Checks if T has a user-defined operator<<.
+template <typename T, typename Char, typename Enable = void>
+class is_streamable {
+ private:
+  template <typename U>
+  static auto test(int)
+      -> bool_constant<sizeof(std::declval<std::basic_ostream<Char>&>()
+                              << std::declval<U>()) != 0>;
+
+  template <typename> static auto test(...) -> std::false_type;
+
+  using result = decltype(test<T>(0));
+
+ public:
+  is_streamable() = default;
+
+  static const bool value = result::value;
+};
+
+// Formatting of built-in types and arrays is intentionally disabled because
+// it's handled by standard (non-ostream) formatters.
+template <typename T, typename Char>
+struct is_streamable<
+    T, Char,
+    enable_if_t<
+        std::is_arithmetic<T>::value || std::is_array<T>::value ||
+        std::is_pointer<T>::value || std::is_same<T, char8_type>::value ||
+        std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
+        std::is_same<T, std_string_view<Char>>::value ||
+        (std::is_convertible<T, int>::value && !std::is_enum<T>::value)>>
+    : std::false_type {};
+
 // Generate a unique explicit instantion in every translation unit using a tag
 // type in an anonymous namespace.
 namespace {
 struct file_access_tag {};
 }  // namespace
-template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
+template <class Tag, class BufType, FILE* BufType::*FileMemberPtr>
 class file_access {
   friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
 };
@@ -50,8 +84,8 @@ inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) {
 #elif defined(_WIN32) && defined(__GLIBCXX__)
   auto* rdbuf = os.rdbuf();
   FILE* c_file;
-  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
+  if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
-    c_file = sfbuf->file();
+    c_file = fbuf->file();
   else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
     c_file = fbuf->file();
   else
@@ -111,7 +145,7 @@ struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
   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());
+    format_value(buffer, value, ctx.locale());
     return formatter<basic_string_view<Char>, Char>::format(
         {buffer.data(), buffer.size()}, ctx);
   }
@@ -146,6 +180,13 @@ auto streamed(const T& value) -> detail::streamed_view<T> {
 
 namespace detail {
 
+// Formats an object of type T that has an overloaded ostream operator<<.
+template <typename T, typename Char>
+struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
+    : basic_ostream_formatter<Char> {
+  using basic_ostream_formatter<Char>::format;
+};
+
 inline void vprint_directly(std::ostream& os, string_view format_str,
                             format_args args) {
   auto buffer = memory_buffer();
@@ -191,19 +232,6 @@ void print(std::wostream& os,
   vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
 }
 
-FMT_MODULE_EXPORT template <typename... T>
-void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
-  fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
-}
-
-FMT_MODULE_EXPORT
-template <typename... Args>
-void println(std::wostream& os,
-             basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
-             Args&&... args) {
-  print(os, L"{}\n", fmt::format(fmt, std::forward<Args>(args)...));
-}
-
 FMT_END_NAMESPACE
 
 #endif  // FMT_OSTREAM_H_

include/spdlog/fmt/bundled/printf.h

@@ -14,7 +14,7 @@
 #include "format.h"
 
 FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN
 
 template <typename T> struct printf_formatter { printf_formatter() = delete; };
 
@@ -81,13 +81,13 @@ class printf_precision_handler {
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
   int operator()(T value) {
     if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      throw_format_error("number is too big");
+      FMT_THROW(format_error("number is too big"));
     return (std::max)(static_cast<int>(value), 0);
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
   int operator()(T) {
-    throw_format_error("precision is not integer");
+    FMT_THROW(format_error("precision is not integer"));
     return 0;
   }
 };
@@ -194,10 +194,12 @@ template <typename Char> struct get_cstring {
 // left alignment if it is negative.
 template <typename Char> class printf_width_handler {
  private:
-  format_specs<Char>& specs_;
+  using format_specs = basic_format_specs<Char>;
+
+  format_specs& specs_;
 
  public:
-  explicit printf_width_handler(format_specs<Char>& specs) : specs_(specs) {}
+  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
 
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
   unsigned operator()(T value) {
@@ -207,31 +209,24 @@ template <typename Char> class printf_width_handler {
       width = 0 - width;
     }
     unsigned int_max = max_value<int>();
-    if (width > int_max) throw_format_error("number is too big");
+    if (width > int_max) FMT_THROW(format_error("number is too big"));
     return static_cast<unsigned>(width);
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
   unsigned operator()(T) {
-    throw_format_error("width is not integer");
+    FMT_THROW(format_error("width is not integer"));
     return 0;
   }
 };
 
-// Workaround for a bug with the XL compiler when initializing
-// printf_arg_formatter's base class.
-template <typename Char>
-auto make_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s)
-    -> arg_formatter<Char> {
-  return {iter, s, locale_ref()};
-}
-
 // The ``printf`` argument formatter.
 template <typename OutputIt, typename Char>
 class printf_arg_formatter : public arg_formatter<Char> {
  private:
   using base = arg_formatter<Char>;
   using context_type = basic_printf_context<OutputIt, Char>;
+  using format_specs = basic_format_specs<Char>;
 
   context_type& context_;
 
@@ -242,8 +237,8 @@ class printf_arg_formatter : public arg_formatter<Char> {
   }
 
  public:
-  printf_arg_formatter(OutputIt iter, format_specs<Char>& s, context_type& ctx)
+  printf_arg_formatter(OutputIt iter, format_specs& s, context_type& ctx)
-      : base(make_arg_formatter(iter, s)), context_(ctx) {}
+      : base{iter, s, locale_ref()}, context_(ctx) {}
 
   OutputIt operator()(monostate value) { return base::operator()(value); }
 
@@ -252,7 +247,7 @@ class printf_arg_formatter : public arg_formatter<Char> {
     // MSVC2013 fails to compile separate overloads for bool and Char so use
     // std::is_same instead.
     if (std::is_same<T, Char>::value) {
-      format_specs<Char> fmt_specs = this->specs;
+      format_specs fmt_specs = this->specs;
       if (fmt_specs.type != presentation_type::none &&
           fmt_specs.type != presentation_type::chr) {
         return (*this)(static_cast<int>(value));
@@ -305,7 +300,8 @@ class printf_arg_formatter : public arg_formatter<Char> {
 };
 
 template <typename Char>
-void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
+void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
+                 const Char* end) {
   for (; it != end; ++it) {
     switch (*it) {
     case '-':
@@ -332,8 +328,8 @@ void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
 }
 
 template <typename Char, typename GetArg>
-int parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
+int parse_header(const Char*& it, const Char* end,
-                 GetArg get_arg) {
+                 basic_format_specs<Char>& specs, GetArg get_arg) {
   int arg_index = -1;
   Char c = *it;
   if (c >= '0' && c <= '9') {
@@ -348,7 +344,7 @@ int parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
       if (value != 0) {
         // Nonzero value means that we parsed width and don't need to
         // parse it or flags again, so return now.
-        if (value == -1) throw_format_error("number is too big");
+        if (value == -1) FMT_THROW(format_error("number is too big"));
         specs.width = value;
         return arg_index;
       }
@@ -359,7 +355,7 @@ int parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
   if (it != end) {
     if (*it >= '0' && *it <= '9') {
       specs.width = parse_nonnegative_int(it, end, -1);
-      if (specs.width == -1) throw_format_error("number is too big");
+      if (specs.width == -1) FMT_THROW(format_error("number is too big"));
     } else if (*it == '*') {
       ++it;
       specs.width = static_cast<int>(visit_format_arg(
@@ -369,52 +365,12 @@ int parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
   return arg_index;
 }
 
-inline auto parse_printf_presentation_type(char c, type t)
-    -> presentation_type {
-  using pt = presentation_type;
-  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
-  switch (c) {
-  case 'd':
-    return in(t, integral_set) ? pt::dec : pt::none;
-  case 'o':
-    return in(t, integral_set) ? pt::oct : pt::none;
-  case 'x':
-    return in(t, integral_set) ? pt::hex_lower : pt::none;
-  case 'X':
-    return in(t, integral_set) ? pt::hex_upper : pt::none;
-  case 'a':
-    return in(t, float_set) ? pt::hexfloat_lower : pt::none;
-  case 'A':
-    return in(t, float_set) ? pt::hexfloat_upper : pt::none;
-  case 'e':
-    return in(t, float_set) ? pt::exp_lower : pt::none;
-  case 'E':
-    return in(t, float_set) ? pt::exp_upper : pt::none;
-  case 'f':
-    return in(t, float_set) ? pt::fixed_lower : pt::none;
-  case 'F':
-    return in(t, float_set) ? pt::fixed_upper : pt::none;
-  case 'g':
-    return in(t, float_set) ? pt::general_lower : pt::none;
-  case 'G':
-    return in(t, float_set) ? pt::general_upper : pt::none;
-  case 'c':
-    return in(t, integral_set) ? pt::chr : pt::none;
-  case 's':
-    return in(t, string_set | cstring_set) ? pt::string : pt::none;
-  case 'p':
-    return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
-  default:
-    return pt::none;
-  }
-}
-
 template <typename Char, typename Context>
 void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
              basic_format_args<Context> args) {
-  using iterator = buffer_appender<Char>;
+  using OutputIt = buffer_appender<Char>;
-  auto out = iterator(buf);
+  auto out = OutputIt(buf);
-  auto context = basic_printf_context<iterator, Char>(out, args);
+  auto context = basic_printf_context<OutputIt, Char>(out, args);
   auto parse_ctx = basic_printf_parse_context<Char>(format);
 
   // Returns the argument with specified index or, if arg_index is -1, the next
@@ -431,25 +387,26 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
   const Char* end = parse_ctx.end();
   auto it = start;
   while (it != end) {
-    if (!find<false, Char>(it, end, '%', it)) {
+    if (!detail::find<false, Char>(it, end, '%', it)) {
-      it = end;  // find leaves it == nullptr if it doesn't find '%'.
+      it = end;  // detail::find leaves it == nullptr if it doesn't find '%'
       break;
     }
     Char c = *it++;
     if (it != end && *it == c) {
-      out = write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
+      out = detail::write(
+          out, basic_string_view<Char>(start, detail::to_unsigned(it - start)));
       start = ++it;
       continue;
     }
-    out =
+    out = detail::write(out, basic_string_view<Char>(
-        write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
+                                 start, detail::to_unsigned(it - 1 - start)));
 
-    auto specs = format_specs<Char>();
+    basic_format_specs<Char> specs;
     specs.align = align::right;
 
     // Parse argument index, flags and width.
     int arg_index = parse_header(it, end, specs, get_arg);
-    if (arg_index == 0) throw_format_error("argument not found");
+    if (arg_index == 0) parse_ctx.on_error("argument not found");
 
     // Parse precision.
     if (it != end && *it == '.') {
@@ -460,7 +417,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
       } else if (c == '*') {
         ++it;
         specs.precision = static_cast<int>(
-            visit_format_arg(printf_precision_handler(), get_arg(-1)));
+            visit_format_arg(detail::printf_precision_handler(), get_arg(-1)));
       } else {
         specs.precision = 0;
       }
@@ -472,15 +429,17 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
     if (specs.precision >= 0 && arg.is_integral())
       specs.fill[0] =
           ' ';  // Ignore '0' flag for non-numeric types or if '-' present.
-    if (specs.precision >= 0 && arg.type() == type::cstring_type) {
+    if (specs.precision >= 0 && arg.type() == detail::type::cstring_type) {
-      auto str = visit_format_arg(get_cstring<Char>(), arg);
+      auto str = visit_format_arg(detail::get_cstring<Char>(), arg);
       auto str_end = str + specs.precision;
       auto nul = std::find(str, str_end, Char());
-      arg = make_arg<basic_printf_context<iterator, Char>>(
+      arg = detail::make_arg<basic_printf_context<OutputIt, Char>>(
           basic_string_view<Char>(
-              str, to_unsigned(nul != str_end ? nul - str : specs.precision)));
+              str, detail::to_unsigned(nul != str_end ? nul - str
+                                                      : specs.precision)));
     }
-    if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false;
+    if (specs.alt && visit_format_arg(detail::is_zero_int(), arg))
+      specs.alt = false;
     if (specs.fill[0] == '0') {
       if (arg.is_arithmetic() && specs.align != align::left)
         specs.align = align::numeric;
@@ -492,6 +451,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
     // Parse length and convert the argument to the required type.
     c = it != end ? *it++ : 0;
     Char t = it != end ? *it : 0;
+    using detail::convert_arg;
     switch (c) {
     case 'h':
       if (t == 'h') {
@@ -530,7 +490,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
     }
 
     // Parse type.
-    if (it == end) throw_format_error("invalid format string");
+    if (it == end) FMT_THROW(format_error("invalid format string"));
     char type = static_cast<char>(*it++);
     if (arg.is_integral()) {
       // Normalize type.
@@ -541,21 +501,22 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
         break;
       case 'c':
         visit_format_arg(
-            char_converter<basic_printf_context<iterator, Char>>(arg), arg);
+            detail::char_converter<basic_printf_context<OutputIt, Char>>(arg),
+            arg);
         break;
       }
     }
-    specs.type = parse_printf_presentation_type(type, arg.type());
+    specs.type = parse_presentation_type(type);
     if (specs.type == presentation_type::none)
-      throw_format_error("invalid format specifier");
+      parse_ctx.on_error("invalid type specifier");
 
     start = it;
 
     // Format argument.
     out = visit_format_arg(
-        printf_arg_formatter<iterator, Char>(out, specs, context), arg);
+        detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
   }
-  write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
+  detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
 }
 FMT_END_DETAIL_NAMESPACE
 
@@ -598,9 +559,9 @@ inline auto vsprintf(
     const S& fmt,
     basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
     -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
+  basic_memory_buffer<Char> buffer;
-  detail::vprintf(buf, detail::to_string_view(fmt), args);
+  vprintf(buffer, detail::to_string_view(fmt), args);
-  return to_string(buf);
+  return to_string(buffer);
 }
 
 /**
@@ -625,10 +586,10 @@ inline auto vfprintf(
     std::FILE* f, const S& fmt,
     basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
     -> int {
-  auto buf = basic_memory_buffer<Char>();
+  basic_memory_buffer<Char> buffer;
-  detail::vprintf(buf, detail::to_string_view(fmt), args);
+  vprintf(buffer, detail::to_string_view(fmt), args);
-  size_t size = buf.size();
+  size_t size = buffer.size();
-  return std::fwrite(buf.data(), sizeof(Char), size, f) < size
+  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
              ? -1
              : static_cast<int>(size);
 }
@@ -673,7 +634,7 @@ inline auto printf(const S& fmt, const T&... args) -> int {
       fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
 }
 
-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_PRINTF_H_

include/spdlog/fmt/bundled/ranges.h

@@ -22,25 +22,27 @@ FMT_BEGIN_NAMESPACE
 
 namespace detail {
 
-template <typename Range, typename OutputIt>
+template <typename RangeT, typename OutputIterator>
-auto copy(const Range& range, OutputIt out) -> OutputIt {
+OutputIterator copy(const RangeT& range, OutputIterator out) {
   for (auto it = range.begin(), end = range.end(); it != end; ++it)
     *out++ = *it;
   return out;
 }
 
-template <typename OutputIt>
+template <typename OutputIterator>
-auto copy(const char* str, OutputIt out) -> OutputIt {
+OutputIterator copy(const char* str, OutputIterator out) {
   while (*str) *out++ = *str++;
   return out;
 }
 
-template <typename OutputIt> auto copy(char ch, OutputIt out) -> OutputIt {
+template <typename OutputIterator>
+OutputIterator copy(char ch, OutputIterator out) {
   *out++ = ch;
   return out;
 }
 
-template <typename OutputIt> auto copy(wchar_t ch, OutputIt out) -> OutputIt {
+template <typename OutputIterator>
+OutputIterator copy(wchar_t ch, OutputIterator out) {
   *out++ = ch;
   return out;
 }
@@ -67,7 +69,7 @@ template <typename T> class is_map {
   template <typename> static void check(...);
 
  public:
-#ifdef FMT_FORMAT_MAP_AS_LIST  // DEPRECATED!
+#ifdef FMT_FORMAT_MAP_AS_LIST
   static constexpr const bool value = false;
 #else
   static constexpr const bool value =
@@ -80,7 +82,7 @@ template <typename T> class is_set {
   template <typename> static void check(...);
 
  public:
-#ifdef FMT_FORMAT_SET_AS_LIST  // DEPRECATED!
+#ifdef FMT_FORMAT_SET_AS_LIST
   static constexpr const bool value = false;
 #else
   static constexpr const bool value =
@@ -155,9 +157,8 @@ template <typename T>
 struct has_mutable_begin_end<
     T, void_t<decltype(detail::range_begin(std::declval<T>())),
               decltype(detail::range_end(std::declval<T>())),
-              // the extra int here is because older versions of MSVC don't
+              enable_if_t<std::is_copy_constructible<T>::value>>>
-              // SFINAE properly unless there are distinct types
+    : std::true_type {};
-              int>> : std::true_type {};
 
 template <typename T>
 struct is_range_<T, void>
@@ -210,61 +211,41 @@ class is_tuple_formattable_ {
   static constexpr const bool value = false;
 };
 template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
-  template <std::size_t... Is>
+  template <std::size_t... I>
-  static std::true_type check2(index_sequence<Is...>,
+  static std::true_type check2(index_sequence<I...>,
-                               integer_sequence<bool, (Is == Is)...>);
+                               integer_sequence<bool, (I == I)...>);
   static std::false_type check2(...);
-  template <std::size_t... Is>
+  template <std::size_t... I>
   static decltype(check2(
-      index_sequence<Is...>{},
+      index_sequence<I...>{},
       integer_sequence<
-          bool, (is_formattable<typename std::tuple_element<Is, T>::type,
+          bool, (is_formattable<typename std::tuple_element<I, T>::type,
-                                C>::value)...>{})) check(index_sequence<Is...>);
+                                C>::value)...>{})) check(index_sequence<I...>);
 
  public:
   static constexpr const bool value =
       decltype(check(tuple_index_sequence<T>{}))::value;
 };
 
-template <typename Tuple, typename F, size_t... Is>
+template <class Tuple, class F, size_t... Is>
-FMT_CONSTEXPR void for_each(index_sequence<Is...>, Tuple&& t, F&& f) {
+void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) noexcept {
   using std::get;
-  // Using a free function get<Is>(Tuple) now.
+  // using free function get<I>(T) now.
-  const int unused[] = {0, ((void)f(get<Is>(t)), 0)...};
+  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
-  ignore_unused(unused);
+  (void)_;  // blocks warnings
 }
 
-template <typename Tuple, typename F>
+template <class T>
-FMT_CONSTEXPR void for_each(Tuple&& t, F&& f) {
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
-  for_each(tuple_index_sequence<remove_cvref_t<Tuple>>(),
+    T const&) {
-           std::forward<Tuple>(t), std::forward<F>(f));
+  return {};
 }
 
-template <typename Tuple1, typename Tuple2, typename F, size_t... Is>
+template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
-void for_each2(index_sequence<Is...>, Tuple1&& t1, Tuple2&& t2, F&& f) {
+  const auto indexes = get_indexes(tup);
-  using std::get;
+  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
-  const int unused[] = {0, ((void)f(get<Is>(t1), get<Is>(t2)), 0)...};
-  ignore_unused(unused);
 }
 
-template <typename Tuple1, typename Tuple2, typename F>
-void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) {
-  for_each2(tuple_index_sequence<remove_cvref_t<Tuple1>>(),
-            std::forward<Tuple1>(t1), std::forward<Tuple2>(t2),
-            std::forward<F>(f));
-}
-
-namespace tuple {
-// Workaround a bug in MSVC 2019 (v140).
-template <typename Char, typename... T>
-using result_t = std::tuple<formatter<remove_cvref_t<T>, Char>...>;
-
-using std::get;
-template <typename Tuple, typename Char, std::size_t... Is>
-auto get_formatters(index_sequence<Is...>)
-    -> result_t<Char, decltype(get<Is>(std::declval<Tuple>()))...>;
-}  // namespace tuple
-
 #if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920
 // Older MSVC doesn't get the reference type correctly for arrays.
 template <typename R> struct range_reference_type_impl {
@@ -288,37 +269,45 @@ using range_reference_type =
 template <typename Range>
 using uncvref_type = remove_cvref_t<range_reference_type<Range>>;
 
-template <typename Formatter>
+template <typename Range>
-FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)
+using uncvref_first_type =
-    -> decltype(f.set_debug_format(set)) {
+    remove_cvref_t<decltype(std::declval<range_reference_type<Range>>().first)>;
-  f.set_debug_format(set);
+
+template <typename Range>
+using uncvref_second_type = remove_cvref_t<
+    decltype(std::declval<range_reference_type<Range>>().second)>;
+
+template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
+  *out++ = ',';
+  *out++ = ' ';
+  return out;
 }
-template <typename Formatter>
-FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}
 
-// These are not generic lambdas for compatibility with C++11.
+template <typename Char, typename OutputIt>
-template <typename ParseContext> struct parse_empty_specs {
+auto write_range_entry(OutputIt out, basic_string_view<Char> str) -> OutputIt {
-  template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) {
+  return write_escaped_string(out, str);
-    f.parse(ctx);
+}
-    detail::maybe_set_debug_format(f, true);
-  }
-  ParseContext& ctx;
-};
-template <typename FormatContext> struct format_tuple_element {
-  using char_type = typename FormatContext::char_type;
 
-  template <typename T>
+template <typename Char, typename OutputIt, typename T,
-  void operator()(const formatter<T, char_type>& f, const T& v) {
+          FMT_ENABLE_IF(std::is_convertible<T, std_string_view<char>>::value)>
-    if (i > 0)
+inline auto write_range_entry(OutputIt out, const T& str) -> OutputIt {
-      ctx.advance_to(detail::copy_str<char_type>(separator, ctx.out()));
+  auto sv = std_string_view<Char>(str);
-    ctx.advance_to(f.format(v, ctx));
+  return write_range_entry<Char>(out, basic_string_view<Char>(sv));
-    ++i;
+}
-  }
 
-  int i;
+template <typename Char, typename OutputIt, typename Arg,
-  FormatContext& ctx;
+          FMT_ENABLE_IF(std::is_same<Arg, Char>::value)>
-  basic_string_view<char_type> separator;
+OutputIt write_range_entry(OutputIt out, const Arg v) {
-};
+  return write_escaped_char(out, v);
+}
+
+template <
+    typename Char, typename OutputIt, typename Arg,
+    FMT_ENABLE_IF(!is_std_string_like<typename std::decay<Arg>::type>::value &&
+                  !std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg& v) {
+  return write<Char>(out, v);
+}
 
 }  // namespace detail
 
@@ -332,20 +321,29 @@ template <typename T, typename C> struct is_tuple_formattable {
       detail::is_tuple_formattable_<T, C>::value;
 };
 
-template <typename Tuple, typename Char>
+template <typename TupleT, typename Char>
-struct formatter<Tuple, Char,
+struct formatter<TupleT, Char,
-                 enable_if_t<fmt::is_tuple_like<Tuple>::value &&
+                 enable_if_t<fmt::is_tuple_like<TupleT>::value &&
-                             fmt::is_tuple_formattable<Tuple, Char>::value>> {
+                             fmt::is_tuple_formattable<TupleT, Char>::value>> {
  private:
-  decltype(detail::tuple::get_formatters<Tuple, Char>(
-      detail::tuple_index_sequence<Tuple>())) formatters_;
-
   basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
   basic_string_view<Char> opening_bracket_ =
       detail::string_literal<Char, '('>{};
   basic_string_view<Char> closing_bracket_ =
       detail::string_literal<Char, ')'>{};
 
+  // C++11 generic lambda for format().
+  template <typename FormatContext> struct format_each {
+    template <typename T> void operator()(const T& v) {
+      if (i > 0) out = detail::copy_str<Char>(separator, out);
+      out = detail::write_range_entry<Char>(out, v);
+      ++i;
+    }
+    int i;
+    typename FormatContext::iterator& out;
+    basic_string_view<Char> separator;
+  };
+
  public:
   FMT_CONSTEXPR formatter() {}
 
@@ -361,21 +359,17 @@ struct formatter<Tuple, Char,
 
   template <typename ParseContext>
   FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    auto it = ctx.begin();
+    return ctx.begin();
-    if (it != ctx.end() && *it != '}')
-      FMT_THROW(format_error("invalid format specifier"));
-    detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
-    return it;
   }
 
-  template <typename FormatContext>
+  template <typename FormatContext = format_context>
-  auto format(const Tuple& value, FormatContext& ctx) const
+  auto format(const TupleT& values, FormatContext& ctx) const
       -> decltype(ctx.out()) {
-    ctx.advance_to(detail::copy_str<Char>(opening_bracket_, ctx.out()));
+    auto out = ctx.out();
-    detail::for_each2(
+    out = detail::copy_str<Char>(opening_bracket_, out);
-        formatters_, value,
+    detail::for_each(values, format_each<FormatContext>{0, out, separator_});
-        detail::format_tuple_element<FormatContext>{0, ctx, separator_});
+    out = detail::copy_str<Char>(closing_bracket_, out);
-    return detail::copy_str<Char>(closing_bracket_, ctx.out());
+    return out;
   }
 };
 
@@ -404,10 +398,12 @@ template <typename Context> struct range_mapper {
 };
 
 template <typename Char, typename Element>
-using range_formatter_type =
+using range_formatter_type = conditional_t<
+    is_formattable<Element, Char>::value,
     formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map(
                   std::declval<Element>()))>,
-              Char>;
+              Char>,
+    fallback_formatter<Element, Char>>;
 
 template <typename R>
 using maybe_const_range =
@@ -417,8 +413,11 @@ using maybe_const_range =
 #if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
 template <typename R, typename Char>
 struct is_formattable_delayed
-    : is_formattable<uncvref_type<maybe_const_range<R>>, Char> {};
+    : disjunction<
+          is_formattable<uncvref_type<maybe_const_range<R>>, Char>,
+          has_fallback_formatter<uncvref_type<maybe_const_range<R>>, Char>> {};
 #endif
+
 }  // namespace detail
 
 template <typename T, typename Char, typename Enable = void>
@@ -427,16 +426,32 @@ struct range_formatter;
 template <typename T, typename Char>
 struct range_formatter<
     T, Char,
-    enable_if_t<conjunction<std::is_same<T, remove_cvref_t<T>>,
+    enable_if_t<conjunction<
-                            is_formattable<T, Char>>::value>> {
+        std::is_same<T, remove_cvref_t<T>>,
+        disjunction<is_formattable<T, Char>,
+                    detail::has_fallback_formatter<T, Char>>>::value>> {
  private:
   detail::range_formatter_type<Char, T> underlying_;
+  bool custom_specs_ = false;
   basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
   basic_string_view<Char> opening_bracket_ =
       detail::string_literal<Char, '['>{};
   basic_string_view<Char> closing_bracket_ =
       detail::string_literal<Char, ']'>{};
 
+  template <class U>
+  FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, int)
+      -> decltype(u.set_debug_format()) {
+    u.set_debug_format();
+  }
+
+  template <class U>
+  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
+
+  FMT_CONSTEXPR void maybe_set_debug_format() {
+    maybe_set_debug_format(underlying_, 0);
+  }
+
  public:
   FMT_CONSTEXPR range_formatter() {}
 
@@ -458,24 +473,31 @@ struct range_formatter<
   FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     auto it = ctx.begin();
     auto end = ctx.end();
+    if (it == end || *it == '}') {
+      maybe_set_debug_format();
+      return it;
+    }
 
-    if (it != end && *it == 'n') {
+    if (*it == 'n') {
       set_brackets({}, {});
       ++it;
     }
 
-    if (it != end && *it != '}') {
+    if (*it == '}') {
-      if (*it != ':') FMT_THROW(format_error("invalid format specifier"));
+      maybe_set_debug_format();
-      ++it;
+      return it;
-    } else {
-      detail::maybe_set_debug_format(underlying_, true);
     }
 
+    if (*it != ':')
+      FMT_THROW(format_error("no other top-level range formatters supported"));
+
+    custom_specs_ = true;
+    ++it;
     ctx.advance_to(it);
     return underlying_.parse(ctx);
   }
 
-  template <typename R, typename FormatContext>
+  template <typename R, class FormatContext>
   auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
     detail::range_mapper<buffer_context<Char>> mapper;
     auto out = ctx.out();
@@ -485,6 +507,7 @@ struct range_formatter<
     auto end = detail::range_end(range);
     for (; it != end; ++it) {
       if (i > 0) out = detail::copy_str<Char>(separator_, out);
+      ;
       ctx.advance_to(out);
       out = underlying_.format(mapper.map(*it), ctx);
       ++i;
@@ -497,14 +520,13 @@ struct range_formatter<
 enum class range_format { disabled, map, set, sequence, string, debug_string };
 
 namespace detail {
-template <typename T>
+template <typename T> struct range_format_kind_ {
-struct range_format_kind_
+  static constexpr auto value = std::is_same<range_reference_type<T>, T>::value
-    : std::integral_constant<range_format,
-                             std::is_same<uncvref_type<T>, T>::value
                                     ? range_format::disabled
                                 : is_map<T>::value ? range_format::map
                                 : is_set<T>::value ? range_format::set
-                                                : range_format::sequence> {};
+                                                   : range_format::sequence;
+};
 
 template <range_format K, typename R, typename Char, typename Enable = void>
 struct range_default_formatter;
@@ -579,6 +601,9 @@ template <typename Char, typename... T> struct tuple_join_view : detail::view {
       : tuple(t), sep{s} {}
 };
 
+template <typename Char, typename... T>
+using tuple_arg_join = tuple_join_view<Char, T...>;
+
 // Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers
 // support in tuple_join. It is disabled by default because of issues with
 // the dynamic width and precision.
@@ -648,42 +673,7 @@ struct formatter<tuple_join_view<Char, T...>, Char> {
   }
 };
 
-namespace detail {
+FMT_MODULE_EXPORT_BEGIN
-// Check if T has an interface like a container adaptor (e.g. std::stack,
-// std::queue, std::priority_queue).
-template <typename T> class is_container_adaptor_like {
-  template <typename U> static auto check(U* p) -> typename U::container_type;
-  template <typename> static void check(...);
-
- public:
-  static constexpr const bool value =
-      !std::is_void<decltype(check<T>(nullptr))>::value;
-};
-
-template <typename Container> struct all {
-  const Container& c;
-  auto begin() const -> typename Container::const_iterator { return c.begin(); }
-  auto end() const -> typename Container::const_iterator { return c.end(); }
-};
-}  // namespace detail
-
-template <typename T, typename Char>
-struct formatter<T, Char,
-                 enable_if_t<detail::is_container_adaptor_like<T>::value>>
-    : formatter<detail::all<typename T::container_type>, Char> {
-  using all = detail::all<typename T::container_type>;
-  template <typename FormatContext>
-  auto format(const T& t, FormatContext& ctx) const -> decltype(ctx.out()) {
-    struct getter : T {
-      static auto get(const T& t) -> all {
-        return {t.*(&getter::c)};  // Access c through the derived class.
-      }
-    };
-    return formatter<all>::format(getter::get(t), ctx);
-  }
-};
-
-FMT_BEGIN_EXPORT
 
 /**
   \rst
@@ -726,7 +716,7 @@ auto join(std::initializer_list<T> list, string_view sep)
   return join(std::begin(list), std::end(list), sep);
 }
 
-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_RANGES_H_

include/spdlog/fmt/bundled/std.h

@@ -8,12 +8,8 @@
 #ifndef FMT_STD_H_
 #define FMT_STD_H_
 
-#include <cstdlib>
-#include <exception>
-#include <memory>
 #include <thread>
 #include <type_traits>
-#include <typeinfo>
 #include <utility>
 
 #include "ostream.h"
@@ -29,19 +25,6 @@
 #  if FMT_HAS_INCLUDE(<variant>)
 #    include <variant>
 #  endif
-#  if FMT_HAS_INCLUDE(<optional>)
-#    include <optional>
-#  endif
-#endif
-
-// GCC 4 does not support FMT_HAS_INCLUDE.
-#if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
-#  include <cxxabi.h>
-// Android NDK with gabi++ library on some architectures does not implement
-// abi::__cxa_demangle().
-#  ifndef __GABIXX_CXXABI_H__
-#    define FMT_HAS_ABI_CXA_DEMANGLE
-#  endif
 #endif
 
 #ifdef __cpp_lib_filesystem
@@ -56,13 +39,12 @@ void write_escaped_path(basic_memory_buffer<Char>& quoted,
 }
 #  ifdef _WIN32
 template <>
-inline void write_escaped_path<char>(memory_buffer& quoted,
+inline void write_escaped_path<char>(basic_memory_buffer<char>& quoted,
                                      const std::filesystem::path& p) {
-  auto buf = basic_memory_buffer<wchar_t>();
+  auto s = p.u8string();
-  write_escaped_string<wchar_t>(std::back_inserter(buf), p.native());
+  write_escaped_string<char>(
-  // Convert UTF-16 to UTF-8.
+      std::back_inserter(quoted),
-  if (!unicode_to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()}))
+      string_view(reinterpret_cast<const char*>(s.c_str()), s.size()));
-    FMT_THROW(std::runtime_error("invalid utf16"));
 }
 #  endif
 template <>
@@ -75,19 +57,13 @@ inline void write_escaped_path<std::filesystem::path::value_type>(
 
 }  // namespace detail
 
-FMT_MODULE_EXPORT
 template <typename Char>
 struct formatter<std::filesystem::path, Char>
     : formatter<basic_string_view<Char>> {
-  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
-    auto out = formatter<basic_string_view<Char>>::parse(ctx);
-    this->set_debug_format(false);
-    return out;
-  }
   template <typename FormatContext>
   auto format(const std::filesystem::path& p, FormatContext& ctx) const ->
       typename FormatContext::iterator {
-    auto quoted = basic_memory_buffer<Char>();
+    basic_memory_buffer<Char> quoted;
     detail::write_escaped_path(quoted, p);
     return formatter<basic_string_view<Char>>::format(
         basic_string_view<Char>(quoted.data(), quoted.size()), ctx);
@@ -97,58 +73,12 @@ FMT_END_NAMESPACE
 #endif
 
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT
 template <typename Char>
 struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
 FMT_END_NAMESPACE
 
-#ifdef __cpp_lib_optional
-FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT
-template <typename T, typename Char>
-struct formatter<std::optional<T>, Char,
-                 std::enable_if_t<is_formattable<T, Char>::value>> {
- private:
-  formatter<T, Char> underlying_;
-  static constexpr basic_string_view<Char> optional =
-      detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
-                             '('>{};
-  static constexpr basic_string_view<Char> none =
-      detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};
-
-  template <class U>
-  FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set)
-      -> decltype(u.set_debug_format(set)) {
-    u.set_debug_format(set);
-  }
-
-  template <class U>
-  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
-
- public:
-  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
-    maybe_set_debug_format(underlying_, true);
-    return underlying_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(std::optional<T> const& opt, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    if (!opt) return detail::write<Char>(ctx.out(), none);
-
-    auto out = ctx.out();
-    out = detail::write<Char>(out, optional);
-    ctx.advance_to(out);
-    out = underlying_.format(*opt, ctx);
-    return detail::write(out, ')');
-  }
-};
-FMT_END_NAMESPACE
-#endif  // __cpp_lib_optional
-
 #ifdef __cpp_lib_variant
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT
 template <typename Char> struct formatter<std::monostate, Char> {
   template <typename ParseContext>
   FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
@@ -170,16 +100,19 @@ template <typename T>
 using variant_index_sequence =
     std::make_index_sequence<std::variant_size<T>::value>;
 
-template <typename> struct is_variant_like_ : std::false_type {};
+// variant_size and variant_alternative check.
-template <typename... Types>
+template <typename T, typename U = void>
-struct is_variant_like_<std::variant<Types...>> : std::true_type {};
+struct is_variant_like_ : std::false_type {};
+template <typename T>
+struct is_variant_like_<T, std::void_t<decltype(std::variant_size<T>::value)>>
+    : std::true_type {};
 
-// formattable element check.
+// formattable element check
 template <typename T, typename C> class is_variant_formattable_ {
-  template <std::size_t... Is>
+  template <std::size_t... I>
   static std::conjunction<
-      is_formattable<std::variant_alternative_t<Is, T>, C>...>
+      is_formattable<std::variant_alternative_t<I, T>, C>...>
-      check(std::index_sequence<Is...>);
+      check(std::index_sequence<I...>);
 
  public:
   static constexpr const bool value =
@@ -197,6 +130,7 @@ auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt {
 }
 
 }  // namespace detail
+
 template <typename T> struct is_variant_like {
   static constexpr const bool value = detail::is_variant_like_<T>::value;
 };
@@ -206,7 +140,6 @@ template <typename T, typename C> struct is_variant_formattable {
       detail::is_variant_formattable_<T, C>::value;
 };
 
-FMT_MODULE_EXPORT
 template <typename Variant, typename Char>
 struct formatter<
     Variant, Char,
@@ -223,127 +156,16 @@ struct formatter<
     auto out = ctx.out();
 
     out = detail::write<Char>(out, "variant(");
-    try {
     std::visit(
         [&](const auto& v) {
           out = detail::write_variant_alternative<Char>(out, v);
         },
         value);
-    } catch (const std::bad_variant_access&) {
-      detail::write<Char>(out, "valueless by exception");
-    }
     *out++ = ')';
     return out;
   }
 };
 FMT_END_NAMESPACE
-#endif  // __cpp_lib_variant
-
-FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT
-template <typename Char> struct formatter<std::error_code, Char> {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    out = detail::write_bytes(out, ec.category().name(), format_specs<Char>());
-    out = detail::write<Char>(out, Char(':'));
-    out = detail::write<Char>(out, ec.value());
-    return out;
-  }
-};
-
-FMT_MODULE_EXPORT
-template <typename T, typename Char>
-struct formatter<
-    T, Char,
-    typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
- private:
-  bool with_typename_ = false;
-
- public:
-  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-      -> decltype(ctx.begin()) {
-    auto it = ctx.begin();
-    auto end = ctx.end();
-    if (it == end || *it == '}') return it;
-    if (*it == 't') {
-      ++it;
-      with_typename_ = true;
-    }
-    return it;
-  }
-
-  template <typename OutputIt>
-  auto format(const std::exception& ex,
-              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
-    format_specs<Char> spec;
-    auto out = ctx.out();
-    if (!with_typename_)
-      return detail::write_bytes(out, string_view(ex.what()), spec);
-
-    const std::type_info& ti = typeid(ex);
-#ifdef FMT_HAS_ABI_CXA_DEMANGLE
-    int status = 0;
-    std::size_t size = 0;
-    std::unique_ptr<char, decltype(&std::free)> demangled_name_ptr(
-        abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
-
-    string_view demangled_name_view;
-    if (demangled_name_ptr) {
-      demangled_name_view = demangled_name_ptr.get();
-
-      // Normalization of stdlib inline namespace names.
-      // libc++ inline namespaces.
-      //  std::__1::*       -> std::*
-      //  std::__1::__fs::* -> std::*
-      // libstdc++ inline namespaces.
-      //  std::__cxx11::*             -> std::*
-      //  std::filesystem::__cxx11::* -> std::filesystem::*
-      if (demangled_name_view.starts_with("std::")) {
-        char* begin = demangled_name_ptr.get();
-        char* to = begin + 5;  // std::
-        for (char *from = to, *end = begin + demangled_name_view.size();
-             from < end;) {
-          // This is safe, because demangled_name is NUL-terminated.
-          if (from[0] == '_' && from[1] == '_') {
-            char* next = from + 1;
-            while (next < end && *next != ':') next++;
-            if (next[0] == ':' && next[1] == ':') {
-              from = next + 2;
-              continue;
-            }
-          }
-          *to++ = *from++;
-        }
-        demangled_name_view = {begin, detail::to_unsigned(to - begin)};
-      }
-    } else {
-      demangled_name_view = string_view(ti.name());
-    }
-    out = detail::write_bytes(out, demangled_name_view, spec);
-#elif FMT_MSC_VERSION
-    string_view demangled_name_view(ti.name());
-    if (demangled_name_view.starts_with("class "))
-      demangled_name_view.remove_prefix(6);
-    else if (demangled_name_view.starts_with("struct "))
-      demangled_name_view.remove_prefix(7);
-    out = detail::write_bytes(out, demangled_name_view, spec);
-#else
-    out = detail::write_bytes(out, string_view(ti.name()), spec);
 #endif
-    out = detail::write<Char>(out, Char(':'));
-    out = detail::write<Char>(out, Char(' '));
-    out = detail::write_bytes(out, string_view(ex.what()), spec);
-
-    return out;
-  }
-};
-FMT_END_NAMESPACE
 
 #endif  // FMT_STD_H_

include/spdlog/fmt/bundled/xchar.h

@@ -12,32 +12,13 @@
 
 #include "format.h"
 
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-#  include <locale>
-#endif
-
 FMT_BEGIN_NAMESPACE
 namespace detail {
-
 template <typename T>
 using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
-
-inline auto write_loc(std::back_insert_iterator<detail::buffer<wchar_t>> out,
-                      loc_value value, const format_specs<wchar_t>& specs,
-                      locale_ref loc) -> bool {
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-  auto& numpunct =
-      std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
-  auto separator = std::wstring();
-  auto grouping = numpunct.grouping();
-  if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep());
-  return value.visit(loc_writer<wchar_t>{out, specs, separator, grouping, {}});
-#endif
-  return false;
 }
-}  // namespace detail
 
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN
 
 using wstring_view = basic_string_view<wchar_t>;
 using wformat_parse_context = basic_format_parse_context<wchar_t>;
@@ -52,9 +33,7 @@ inline auto runtime(wstring_view s) -> wstring_view { return s; }
 #else
 template <typename... Args>
 using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
-inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
+inline auto runtime(wstring_view s) -> basic_runtime<wchar_t> { return {{s}}; }
-  return {{s}};
-}
 #endif
 
 template <> struct is_char<wchar_t> : std::true_type {};
@@ -147,7 +126,7 @@ auto vformat_to(OutputIt out, const S& format_str,
     -> OutputIt {
   auto&& buf = detail::get_buffer<Char>(out);
   detail::vformat_to(buf, detail::to_string_view(format_str), args);
-  return detail::get_iterator(buf, out);
+  return detail::get_iterator(buf);
 }
 
 template <typename OutputIt, typename S, typename... Args,
@@ -170,7 +149,7 @@ inline auto vformat_to(
   auto&& buf = detail::get_buffer<Char>(out);
   vformat_to(buf, detail::to_string_view(format_str), args,
              detail::locale_ref(loc));
-  return detail::get_iterator(buf, out);
+  return detail::get_iterator(buf);
 }
 
 template <
@@ -181,7 +160,7 @@ template <
 inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
                       Args&&... args) ->
     typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, loc, detail::to_string_view(format_str),
+  return vformat_to(out, loc, to_string_view(format_str),
                     fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
@@ -238,22 +217,13 @@ template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
   return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
 }
 
-template <typename... T>
-void println(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
-  return print(f, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
-}
-
-template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
-  return print(L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
-}
-
 /**
   Converts *value* to ``std::wstring`` using the default format for type *T*.
  */
 template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
   return format(FMT_STRING(L"{}"), value);
 }
-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_XCHAR_H_

include/spdlog/fmt/fmt.h

@@ -16,6 +16,13 @@
 #    if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY)
 #        define FMT_HEADER_ONLY
 #    endif
+#    ifndef FMT_USE_WINDOWS_H
+#        define FMT_USE_WINDOWS_H 0
+#    endif
+// enable the 'n' flag in for backward compatibility with fmt 6.x
+#    define FMT_DEPRECATED_N_SPECIFIER
+// enable ostream formatting for backward compatibility with fmt 8.x
+#    define FMT_DEPRECATED_OSTREAM
 
 #    include <spdlog/fmt/bundled/core.h>
 #    include <spdlog/fmt/bundled/format.h>

src/bundled_fmtlib_format.cpp

@@ -9,13 +9,14 @@
 #if !defined(SPDLOG_FMT_EXTERNAL) && !defined(SPDLOG_USE_STD_FORMAT)
 
 #include <spdlog/fmt/bundled/format-inl.h>
+
 FMT_BEGIN_NAMESPACE
 namespace detail {
 
 template FMT_API auto dragonbox::to_decimal(float x) noexcept
--> dragonbox::decimal_fp<float>;
+    -> dragonbox::decimal_fp<float>;
 template FMT_API auto dragonbox::to_decimal(double x) noexcept
--> dragonbox::decimal_fp<double>;
+    -> dragonbox::decimal_fp<double>;
 
 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
 template FMT_API locale_ref::locale_ref(const std::locale& loc);
@@ -25,18 +26,22 @@ template FMT_API auto locale_ref::get<std::locale>() const -> std::locale;
 // Explicit instantiations for char.
 
 template FMT_API auto thousands_sep_impl(locale_ref)
--> thousands_sep_result<char>;
+    -> thousands_sep_result<char>;
 template FMT_API auto decimal_point_impl(locale_ref) -> char;
 
 template FMT_API void buffer<char>::append(const char*, const char*);
 
+// DEPRECATED!
+// There is no correspondent extern template in format.h because of
+// incompatibility between clang and gcc (#2377).
 template FMT_API void vformat_to(buffer<char>&, string_view,
-                                 typename vformat_args<>::type, locale_ref);
+    basic_format_args<FMT_BUFFER_CONTEXT(char)>,
+    locale_ref);
 
 // Explicit instantiations for wchar_t.
 
 template FMT_API auto thousands_sep_impl(locale_ref)
--> thousands_sep_result<wchar_t>;
+    -> thousands_sep_result<wchar_t>;
 template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
 
 template FMT_API void buffer<wchar_t>::append(const wchar_t*, const wchar_t*);