cpp/openttd-patchpack/source Changeset - r28571:f38bdbf45090

Changeset - r28571:f38bdbf45090

Parent rev.

Child rev.

[Not reviewed]

master

0 7 0

Rubidium - 9 months ago 2024-01-26 17:13:55
rubidium@openttd.org

Update: fmt to 10.2.0

7 files changed with 1372 insertions and 1359 deletions:

src/3rdparty/fmt/chrono.h

226

253

src/3rdparty/fmt/core.h

327

308

src/3rdparty/fmt/format-inl.h

src/3rdparty/fmt/format.h

397

598

src/3rdparty/fmt/ostream.h

src/3rdparty/fmt/ranges.h

src/3rdparty/fmt/std.h

245

0 comments (0 inline, 0 general)

src/3rdparty/fmt/chrono.h

➞

Show inline comments

@@ @@ -18,7 +18,7 @@ @@
 #include <ostream>
 #include <type_traits>
-#include "format.h"
+#include "ostream.h"  // formatbuf
 FMT_BEGIN_NAMESPACE
@@ @@ -72,7 +72,8 @@ template <typename To, typename From, @@
           FMT_ENABLE_IF(!std::is_same<From, To>::value &&
                         std::numeric_limits<From>::is_signed ==
                             std::numeric_limits<To>::is_signed)>
 FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
 FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
     -> To {
   ec = 0;
   using F = std::numeric_limits<From>;
   using T = std::numeric_limits<To>;
@@ @@ -101,7 +102,8 @@ template <typename To, typename From, @@
           FMT_ENABLE_IF(!std::is_same<From, To>::value &&
                         std::numeric_limits<From>::is_signed !=
                             std::numeric_limits<To>::is_signed)>
 FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
 FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
     -> To {
   ec = 0;
   using F = std::numeric_limits<From>;
   using T = std::numeric_limits<To>;
@@ @@ -133,7 +135,8 @@ FMT_CONSTEXPR To lossless_integral_conve @@
 template <typename To, typename From,
           FMT_ENABLE_IF(std::is_same<From, To>::value)>
 FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
 FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
     -> To {
   ec = 0;
   return from;
 }  // function
@@ @@ -154,7 +157,7 @@ FMT_CONSTEXPR To lossless_integral_conve @@
 // clang-format on
 template <typename To, typename From,
           FMT_ENABLE_IF(!std::is_same<From, To>::value)>
-FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
+FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {
   ec = 0;
   using T = std::numeric_limits<To>;
   static_assert(std::is_floating_point<From>::value, "From must be floating");
@@ @@ -176,7 +179,7 @@ FMT_CONSTEXPR To safe_float_conversion(c @@
 template <typename To, typename From,
           FMT_ENABLE_IF(std::is_same<From, To>::value)>
-FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
+FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {
   ec = 0;
   static_assert(std::is_floating_point<From>::value, "From must be floating");
   return from;
@@ @@ -188,8 +191,8 @@ FMT_CONSTEXPR To safe_float_conversion(c @@
 template <typename To, typename FromRep, typename FromPeriod,
           FMT_ENABLE_IF(std::is_integral<FromRep>::value),
           FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>
 To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
                       int& ec) {
 auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
                         int& ec) -> To {
   using From = std::chrono::duration<FromRep, FromPeriod>;
   ec = 0;
   // the basic idea is that we need to convert from count() in the from type
@@ @@ -240,8 +243,8 @@ To safe_duration_cast(std::chrono::durat @@
 template <typename To, typename FromRep, typename FromPeriod,
           FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),
           FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
 To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
                       int& ec) {
 auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
                         int& ec) -> To {
   using From = std::chrono::duration<FromRep, FromPeriod>;
   ec = 0;
   if (std::isnan(from.count())) {
@@ @@ -321,12 +324,12 @@ To safe_duration_cast(std::chrono::durat @@
 namespace detail {
 template <typename T = void> struct null {};
 inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }
 inline null<> localtime_s(...) { return null<>(); }
 inline null<> gmtime_r(...) { return null<>(); }
 inline null<> gmtime_s(...) { return null<>(); }
 inline auto localtime_r FMT_NOMACRO(...) -> null<> { return null<>(); }
 inline auto localtime_s(...) -> null<> { return null<>(); }
 inline auto gmtime_r(...) -> null<> { return null<>(); }
 inline auto gmtime_s(...) -> null<> { return null<>(); }
-inline const std::locale& get_classic_locale() {
+inline auto get_classic_locale() -> const std::locale& {
   static const auto& locale = std::locale::classic();
   return locale;
+}
@@ @@ -336,8 +339,6 @@ template <typename CodeUnit> struct code @@
   CodeUnit buf[max_size];
   CodeUnit* end;
 };
 template <typename CodeUnit>
 constexpr const size_t codecvt_result<CodeUnit>::max_size;
 template <typename CodeUnit>
 void write_codecvt(codecvt_result<CodeUnit>& out, string_view in_buf,
@@ @@ -377,8 +378,8 @@ auto write_encoded_tm_str(OutputIt out, @@
     unit_t unit;
     write_codecvt(unit, in, loc);
     // In UTF-8 is used one to four one-byte code units.
     unicode_to_utf8<code_unit, basic_memory_buffer<char, unit_t::max_size * 4>>
         u;
     auto u =
         to_utf8<code_unit, basic_memory_buffer<char, unit_t::max_size * 4>>();
     if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)}))
       FMT_THROW(format_error("failed to format time"));
     return copy_str<char>(u.c_str(), u.c_str() + u.size(), out);
@@ @@ -408,8 +409,7 @@ inline void do_write(buffer<Char>& buf, @@
   auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
   auto&& os = std::basic_ostream<Char>(&format_buf);
   os.imbue(loc);
   using iterator = std::ostreambuf_iterator<Char>;
   const auto& facet = std::use_facet<std::time_put<Char, iterator>>(loc);
   const auto& facet = std::use_facet<std::time_put<Char>>(loc);
   auto end = facet.put(os, os, Char(' '), &time, format, modifier);
   if (end.failed()) FMT_THROW(format_error("failed to format time"));
+}
@@ @@ -432,6 +432,51 @@ auto write(OutputIt out, const std::tm& @@
   return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc);
+}
 template <typename Rep1, typename Rep2>
 struct is_same_arithmetic_type
     : public std::integral_constant<bool,
                                     (std::is_integral<Rep1>::value &&
                                      std::is_integral<Rep2>::value) ||
                                         (std::is_floating_point<Rep1>::value &&
                                          std::is_floating_point<Rep2>::value)> {
 };
 template <
     typename To, typename FromRep, typename FromPeriod,
     FMT_ENABLE_IF(is_same_arithmetic_type<FromRep, typename To::rep>::value)>
 auto fmt_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {
 #if FMT_SAFE_DURATION_CAST
   // Throwing version of safe_duration_cast is only available for
   // integer to integer or float to float casts.
   int ec;
   To to = safe_duration_cast::safe_duration_cast<To>(from, ec);
   if (ec) FMT_THROW(format_error("cannot format duration"));
   return to;
 #else
   // Standard duration cast, may overflow.
   return std::chrono::duration_cast<To>(from);
 #endif
+}
 template <
     typename To, typename FromRep, typename FromPeriod,
     FMT_ENABLE_IF(!is_same_arithmetic_type<FromRep, typename To::rep>::value)>
 auto fmt_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {
   // Mixed integer <-> float cast is not supported by safe_duration_cast.
   return std::chrono::duration_cast<To>(from);
+}
 template <typename Duration>
 auto to_time_t(
     std::chrono::time_point<std::chrono::system_clock, Duration> time_point)
     -> std::time_t {
   // Cannot use std::chrono::system_clock::to_time_t since this would first
   // require a cast to std::chrono::system_clock::time_point, which could
   // overflow.
   return fmt_duration_cast<std::chrono::duration<std::time_t>>(
              time_point.time_since_epoch())
       .count();
+}
 }  // namespace detail
 FMT_BEGIN_EXPORT
@@ @@ -441,29 +486,29 @@ FMT_BEGIN_EXPORT @@
   expressed in local time. Unlike ``std::localtime``, this function is
   thread-safe on most platforms.
  */
-inline std::tm localtime(std::time_t time) {
+inline auto localtime(std::time_t time) -> std::tm {
   struct dispatcher {
     std::time_t time_;
     std::tm tm_;
     dispatcher(std::time_t t) : time_(t) {}
-    bool run() {
+    auto run() -> bool {
       using namespace fmt::detail;
       return handle(localtime_r(&time_, &tm_));
+    }
-    bool handle(std::tm* tm) { return tm != nullptr; }
+    auto handle(std::tm* tm) -> bool { return tm != nullptr; }
-    bool handle(detail::null<>) {
+    auto handle(detail::null<>) -> bool {
       using namespace fmt::detail;
       return fallback(localtime_s(&tm_, &time_));
+    }
-    bool fallback(int res) { return res == 0; }
+    auto fallback(int res) -> bool { return res == 0; }
 #if !FMT_MSC_VERSION
-    bool fallback(detail::null<>) {
+    auto fallback(detail::null<>) -> bool {
       using namespace fmt::detail;
       std::tm* tm = std::localtime(&time_);
       if (tm) tm_ = *tm;
@@ @@ -480,8 +525,8 @@ inline std::tm localtime(std::time_t tim @@
 #if FMT_USE_LOCAL_TIME
 template <typename Duration>
 inline auto localtime(std::chrono::local_time<Duration> time) -> std::tm {
   return localtime(std::chrono::system_clock::to_time_t(
       std::chrono::current_zone()->to_sys(time)));
   return localtime(
       detail::to_time_t(std::chrono::current_zone()->to_sys(time)));
+}
 #endif
@@ @@ -490,90 +535,49 @@ inline auto localtime(std::chrono::local @@
   expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this
   function is thread-safe on most platforms.
  */
-inline std::tm gmtime(std::time_t time) {
+inline auto gmtime(std::time_t time) -> std::tm {
   struct dispatcher {
     std::time_t time_;
     std::tm tm_;
     dispatcher(std::time_t t) : time_(t) {}
-    bool run() {
+    auto run() -> bool {
       using namespace fmt::detail;
       return handle(gmtime_r(&time_, &tm_));
+    }
-    bool handle(std::tm* tm) { return tm != nullptr; }
+    auto handle(std::tm* tm) -> bool { return tm != nullptr; }
-    bool handle(detail::null<>) {
+    auto handle(detail::null<>) -> bool {
       using namespace fmt::detail;
       return fallback(gmtime_s(&tm_, &time_));
+    }
-    bool fallback(int res) { return res == 0; }
+    auto fallback(int res) -> bool { return res == 0; }
 #if !FMT_MSC_VERSION
-    bool fallback(detail::null<>) {
+    auto fallback(detail::null<>) -> bool {
       std::tm* tm = std::gmtime(&time_);
       if (tm) tm_ = *tm;
       return tm != nullptr;
+    }
 #endif
   };
-  dispatcher gt(time);
+  auto gt = dispatcher(time);
   // Too big time values may be unsupported.
   if (!gt.run()) FMT_THROW(format_error("time_t value out of range"));
   return gt.tm_;
+}
 inline std::tm gmtime(
     std::chrono::time_point<std::chrono::system_clock> time_point) {
   return gmtime(std::chrono::system_clock::to_time_t(time_point));
 template <typename Duration>
 inline auto gmtime(
     std::chrono::time_point<std::chrono::system_clock, Duration> time_point)
     -> std::tm {
   return gmtime(detail::to_time_t(time_point));
+}
 FMT_BEGIN_DETAIL_NAMESPACE
 // DEPRECATED!
 template <typename Char>
 FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end,
                                format_specs<Char>& specs) -> const Char* {
   FMT_ASSERT(begin != end, "");
   auto align = align::none;
   auto p = begin + code_point_length(begin);
   if (end - p <= 0) p = begin;
   for (;;) {
     switch (to_ascii(*p)) {
     case '<':
       align = align::left;
       break;
     case '>':
       align = align::right;
       break;
     case '^':
       align = align::center;
       break;
+    }
     if (align != align::none) {
       if (p != begin) {
         auto c = *begin;
         if (c == '}') return begin;
         if (c == '{') {
           throw_format_error("invalid fill character '{'");
           return begin;
+        }
         specs.fill = {begin, to_unsigned(p - begin)};
         begin = p + 1;
       } else {
         ++begin;
+      }
       break;
     } else if (p == begin) {
       break;
+    }
     p = begin;
+  }
   specs.align = align;
   return begin;
+}
 namespace detail {
 // Writes two-digit numbers a, b and c separated by sep to buf.
 // The method by Pavel Novikov based on
@@ @@ -609,7 +613,8 @@ inline void write_digit2_separated(char* @@
+  }
+}
 template <typename Period> FMT_CONSTEXPR inline const char* get_units() {
 template <typename Period>
 FMT_CONSTEXPR inline auto get_units() -> const char* {
   if (std::is_same<Period, std::atto>::value) return "as";
   if (std::is_same<Period, std::femto>::value) return "fs";
   if (std::is_same<Period, std::pico>::value) return "ps";
@@ @@ -627,8 +632,9 @@ template <typename Period> FMT_CONSTEXPR @@
   if (std::is_same<Period, std::tera>::value) return "Ts";
   if (std::is_same<Period, std::peta>::value) return "Ps";
   if (std::is_same<Period, std::exa>::value) return "Es";
-  if (std::is_same<Period, std::ratio<60>>::value) return "m";
+  if (std::is_same<Period, std::ratio<60>>::value) return "min";
   if (std::is_same<Period, std::ratio<3600>>::value) return "h";
   if (std::is_same<Period, std::ratio<86400>>::value) return "d";
   return nullptr;
+}
@@ @@ -664,9 +670,8 @@ auto write_padding(OutputIt out, pad_typ @@
 // Parses a put_time-like format string and invokes handler actions.
 template <typename Char, typename Handler>
 FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,
                                               const Char* end,
                                               Handler&& handler) {
 FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end,
                                        Handler&& handler) -> const Char* {
   if (begin == end || *begin == '}') return begin;
   if (*begin != '%') FMT_THROW(format_error("invalid format"));
   auto ptr = begin;
@@ @@ -997,25 +1002,25 @@ struct tm_format_checker : null_chrono_s @@
   FMT_CONSTEXPR void on_tz_name() {}
 };
-inline const char* tm_wday_full_name(int wday) {
+inline auto tm_wday_full_name(int wday) -> const char* {
   static constexpr const char* full_name_list[] = {
       "Sunday",   "Monday", "Tuesday", "Wednesday",
       "Thursday", "Friday", "Saturday"};
   return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?";
+}
-inline const char* tm_wday_short_name(int wday) {
+inline auto tm_wday_short_name(int wday) -> const char* {
   static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed",
                                                     "Thu", "Fri", "Sat"};
   return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???";
+}
-inline const char* tm_mon_full_name(int mon) {
+inline auto tm_mon_full_name(int mon) -> const char* {
   static constexpr const char* full_name_list[] = {
       "January", "February", "March",     "April",   "May",      "June",
       "July",    "August",   "September", "October", "November", "December"};
   return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?";
+}
-inline const char* tm_mon_short_name(int mon) {
+inline auto tm_mon_short_name(int mon) -> const char* {
   static constexpr const char* short_name_list[] = {
       "Jan", "Feb", "Mar", "Apr", "May", "Jun",
       "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
@@ @@ -1047,21 +1052,21 @@ inline void tzset_once() { @@
 // Converts value to Int and checks that it's in the range [0, upper).
 template <typename T, typename Int, FMT_ENABLE_IF(std::is_integral<T>::value)>
 inline Int to_nonnegative_int(T value, Int upper) {
   FMT_ASSERT(std::is_unsigned<Int>::value ||
                  (value >= 0 && to_unsigned(value) <= to_unsigned(upper)),
              "invalid value");
   (void)upper;
 inline auto to_nonnegative_int(T value, Int upper) -> Int {
   if (!std::is_unsigned<Int>::value &&
       (value < 0 || to_unsigned(value) > to_unsigned(upper))) {
     FMT_THROW(fmt::format_error("chrono value is out of range"));
+  }
   return static_cast<Int>(value);
+}
 template <typename T, typename Int, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-inline Int to_nonnegative_int(T value, Int upper) {
+inline auto to_nonnegative_int(T value, Int upper) -> Int {
   if (value < 0 || value > static_cast<T>(upper))
     FMT_THROW(format_error("invalid value"));
   return static_cast<Int>(value);
+}
-constexpr long long pow10(std::uint32_t n) {
+constexpr auto pow10(std::uint32_t n) -> long long {
   return n == 0 ? 1 : 10 * pow10(n - 1);
+}
@@ @@ -1095,13 +1100,12 @@ void write_fractional_seconds(OutputIt& @@
                                 std::chrono::seconds::rep>::type,
       std::ratio<1, detail::pow10(num_fractional_digits)>>;
   const auto fractional =
       d - std::chrono::duration_cast<std::chrono::seconds>(d);
   const auto fractional = d - fmt_duration_cast<std::chrono::seconds>(d);
   const auto subseconds =
       std::chrono::treat_as_floating_point<
           typename subsecond_precision::rep>::value
           ? fractional.count()
-          : std::chrono::duration_cast<subsecond_precision>(fractional).count();
+          : fmt_duration_cast<subsecond_precision>(fractional).count();
   auto n = static_cast<uint32_or_64_or_128_t<long long>>(subseconds);
   const int num_digits = detail::count_digits(n);
@@ @@ -1152,7 +1156,7 @@ void write_floating_seconds(memory_buffe @@
       num_fractional_digits = 6;
+  }
   format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"),
+  fmt::format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"),
             std::fmod(val * static_cast<rep>(Duration::period::num) /
                           static_cast<rep>(Duration::period::den),
                       static_cast<rep>(60)),
@@ @@ -1217,8 +1221,7 @@ class tm_writer { @@
     return static_cast<int>(l);
+  }
   // Algorithm:
   // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_the_week_number_from_a_month_and_day_of_the_month_or_ordinal_date
   // Algorithm: https://en.wikipedia.org/wiki/ISO_week_date.
   auto iso_year_weeks(long long curr_year) const noexcept -> int {
     const auto prev_year = curr_year - 1;
     const auto curr_p =
@@ @@ -1358,7 +1361,7 @@ class tm_writer { @@
         subsecs_(subsecs),
         tm_(tm) {}
-  OutputIt out() const { return out_; }
+  auto out() const -> OutputIt { return out_; }
   FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {
     out_ = copy_str<Char>(begin, end, out_);
@@ @@ -1622,6 +1625,7 @@ struct chrono_format_checker : null_chro @@
   template <typename Char>
   FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
   FMT_CONSTEXPR void on_day_of_year() {}
   FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {}
   FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {}
   FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {}
@@ @@ -1640,16 +1644,16 @@ struct chrono_format_checker : null_chro @@
 template <typename T,
           FMT_ENABLE_IF(std::is_integral<T>::value&& has_isfinite<T>::value)>
-inline bool isfinite(T) {
+inline auto isfinite(T) -> bool {
   return true;
+}
 template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline T mod(T x, int y) {
+inline auto mod(T x, int y) -> T {
   return x % static_cast<T>(y);
+}
 template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-inline T mod(T x, int y) {
+inline auto mod(T x, int y) -> T {
   return std::fmod(x, static_cast<T>(y));
+}
@@ @@ -1664,49 +1668,38 @@ template <typename T> struct make_unsign @@
   using type = typename std::make_unsigned<T>::type;
 };
 #if FMT_SAFE_DURATION_CAST
 // throwing version of safe_duration_cast
 template <typename To, typename FromRep, typename FromPeriod>
 To fmt_safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) {
   int ec;
   To to = safe_duration_cast::safe_duration_cast<To>(from, ec);
   if (ec) FMT_THROW(format_error("cannot format duration"));
   return to;
+}
 #endif
 template <typename Rep, typename Period,
           FMT_ENABLE_IF(std::is_integral<Rep>::value)>
 inline std::chrono::duration<Rep, std::milli> get_milliseconds(
     std::chrono::duration<Rep, Period> d) {
 inline auto get_milliseconds(std::chrono::duration<Rep, Period> d)
     -> std::chrono::duration<Rep, std::milli> {
   // this may overflow and/or the result may not fit in the
   // target type.
 #if FMT_SAFE_DURATION_CAST
   using CommonSecondsType =
       typename std::common_type<decltype(d), std::chrono::seconds>::type;
-  const auto d_as_common = fmt_safe_duration_cast<CommonSecondsType>(d);
+  const auto d_as_common = fmt_duration_cast<CommonSecondsType>(d);
   const auto d_as_whole_seconds =
-      fmt_safe_duration_cast<std::chrono::seconds>(d_as_common);
+      fmt_duration_cast<std::chrono::seconds>(d_as_common);
   // this conversion should be nonproblematic
   const auto diff = d_as_common - d_as_whole_seconds;
   const auto ms =
-      fmt_safe_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
+      fmt_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
   return ms;
 #else
   auto s = std::chrono::duration_cast<std::chrono::seconds>(d);
   return std::chrono::duration_cast<std::chrono::milliseconds>(d - s);
   auto s = fmt_duration_cast<std::chrono::seconds>(d);
   return fmt_duration_cast<std::chrono::milliseconds>(d - s);
 #endif
+}
 template <typename Char, typename Rep, typename OutputIt,
           FMT_ENABLE_IF(std::is_integral<Rep>::value)>
-OutputIt format_duration_value(OutputIt out, Rep val, int) {
+auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt {
   return write<Char>(out, val);
+}
 template <typename Char, typename Rep, typename OutputIt,
           FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
-OutputIt format_duration_value(OutputIt out, Rep val, int precision) {
+auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt {
   auto specs = format_specs<Char>();
   specs.precision = precision;
   specs.type = precision >= 0 ? presentation_type::fixed_lower
@@ @@ -1715,12 +1708,12 @@ OutputIt format_duration_value(OutputIt @@
+}
 template <typename Char, typename OutputIt>
-OutputIt copy_unit(string_view unit, OutputIt out, Char) {
+auto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt {
   return std::copy(unit.begin(), unit.end(), out);
+}
 template <typename OutputIt>
-OutputIt copy_unit(string_view unit, OutputIt out, wchar_t) {
+auto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt {
   // This works when wchar_t is UTF-32 because units only contain characters
   // that have the same representation in UTF-16 and UTF-32.
   utf8_to_utf16 u(unit);
@@ @@ -1728,7 +1721,7 @@ OutputIt copy_unit(string_view unit, Out @@
+}
 template <typename Char, typename Period, typename OutputIt>
-OutputIt format_duration_unit(OutputIt out) {
+auto format_duration_unit(OutputIt out) -> OutputIt {
   if (const char* unit = get_units<Period>())
     return copy_unit(string_view(unit), out, Char());
   *out++ = '[';
@@ @@ -1795,18 +1788,12 @@ struct chrono_formatter { @@
     // this may overflow and/or the result may not fit in the
     // target type.
 #if FMT_SAFE_DURATION_CAST
     // might need checked conversion (rep!=Rep)
     auto tmpval = std::chrono::duration<rep, Period>(val);
     s = fmt_safe_duration_cast<seconds>(tmpval);
 #else
     s = std::chrono::duration_cast<seconds>(
         std::chrono::duration<rep, Period>(val));
 #endif
     s = fmt_duration_cast<seconds>(std::chrono::duration<rep, Period>(val));
+  }
   // returns true if nan or inf, writes to out.
-  bool handle_nan_inf() {
+  auto handle_nan_inf() -> bool {
     if (isfinite(val)) {
       return false;
+    }
@@ @@ -1823,17 +1810,22 @@ struct chrono_formatter { @@
     return true;
+  }
   Rep hour() const { return static_cast<Rep>(mod((s.count() / 3600), 24)); }
   auto days() const -> Rep { return static_cast<Rep>(s.count() / 86400); }
   auto hour() const -> Rep {
     return static_cast<Rep>(mod((s.count() / 3600), 24));
+  }
-  Rep hour12() const {
+  auto hour12() const -> Rep {
     Rep hour = static_cast<Rep>(mod((s.count() / 3600), 12));
     return hour <= 0 ? 12 : hour;
+  }
   Rep minute() const { return static_cast<Rep>(mod((s.count() / 60), 60)); }
   Rep second() const { return static_cast<Rep>(mod(s.count(), 60)); }
   auto minute() const -> Rep {
     return static_cast<Rep>(mod((s.count() / 60), 60));
+  }
   auto second() const -> Rep { return static_cast<Rep>(mod(s.count(), 60)); }
-  std::tm time() const {
+  auto time() const -> std::tm {
     auto time = std::tm();
     time.tm_hour = to_nonnegative_int(hour(), 24);
     time.tm_min = to_nonnegative_int(minute(), 60);
@@ @@ -1901,10 +1893,14 @@ struct chrono_formatter { @@
   void on_dec0_week_of_year(numeric_system) {}
   void on_dec1_week_of_year(numeric_system) {}
   void on_iso_week_of_year(numeric_system) {}
   void on_day_of_year() {}
   void on_day_of_month(numeric_system) {}
   void on_day_of_month_space(numeric_system) {}
   void on_day_of_year() {
     if (handle_nan_inf()) return;
     write(days(), 0);
+  }
   void on_24_hour(numeric_system ns, pad_type pad) {
     if (handle_nan_inf()) return;
@@ @@ -1997,7 +1993,7 @@ struct chrono_formatter { @@
+  }
 };
-FMT_END_DETAIL_NAMESPACE
+}  // namespace detail
 #if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907
 using weekday = std::chrono::weekday;
@@ @@ -2011,7 +2007,7 @@ class weekday { @@
   weekday() = default;
   explicit constexpr weekday(unsigned wd) noexcept
       : value(static_cast<unsigned char>(wd != 7 ? wd : 0)) {}
-  constexpr unsigned c_encoding() const noexcept { return value; }
+  constexpr auto c_encoding() const noexcept -> unsigned { return value; }
 };
 class year_month_day {};
@@ @@ -2047,80 +2043,67 @@ template <typename Char> struct formatte @@
 template <typename Rep, typename Period, typename Char>
 struct formatter<std::chrono::duration<Rep, Period>, Char> {
  private:
   format_specs<Char> specs;
   int precision = -1;
   using arg_ref_type = detail::arg_ref<Char>;
   arg_ref_type width_ref;
   arg_ref_type precision_ref;
   bool localized = false;
   basic_string_view<Char> format_str;
   using duration = std::chrono::duration<Rep, Period>;
   using iterator = typename basic_format_parse_context<Char>::iterator;
   struct parse_range {
     iterator begin;
     iterator end;
   };
   FMT_CONSTEXPR parse_range do_parse(basic_format_parse_context<Char>& ctx) {
     auto begin = ctx.begin(), end = ctx.end();
     if (begin == end || *begin == '}') return {begin, begin};
     begin = detail::parse_align(begin, end, specs);
     if (begin == end) return {begin, begin};
     begin = detail::parse_dynamic_spec(begin, end, specs.width, width_ref, ctx);
     if (begin == end) return {begin, begin};
     auto checker = detail::chrono_format_checker();
     if (*begin == '.') {
       checker.has_precision_integral = !std::is_floating_point<Rep>::value;
       begin =
           detail::parse_precision(begin, end, precision, precision_ref, ctx);
+    }
     if (begin != end && *begin == 'L') {
       ++begin;
       localized = true;
+    }
     end = detail::parse_chrono_format(begin, end, checker);
     return {begin, end};
+  }
   format_specs<Char> specs_;
   detail::arg_ref<Char> width_ref_;
   detail::arg_ref<Char> precision_ref_;
   bool localized_ = false;
   basic_string_view<Char> format_str_;
  public:
   FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
       -> decltype(ctx.begin()) {
     auto range = do_parse(ctx);
     format_str = basic_string_view<Char>(
         &*range.begin, detail::to_unsigned(range.end - range.begin));
     return range.end;
     auto it = ctx.begin(), end = ctx.end();
     if (it == end || *it == '}') return it;
     it = detail::parse_align(it, end, specs_);
     if (it == end) return it;
     it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
     if (it == end) return it;
     auto checker = detail::chrono_format_checker();
     if (*it == '.') {
       checker.has_precision_integral = !std::is_floating_point<Rep>::value;
       it = detail::parse_precision(it, end, specs_.precision, precision_ref_,
                                    ctx);
+    }
     if (it != end && *it == 'L') {
       localized_ = true;
       ++it;
+    }
     end = detail::parse_chrono_format(it, end, checker);
     format_str_ = {it, detail::to_unsigned(end - it)};
     return end;
+  }
   template <typename FormatContext>
-  auto format(const duration& d, FormatContext& ctx) const
+  auto format(std::chrono::duration<Rep, Period> d, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     auto specs_copy = specs;
     auto precision_copy = precision;
     auto begin = format_str.begin(), end = format_str.end();
     auto specs = specs_;
     auto precision = specs.precision;
     specs.precision = -1;
     auto begin = format_str_.begin(), end = format_str_.end();
     // As a possible future optimization, we could avoid extra copying if width
     // is not specified.
-    basic_memory_buffer<Char> buf;
+    auto buf = basic_memory_buffer<Char>();
     auto out = std::back_inserter(buf);
     detail::handle_dynamic_spec<detail::width_checker>(specs_copy.width,
                                                        width_ref, ctx);
     detail::handle_dynamic_spec<detail::precision_checker>(precision_copy,
                                                            precision_ref, ctx);
     detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
                                                        ctx);
     detail::handle_dynamic_spec<detail::precision_checker>(precision,
                                                            precision_ref_, ctx);
     if (begin == end || *begin == '}') {
-      out = detail::format_duration_value<Char>(out, d.count(), precision_copy);
+      out = detail::format_duration_value<Char>(out, d.count(), precision);
       detail::format_duration_unit<Char, Period>(out);
     } else {
       detail::chrono_formatter<FormatContext, decltype(out), Rep, Period> f(
           ctx, out, d);
       f.precision = precision_copy;
       f.localized = localized;
       using chrono_formatter =
           detail::chrono_formatter<FormatContext, decltype(out), Rep, Period>;
       auto f = chrono_formatter(ctx, out, d);
       f.precision = precision;
       f.localized = localized_;
       detail::parse_chrono_format(begin, end, f);
+    }
     return detail::write(
-        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs_copy);
+        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
+  }
 };
@@ @@ -2128,34 +2111,33 @@ template <typename Char, typename Durati @@
 struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
                  Char> : formatter<std::tm, Char> {
   FMT_CONSTEXPR formatter() {
-    this->format_str = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{};
+    this->format_str_ = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{};
+  }
   template <typename FormatContext>
   auto format(std::chrono::time_point<std::chrono::system_clock, Duration> val,
               FormatContext& ctx) const -> decltype(ctx.out()) {
     using period = typename Duration::period;
     if (period::num != 1 || period::den != 1 ||
         std::is_floating_point<typename Duration::rep>::value) {
     if (detail::const_check(
             period::num != 1 || period::den != 1 ||
             std::is_floating_point<typename Duration::rep>::value)) {
       const auto epoch = val.time_since_epoch();
       auto subsecs = std::chrono::duration_cast<Duration>(
           epoch - std::chrono::duration_cast<std::chrono::seconds>(epoch));
       auto subsecs = detail::fmt_duration_cast<Duration>(
           epoch - detail::fmt_duration_cast<std::chrono::seconds>(epoch));
       if (subsecs.count() < 0) {
         auto second = std::chrono::seconds(1);
         auto second =
             detail::fmt_duration_cast<Duration>(std::chrono::seconds(1));
         if (epoch.count() < ((Duration::min)() + second).count())
           FMT_THROW(format_error("duration is too small"));
         subsecs += second;
         val -= second;
+      }
       return formatter<std::tm, Char>::do_format(
           gmtime(std::chrono::time_point_cast<std::chrono::seconds>(val)), ctx,
           &subsecs);
       return formatter<std::tm, Char>::do_format(gmtime(val), ctx, &subsecs);
+    }
     return formatter<std::tm, Char>::format(
         gmtime(std::chrono::time_point_cast<std::chrono::seconds>(val)), ctx);
     return formatter<std::tm, Char>::format(gmtime(val), ctx);
+  }
 };
@@ @@ -2164,7 +2146,7 @@ template <typename Char, typename Durati @@
 struct formatter<std::chrono::local_time<Duration>, Char>
     : formatter<std::tm, Char> {
   FMT_CONSTEXPR formatter() {
-    this->format_str = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{};
+    this->format_str_ = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{};
+  }
   template <typename FormatContext>
@@ @@ -2174,17 +2156,13 @@ struct formatter<std::chrono::local_time @@
     if (period::num != 1 || period::den != 1 ||
         std::is_floating_point<typename Duration::rep>::value) {
       const auto epoch = val.time_since_epoch();
       const auto subsecs = std::chrono::duration_cast<Duration>(
           epoch - std::chrono::duration_cast<std::chrono::seconds>(epoch));
       const auto subsecs = detail::fmt_duration_cast<Duration>(
           epoch - detail::fmt_duration_cast<std::chrono::seconds>(epoch));
       return formatter<std::tm, Char>::do_format(
           localtime(std::chrono::time_point_cast<std::chrono::seconds>(val)),
           ctx, &subsecs);
       return formatter<std::tm, Char>::do_format(localtime(val), ctx, &subsecs);
+    }
     return formatter<std::tm, Char>::format(
         localtime(std::chrono::time_point_cast<std::chrono::seconds>(val)),
         ctx);
     return formatter<std::tm, Char>::format(localtime(val), ctx);
+  }
 };
 #endif
@@ @@ -2207,51 +2185,46 @@ struct formatter<std::chrono::time_point @@
 template <typename Char> struct formatter<std::tm, Char> {
  private:
   format_specs<Char> specs;
   detail::arg_ref<Char> width_ref;
   format_specs<Char> specs_;
   detail::arg_ref<Char> width_ref_;
  protected:
   basic_string_view<Char> format_str;
   FMT_CONSTEXPR auto do_parse(basic_format_parse_context<Char>& ctx)
       -> decltype(ctx.begin()) {
     auto begin = ctx.begin(), end = ctx.end();
     if (begin == end || *begin == '}') return begin;
     begin = detail::parse_align(begin, end, specs);
     if (begin == end) return end;
     begin = detail::parse_dynamic_spec(begin, end, specs.width, width_ref, ctx);
     if (begin == end) return end;
     end = detail::parse_chrono_format(begin, end, detail::tm_format_checker());
     // Replace default format_str only if the new spec is not empty.
     if (end != begin) format_str = {begin, detail::to_unsigned(end - begin)};
     return end;
+  }
   basic_string_view<Char> format_str_;
   template <typename FormatContext, typename Duration>
   auto do_format(const std::tm& tm, FormatContext& ctx,
                  const Duration* subsecs) const -> decltype(ctx.out()) {
     auto specs_copy = specs;
     basic_memory_buffer<Char> buf;
     auto specs = specs_;
     auto buf = basic_memory_buffer<Char>();
     auto out = std::back_inserter(buf);
     detail::handle_dynamic_spec<detail::width_checker>(specs_copy.width,
                                                        width_ref, ctx);
     detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
                                                        ctx);
-    const auto loc_ref = ctx.locale();
     auto loc_ref = ctx.locale();
     detail::get_locale loc(static_cast<bool>(loc_ref), loc_ref);
     auto w =
         detail::tm_writer<decltype(out), Char, Duration>(loc, out, tm, subsecs);
-    detail::parse_chrono_format(format_str.begin(), format_str.end(), w);
+    detail::parse_chrono_format(format_str_.begin(), format_str_.end(), w);
     return detail::write(
-        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs_copy);
+        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
+  }
  public:
   FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
       -> decltype(ctx.begin()) {
     return this->do_parse(ctx);
     auto it = ctx.begin(), end = ctx.end();
     if (it == end || *it == '}') return it;
     it = detail::parse_align(it, end, specs_);
     if (it == end) return it;
     it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
     if (it == end) return it;
     end = detail::parse_chrono_format(it, end, detail::tm_format_checker());
     // Replace the default format_str only if the new spec is not empty.
     if (end != it) format_str_ = {it, detail::to_unsigned(end - it)};
     return end;
+  }
   template <typename FormatContext>

src/3rdparty/fmt/core.h

➞

Show inline comments

@@ @@ -13,11 +13,12 @@ @@
 #include <cstring>  // std::strlen
 #include <iterator>
 #include <limits>
 #include <memory>  // std::addressof
 #include <string>
 #include <type_traits>
 // The fmt library version in the form major * 10000 + minor * 100 + patch.
-#define FMT_VERSION 100000
+#define FMT_VERSION 100200
 #if defined(__clang__) && !defined(__ibmxl__)
 #  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
@@ @@ -92,7 +93,7 @@ @@
 #ifndef FMT_USE_CONSTEXPR
 #  if (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 || \
        (FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L)) &&             \
       !FMT_ICC_VERSION && !defined(__NVCC__)
+      !FMT_ICC_VERSION && (!defined(__NVCC__) || FMT_CPLUSPLUS >= 202002L)
 #    define FMT_USE_CONSTEXPR 1
 #  else
 #    define FMT_USE_CONSTEXPR 0
@@ @@ -104,9 +105,12 @@ @@
 #  define FMT_CONSTEXPR
 #endif
 #if ((FMT_CPLUSPLUS >= 202002L) &&                            \
      (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE > 9)) || \
     (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)
 #if (FMT_CPLUSPLUS >= 202002L ||                                \
      (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)) &&  \
     ((!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 10) &&  \
      (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 10000) && \
      (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1928)) &&          \
     defined(__cpp_lib_is_constant_evaluated)
 #  define FMT_CONSTEXPR20 constexpr
 #else
 #  define FMT_CONSTEXPR20
@@ @@ -162,9 +166,6 @@ @@
 #  endif
 #endif
 // An inline std::forward replacement.
 #define FMT_FORWARD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
 #ifdef _MSC_VER
 #  define FMT_UNCHECKED_ITERATOR(It) \
     using _Unchecked_type = It  // Mark iterator as checked.
@@ @@ -181,24 +182,26 @@ @@
+    }
 #endif
 #ifndef FMT_MODULE_EXPORT
 #  define FMT_MODULE_EXPORT
 #ifndef FMT_EXPORT
 #  define FMT_EXPORT
 #  define FMT_BEGIN_EXPORT
 #  define FMT_END_EXPORT
 #endif
 #if FMT_GCC_VERSION || FMT_CLANG_VERSION
 #  define FMT_VISIBILITY(value) __attribute__((visibility(value)))
 #else
 #  define FMT_VISIBILITY(value)
 #endif
 #if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
-#  ifdef FMT_LIB_EXPORT
+#  if defined(FMT_LIB_EXPORT)
 #    define FMT_API __declspec(dllexport)
 #  elif defined(FMT_SHARED)
 #    define FMT_API __declspec(dllimport)
 #  endif
 #else
 #  if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
 #    if defined(__GNUC__) || defined(__clang__)
 #      define FMT_API __attribute__((visibility("default")))
 #    endif
 #  endif
 #elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
 #  define FMT_API FMT_VISIBILITY("default")
 #endif
 #ifndef FMT_API
 #  define FMT_API
@@ @@ -224,8 +227,9 @@ @@
         __apple_build_version__ >= 14000029L) &&                 \
        FMT_CPLUSPLUS >= 202002L) ||                              \
       (defined(__cpp_consteval) &&                               \
        (!FMT_MSC_VERSION || _MSC_FULL_VER >= 193030704))
 // consteval is broken in MSVC before VS2022 and Apple clang before 14.
        (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1929))
 // consteval is broken in MSVC before VS2019 version 16.10 and Apple clang
 // before 14.
 #    define FMT_CONSTEVAL consteval
 #    define FMT_HAS_CONSTEVAL
 #  else
@@ @@ -244,10 +248,13 @@ @@
 #  endif
 #endif
 #if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L
 #  define FMT_INLINE_VARIABLE inline
 // GCC < 5 requires this-> in decltype
 #ifndef FMT_DECLTYPE_THIS
 #  if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
 #    define FMT_DECLTYPE_THIS this->
 #else
 #  define FMT_INLINE_VARIABLE
 #    define FMT_DECLTYPE_THIS
 #  endif
 #endif
 FMT_GCC_PRAGMA("GCC push_options")
@@ @@ -266,11 +273,18 @@ template <typename T> @@
 using remove_const_t = typename std::remove_const<T>::type;
 template <typename T>
 using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
 template <typename T> struct type_identity { using type = T; };
 template <typename T> struct type_identity {
   using type = T;
 };
 template <typename T> using type_identity_t = typename type_identity<T>::type;
 template <typename T>
 using underlying_t = typename std::underlying_type<T>::type;
 // Checks whether T is a container with contiguous storage.
 template <typename T> struct is_contiguous : std::false_type {};
 template <typename Char>
 struct is_contiguous<std::basic_string<Char>> : std::true_type {};
 struct monostate {
   constexpr monostate() {}
 };
@@ @@ -284,8 +298,11 @@ struct monostate { @@
 #  define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0
 #endif
 // This is defined in core.h instead of format.h to avoid injecting in std.
 // It is a template to avoid undesirable implicit conversions to std::byte.
 #ifdef __cpp_lib_byte
 inline auto format_as(std::byte b) -> unsigned char {
 template <typename T, FMT_ENABLE_IF(std::is_same<T, std::byte>::value)>
 inline auto format_as(T b) -> unsigned char {
   return static_cast<unsigned char>(b);
+}
 #endif
@@ @@ -389,7 +406,7 @@ FMT_CONSTEXPR inline auto is_utf8() -> b @@
   compiled with a different ``-std`` option than the client code (which is not
   recommended).
  */
-FMT_MODULE_EXPORT
+FMT_EXPORT
 template <typename Char> class basic_string_view {
  private:
   const Char* data_;
@@ @@ -449,15 +466,15 @@ template <typename Char> class basic_str @@
     size_ -= n;
+  }
   FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(
       basic_string_view<Char> sv) const noexcept {
   FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(
       basic_string_view<Char> sv) const noexcept -> bool {
     return size_ >= sv.size_ &&
            std::char_traits<Char>::compare(data_, sv.data_, sv.size_) == 0;
+  }
-  FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(Char c) const noexcept {
+  FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(Char c) const noexcept -> bool {
     return size_ >= 1 && std::char_traits<Char>::eq(*data_, c);
+  }
-  FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(const Char* s) const {
+  FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(const Char* s) const -> bool {
     return starts_with(basic_string_view<Char>(s));
+  }
@@ @@ -492,11 +509,11 @@ template <typename Char> class basic_str @@
+  }
 };
-FMT_MODULE_EXPORT
+FMT_EXPORT
 using string_view = basic_string_view<char>;
 /** Specifies if ``T`` is a character type. Can be specialized by users. */
-FMT_MODULE_EXPORT
+FMT_EXPORT
 template <typename T> struct is_char : std::false_type {};
 template <> struct is_char<char> : std::true_type {};
@@ @@ -595,10 +612,10 @@ FMT_TYPE_CONSTANT(const Char*, cstring_t @@
 FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
 FMT_TYPE_CONSTANT(const void*, pointer_type);
-constexpr bool is_integral_type(type t) {
+constexpr auto is_integral_type(type t) -> bool {
   return t > type::none_type && t <= type::last_integer_type;
+}
-constexpr bool is_arithmetic_type(type t) {
+constexpr auto is_arithmetic_type(type t) -> bool {
   return t > type::none_type && t <= type::last_numeric_type;
+}
@@ @@ -622,6 +639,7 @@ enum { @@
   pointer_set = set(type::pointer_type)
 };
 // DEPRECATED!
 FMT_NORETURN FMT_API void throw_format_error(const char* message);
 struct error_handler {
@@ @@ -634,6 +652,9 @@ struct error_handler { @@
 };
 }  // namespace detail
 /** Throws ``format_error`` with a given message. */
 using detail::throw_format_error;
 /** String's character type. */
 template <typename S> using char_t = typename detail::char_t_impl<S>::type;
@@ @@ -644,7 +665,7 @@ template <typename S> using char_t = typ @@
   You can use the ``format_parse_context`` type alias for ``char`` instead.
   \endrst
  */
-FMT_MODULE_EXPORT
+FMT_EXPORT
 template <typename Char> class basic_format_parse_context {
  private:
   basic_string_view<Char> format_str_;
@@ @@ -710,7 +731,7 @@ template <typename Char> class basic_for @@
   FMT_CONSTEXPR void check_dynamic_spec(int arg_id);
 };
-FMT_MODULE_EXPORT
+FMT_EXPORT
 using format_parse_context = basic_format_parse_context<char>;
 namespace detail {
@@ @@ -751,72 +772,6 @@ class compile_parse_context : public bas @@
 #endif
+  }
 };
 }  // namespace detail
 template <typename Char>
 FMT_CONSTEXPR void basic_format_parse_context<Char>::do_check_arg_id(int id) {
   // Argument id is only checked at compile-time during parsing because
   // formatting has its own validation.
   if (detail::is_constant_evaluated() &&
       (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) {
     using context = detail::compile_parse_context<Char>;
     if (id >= static_cast<context*>(this)->num_args())
       detail::throw_format_error("argument not found");
+  }
+}
 template <typename Char>
 FMT_CONSTEXPR void basic_format_parse_context<Char>::check_dynamic_spec(
     int arg_id) {
   if (detail::is_constant_evaluated() &&
       (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) {
     using context = detail::compile_parse_context<Char>;
     static_cast<context*>(this)->check_dynamic_spec(arg_id);
+  }
+}
 FMT_MODULE_EXPORT template <typename Context> class basic_format_arg;
 FMT_MODULE_EXPORT template <typename Context> class basic_format_args;
 FMT_MODULE_EXPORT template <typename Context> class dynamic_format_arg_store;
 // A formatter for objects of type T.
 FMT_MODULE_EXPORT
 template <typename T, typename Char = char, typename Enable = void>
 struct formatter {
   // A deleted default constructor indicates a disabled formatter.
   formatter() = delete;
 };
 // Specifies if T has an enabled formatter specialization. A type can be
 // formattable even if it doesn't have a formatter e.g. via a conversion.
 template <typename T, typename Context>
 using has_formatter =
     std::is_constructible<typename Context::template formatter_type<T>>;
 // Checks whether T is a container with contiguous storage.
 template <typename T> struct is_contiguous : std::false_type {};
 template <typename Char>
 struct is_contiguous<std::basic_string<Char>> : std::true_type {};
 class appender;
 namespace detail {
 template <typename Context, typename T>
 constexpr auto has_const_formatter_impl(T*)
     -> decltype(typename Context::template formatter_type<T>().format(
                     std::declval<const T&>(), std::declval<Context&>()),
                 true) {
   return true;
+}
 template <typename Context>
 constexpr auto has_const_formatter_impl(...) -> bool {
   return false;
+}
 template <typename T, typename Context>
 constexpr auto has_const_formatter() -> bool {
   return has_const_formatter_impl<Context>(static_cast<T*>(nullptr));
+}
 // Extracts a reference to the container from back_insert_iterator.
 template <typename Container>
@@ @@ -862,7 +817,7 @@ template <typename T> class buffer { @@
  protected:
   // Don't initialize ptr_ since it is not accessed to save a few cycles.
   FMT_MSC_WARNING(suppress : 26495)
   buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {}
+  FMT_CONSTEXPR buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {}
   FMT_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept
       : ptr_(p), size_(sz), capacity_(cap) {}
@@ @@ -877,6 +832,7 @@ template <typename T> class buffer { @@
+  }
   /** Increases the buffer capacity to hold at least *capacity* elements. */
   // DEPRECATED!
   virtual FMT_CONSTEXPR20 void grow(size_t capacity) = 0;
  public:
@@ @@ -898,10 +854,8 @@ template <typename T> class buffer { @@
   /** Returns the capacity of this buffer. */
   constexpr auto capacity() const noexcept -> size_t { return capacity_; }
   /** Returns a pointer to the buffer data. */
+  /** Returns a pointer to the buffer data (not null-terminated). */
   FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
   /** Returns a pointer to the buffer data. */
   FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }
   /** Clears this buffer. */
@@ @@ -1094,6 +1048,79 @@ template <typename T = char> class count @@
   auto count() -> size_t { return count_ + this->size(); }
 };
 }  // namespace detail
 template <typename Char>
 FMT_CONSTEXPR void basic_format_parse_context<Char>::do_check_arg_id(int id) {
   // Argument id is only checked at compile-time during parsing because
   // formatting has its own validation.
   if (detail::is_constant_evaluated() &&
       (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) {
     using context = detail::compile_parse_context<Char>;
     if (id >= static_cast<context*>(this)->num_args())
       detail::throw_format_error("argument not found");
+  }
+}
 template <typename Char>
 FMT_CONSTEXPR void basic_format_parse_context<Char>::check_dynamic_spec(
     int arg_id) {
   if (detail::is_constant_evaluated() &&
       (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) {
     using context = detail::compile_parse_context<Char>;
     static_cast<context*>(this)->check_dynamic_spec(arg_id);
+  }
+}
 FMT_EXPORT template <typename Context> class basic_format_arg;
 FMT_EXPORT template <typename Context> class basic_format_args;
 FMT_EXPORT template <typename Context> class dynamic_format_arg_store;
 // A formatter for objects of type T.
 FMT_EXPORT
 template <typename T, typename Char = char, typename Enable = void>
 struct formatter {
   // A deleted default constructor indicates a disabled formatter.
   formatter() = delete;
 };
 // Specifies if T has an enabled formatter specialization. A type can be
 // formattable even if it doesn't have a formatter e.g. via a conversion.
 template <typename T, typename Context>
 using has_formatter =
     std::is_constructible<typename Context::template formatter_type<T>>;
 // An output iterator that appends to a buffer.
 // It is used to reduce symbol sizes for the common case.
 class appender : public std::back_insert_iterator<detail::buffer<char>> {
   using base = std::back_insert_iterator<detail::buffer<char>>;
  public:
   using std::back_insert_iterator<detail::buffer<char>>::back_insert_iterator;
   appender(base it) noexcept : base(it) {}
   FMT_UNCHECKED_ITERATOR(appender);
   auto operator++() noexcept -> appender& { return *this; }
   auto operator++(int) noexcept -> appender { return *this; }
 };
 namespace detail {
 template <typename Context, typename T>
 constexpr auto has_const_formatter_impl(T*)
     -> decltype(typename Context::template formatter_type<T>().format(
                     std::declval<const T&>(), std::declval<Context&>()),
                 true) {
   return true;
+}
 template <typename Context>
 constexpr auto has_const_formatter_impl(...) -> bool {
   return false;
+}
 template <typename T, typename Context>
 constexpr auto has_const_formatter() -> bool {
   return has_const_formatter_impl<Context>(static_cast<T*>(nullptr));
+}
 template <typename T>
 using buffer_appender = conditional_t<std::is_same<T, char>::value, appender,
@@ @@ -1269,9 +1296,9 @@ template <typename Context> class value @@
   FMT_INLINE value(const named_arg_info<char_type>* args, size_t size)
       : named_args{args, size} {}
   template <typename T> FMT_CONSTEXPR FMT_INLINE value(T& val) {
     using value_type = remove_cvref_t<T>;
     custom.value = const_cast<value_type*>(&val);
   template <typename T> FMT_CONSTEXPR20 FMT_INLINE value(T& val) {
     using value_type = remove_const_t<T>;
     custom.value = const_cast<value_type*>(std::addressof(val));
     // Get the formatter type through the context to allow different contexts
     // have different extension points, e.g. `formatter<T>` for `format` and
     // `printf_formatter<T>` for `printf`.
@@ @@ -1292,13 +1319,11 @@ template <typename Context> class value @@
     parse_ctx.advance_to(f.parse(parse_ctx));
     using qualified_type =
         conditional_t<has_const_formatter<T, Context>(), const T, T>;
     // Calling format through a mutable reference is deprecated.
     ctx.advance_to(f.format(*static_cast<qualified_type*>(arg), ctx));
+  }
 };
 template <typename Context, typename T>
 FMT_CONSTEXPR auto make_arg(T&& value) -> basic_format_arg<Context>;
 // To minimize the number of types we need to deal with, long is translated
 // either to int or to long long depending on its size.
 enum { long_short = sizeof(long) == sizeof(int) };
@@ @@ -1308,7 +1333,7 @@ using ulong_type = conditional_t<long_sh @@
 template <typename T> struct format_as_result {
   template <typename U,
             FMT_ENABLE_IF(std::is_enum<U>::value || std::is_class<U>::value)>
   static auto map(U*) -> decltype(format_as(std::declval<U>()));
+  static auto map(U*) -> remove_cvref_t<decltype(format_as(std::declval<U>()))>;
   static auto map(...) -> void;
   using type = decltype(map(static_cast<T*>(nullptr)));
@@ @@ -1410,9 +1435,8 @@ template <typename Context> struct arg_m @@
       FMT_ENABLE_IF(
           std::is_pointer<T>::value || std::is_member_pointer<T>::value ||
           std::is_function<typename std::remove_pointer<T>::type>::value ||
           (std::is_convertible<const T&, const void*>::value &&
            !std::is_convertible<const T&, const char_type*>::value &&
            !has_formatter<T, Context>::value))>
           (std::is_array<T>::value &&
            !std::is_convertible<T, const char_type*>::value))>
   FMT_CONSTEXPR auto map(const T&) -> unformattable_pointer {
     return {};
+  }
@@ @@ -1426,39 +1450,39 @@ template <typename Context> struct arg_m @@
   // Only map owning types because mapping views can be unsafe.
   template <typename T, typename U = format_as_t<T>,
             FMT_ENABLE_IF(std::is_arithmetic<U>::value)>
   FMT_CONSTEXPR FMT_INLINE auto map(const T& val) -> decltype(this->map(U())) {
   FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
       -> decltype(FMT_DECLTYPE_THIS map(U())) {
     return map(format_as(val));
+  }
   template <typename T, typename U = remove_cvref_t<T>>
   struct formattable
       : bool_constant<has_const_formatter<U, Context>() ||
   template <typename T, typename U = remove_const_t<T>>
   struct formattable : bool_constant<has_const_formatter<U, Context>() ||
                       (has_formatter<U, Context>::value &&
-                       !std::is_const<remove_reference_t<T>>::value)> {};
+                                      !std::is_const<T>::value)> {};
   template <typename T, FMT_ENABLE_IF(formattable<T>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto do_map(T&& val) -> T& {
   FMT_CONSTEXPR FMT_INLINE auto do_map(T& val) -> T& {
     return val;
+  }
   template <typename T, FMT_ENABLE_IF(!formattable<T>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto do_map(T&&) -> unformattable {
   FMT_CONSTEXPR FMT_INLINE auto do_map(T&) -> unformattable {
     return {};
+  }
-  template <typename T, typename U = remove_cvref_t<T>,
+  template <typename T, typename U = remove_const_t<T>,
             FMT_ENABLE_IF((std::is_class<U>::value || std::is_enum<U>::value ||
                            std::is_union<U>::value) &&
                           !is_string<U>::value && !is_char<U>::value &&
                           !is_named_arg<U>::value &&
                           !std::is_arithmetic<format_as_t<U>>::value)>
   FMT_CONSTEXPR FMT_INLINE auto map(T&& val)
       -> decltype(this->do_map(std::forward<T>(val))) {
     return do_map(std::forward<T>(val));
   FMT_CONSTEXPR FMT_INLINE auto map(T& val)
       -> decltype(FMT_DECLTYPE_THIS do_map(val)) {
     return do_map(val);
+  }
   template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
   FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg)
-      -> decltype(this->map(named_arg.value)) {
+      -> decltype(FMT_DECLTYPE_THIS map(named_arg.value)) {
     return map(named_arg.value);
+  }
@@ @@ -1476,31 +1500,132 @@ enum { packed_arg_bits = 4 }; @@
 enum { max_packed_args = 62 / packed_arg_bits };
 enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
 enum : unsigned long long { has_named_args_bit = 1ULL << 62 };
 }  // namespace detail
 // An output iterator that appends to a buffer.
 // It is used to reduce symbol sizes for the common case.
 class appender : public std::back_insert_iterator<detail::buffer<char>> {
   using base = std::back_insert_iterator<detail::buffer<char>>;
 template <typename Char, typename InputIt>
 auto copy_str(InputIt begin, InputIt end, appender out) -> appender {
   get_container(out).append(begin, end);
   return out;
+}
 template <typename Char, typename InputIt>
 auto copy_str(InputIt begin, InputIt end,
               std::back_insert_iterator<std::string> out)
     -> std::back_insert_iterator<std::string> {
   get_container(out).append(begin, end);
   return out;
+}
 template <typename Char, typename R, typename OutputIt>
 FMT_CONSTEXPR auto copy_str(R&& rng, OutputIt out) -> OutputIt {
   return detail::copy_str<Char>(rng.begin(), rng.end(), out);
+}
 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
 // A workaround for gcc 4.8 to make void_t work in a SFINAE context.
 template <typename...> struct void_t_impl {
   using type = void;
 };
 template <typename... T> using void_t = typename void_t_impl<T...>::type;
 #else
 template <typename...> using void_t = void;
 #endif
 template <typename It, typename T, typename Enable = void>
 struct is_output_iterator : std::false_type {};
 template <typename It, typename T>
 struct is_output_iterator<
     It, T,
     void_t<typename std::iterator_traits<It>::iterator_category,
            decltype(*std::declval<It>() = std::declval<T>())>>
     : std::true_type {};
 template <typename It> struct is_back_insert_iterator : std::false_type {};
 template <typename Container>
 struct is_back_insert_iterator<std::back_insert_iterator<Container>>
     : std::true_type {};
 // A type-erased reference to an std::locale to avoid a heavy <locale> include.
 class locale_ref {
  private:
   const void* locale_;  // A type-erased pointer to std::locale.
  public:
   using std::back_insert_iterator<detail::buffer<char>>::back_insert_iterator;
   appender(base it) noexcept : base(it) {}
   FMT_UNCHECKED_ITERATOR(appender);
   auto operator++() noexcept -> appender& { return *this; }
   auto operator++(int) noexcept -> appender { return *this; }
   constexpr FMT_INLINE locale_ref() : locale_(nullptr) {}
   template <typename Locale> explicit locale_ref(const Locale& loc);
   explicit operator bool() const noexcept { return locale_ != nullptr; }
   template <typename Locale> auto get() const -> Locale;
 };
 // A formatting argument. It is a trivially copyable/constructible type to
 // allow storage in basic_memory_buffer.
 template <typename> constexpr auto encode_types() -> unsigned long long {
   return 0;
+}
 template <typename Context, typename Arg, typename... Args>
 constexpr auto encode_types() -> unsigned long long {
   return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
          (encode_types<Context, Args...>() << packed_arg_bits);
+}
 #if defined(__cpp_if_constexpr)
 // This type is intentionally undefined, only used for errors
 template <typename T, typename Char> struct type_is_unformattable_for;
 #endif
 template <bool PACKED, typename Context, typename T, FMT_ENABLE_IF(PACKED)>
 FMT_CONSTEXPR FMT_INLINE auto make_arg(T& val) -> value<Context> {
   using arg_type = remove_cvref_t<decltype(arg_mapper<Context>().map(val))>;
   constexpr bool formattable_char =
       !std::is_same<arg_type, unformattable_char>::value;
   static_assert(formattable_char, "Mixing character types is disallowed.");
   // Formatting of arbitrary pointers is disallowed. If you want to format a
   // pointer cast it to `void*` or `const void*`. In particular, this forbids
   // formatting of `[const] volatile char*` printed as bool by iostreams.
   constexpr bool formattable_pointer =
       !std::is_same<arg_type, unformattable_pointer>::value;
   static_assert(formattable_pointer,
                 "Formatting of non-void pointers is disallowed.");
   constexpr bool formattable = !std::is_same<arg_type, unformattable>::value;
 #if defined(__cpp_if_constexpr)
   if constexpr (!formattable) {
     type_is_unformattable_for<T, typename Context::char_type> _;
+  }
 #endif
   static_assert(
       formattable,
       "Cannot format an argument. To make type T formattable provide a "
       "formatter<T> specialization: https://fmt.dev/latest/api.html#udt");
   return {arg_mapper<Context>().map(val)};
+}
 template <typename Context, typename T>
 FMT_CONSTEXPR auto make_arg(T& val) -> basic_format_arg<Context> {
   auto arg = basic_format_arg<Context>();
   arg.type_ = mapped_type_constant<T, Context>::value;
   arg.value_ = make_arg<true, Context>(val);
   return arg;
+}
 template <bool PACKED, typename Context, typename T, FMT_ENABLE_IF(!PACKED)>
 FMT_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg<Context> {
   return make_arg<Context>(val);
+}
 }  // namespace detail
 FMT_BEGIN_EXPORT
 // A formatting argument. Context is a template parameter for the compiled API
 // where output can be unbuffered.
 template <typename Context> class basic_format_arg {
  private:
   detail::value<Context> value_;
   detail::type type_;
   template <typename ContextType, typename T>
-  friend FMT_CONSTEXPR auto detail::make_arg(T&& value)
   friend FMT_CONSTEXPR auto detail::make_arg(T& value)
       -> basic_format_arg<ContextType>;
   template <typename Visitor, typename Ctx>
@@ @@ -1545,6 +1670,15 @@ template <typename Context> class basic_ @@
   auto is_arithmetic() const -> bool {
     return detail::is_arithmetic_type(type_);
+  }
   FMT_INLINE auto format_custom(const char_type* parse_begin,
                                 typename Context::parse_context_type& parse_ctx,
                                 Context& ctx) -> bool {
     if (type_ != detail::type::custom_type) return false;
     parse_ctx.advance_to(parse_begin);
     value_.custom.format(value_.custom.value, parse_ctx, ctx);
     return true;
+  }
 };
 /**
@@ @@ -1554,7 +1688,7 @@ template <typename Context> class basic_ @@
   ``vis(value)`` will be called with the value of type ``double``.
   \endrst
  */
-FMT_MODULE_EXPORT
+// DEPRECATED!
 template <typename Visitor, typename Context>
 FMT_CONSTEXPR FMT_INLINE auto visit_format_arg(
     Visitor&& vis, const basic_format_arg<Context>& arg) -> decltype(vis(0)) {
@@ @@ -1596,123 +1730,6 @@ FMT_CONSTEXPR FMT_INLINE auto visit_form @@
   return vis(monostate());
+}
 namespace detail {
 template <typename Char, typename InputIt>
 auto copy_str(InputIt begin, InputIt end, appender out) -> appender {
   get_container(out).append(begin, end);
   return out;
+}
 template <typename Char, typename R, typename OutputIt>
 FMT_CONSTEXPR auto copy_str(R&& rng, OutputIt out) -> OutputIt {
   return detail::copy_str<Char>(rng.begin(), rng.end(), out);
+}
 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
 // A workaround for gcc 4.8 to make void_t work in a SFINAE context.
 template <typename...> struct void_t_impl { using type = void; };
 template <typename... T> using void_t = typename void_t_impl<T...>::type;
 #else
 template <typename...> using void_t = void;
 #endif
 template <typename It, typename T, typename Enable = void>
 struct is_output_iterator : std::false_type {};
 template <typename It, typename T>
 struct is_output_iterator<
     It, T,
     void_t<typename std::iterator_traits<It>::iterator_category,
            decltype(*std::declval<It>() = std::declval<T>())>>
     : std::true_type {};
 template <typename It> struct is_back_insert_iterator : std::false_type {};
 template <typename Container>
 struct is_back_insert_iterator<std::back_insert_iterator<Container>>
     : std::true_type {};
 template <typename It>
 struct is_contiguous_back_insert_iterator : std::false_type {};
 template <typename Container>
 struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>>
     : is_contiguous<Container> {};
 template <>
 struct is_contiguous_back_insert_iterator<appender> : std::true_type {};
 // A type-erased reference to an std::locale to avoid a heavy <locale> include.
 class locale_ref {
  private:
   const void* locale_;  // A type-erased pointer to std::locale.
  public:
   constexpr FMT_INLINE locale_ref() : locale_(nullptr) {}
   template <typename Locale> explicit locale_ref(const Locale& loc);
   explicit operator bool() const noexcept { return locale_ != nullptr; }
   template <typename Locale> auto get() const -> Locale;
 };
 template <typename> constexpr auto encode_types() -> unsigned long long {
   return 0;
+}
 template <typename Context, typename Arg, typename... Args>
 constexpr auto encode_types() -> unsigned long long {
   return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
          (encode_types<Context, Args...>() << packed_arg_bits);
+}
 template <typename Context, typename T>
 FMT_CONSTEXPR FMT_INLINE auto make_value(T&& val) -> value<Context> {
   using arg_type = remove_cvref_t<decltype(arg_mapper<Context>().map(val))>;
   constexpr bool formattable_char =
       !std::is_same<arg_type, unformattable_char>::value;
   static_assert(formattable_char, "Mixing character types is disallowed.");
   // Formatting of arbitrary pointers is disallowed. If you want to format a
   // pointer cast it to `void*` or `const void*`. In particular, this forbids
   // formatting of `[const] volatile char*` printed as bool by iostreams.
   constexpr bool formattable_pointer =
       !std::is_same<arg_type, unformattable_pointer>::value;
   static_assert(formattable_pointer,
                 "Formatting of non-void pointers is disallowed.");
   constexpr bool formattable = !std::is_same<arg_type, unformattable>::value;
   static_assert(
       formattable,
       "Cannot format an argument. To make type T formattable provide a "
       "formatter<T> specialization: https://fmt.dev/latest/api.html#udt");
   return {arg_mapper<Context>().map(val)};
+}
 template <typename Context, typename T>
 FMT_CONSTEXPR auto make_arg(T&& value) -> basic_format_arg<Context> {
   auto arg = basic_format_arg<Context>();
   arg.type_ = mapped_type_constant<T, Context>::value;
   arg.value_ = make_value<Context>(value);
   return arg;
+}
 // The DEPRECATED type template parameter is there to avoid an ODR violation
 // when using a fallback formatter in one translation unit and an implicit
 // conversion in another (not recommended).
 template <bool IS_PACKED, typename Context, type, typename T,
           FMT_ENABLE_IF(IS_PACKED)>
 FMT_CONSTEXPR FMT_INLINE auto make_arg(T&& val) -> value<Context> {
   return make_value<Context>(val);
+}
 template <bool IS_PACKED, typename Context, type, typename T,
           FMT_ENABLE_IF(!IS_PACKED)>
 FMT_CONSTEXPR inline auto make_arg(T&& value) -> basic_format_arg<Context> {
   return make_arg<Context>(value);
+}
 }  // namespace detail
 FMT_BEGIN_EXPORT
 // Formatting context.
 template <typename OutputIt, typename Char> class basic_format_context {
  private:
@@ @@ -1750,6 +1767,7 @@ template <typename OutputIt, typename Ch @@
+  }
   auto args() const -> const format_args& { return args_; }
   // DEPRECATED!
   FMT_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; }
   void on_error(const char* message) { error_handler().on_error(message); }
@@ @@ -1772,7 +1790,7 @@ using format_context = buffer_context<ch @@
 template <typename T, typename Char = char>
 using is_formattable = bool_constant<!std::is_base_of<
     detail::unformattable, decltype(detail::arg_mapper<buffer_context<Char>>()
                                         .map(std::declval<T>()))>::value>;
+                                        .map(std::declval<T&>()))>::value>;
 /**
   \rst
@@ @@ -1790,7 +1808,7 @@ class format_arg_store @@
+{
  private:
   static const size_t num_args = sizeof...(Args);
-  static const size_t num_named_args = detail::count_named_args<Args...>();
+  static constexpr size_t num_named_args = detail::count_named_args<Args...>();
   static const bool is_packed = num_args <= detail::max_packed_args;
   using value_type = conditional_t<is_packed, detail::value<Context>,
@@ @@ -1811,15 +1829,13 @@ class format_arg_store @@
  public:
   template <typename... T>
-  FMT_CONSTEXPR FMT_INLINE format_arg_store(T&&... args)
   FMT_CONSTEXPR FMT_INLINE format_arg_store(T&... args)
+      :
 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
         basic_format_args<Context>(*this),
 #endif
         data_{detail::make_arg<
             is_packed, Context,
             detail::mapped_type_constant<remove_cvref_t<T>, Context>::value>(
             FMT_FORWARD(args))...} {
         data_{detail::make_arg<is_packed, Context>(args)...} {
     if (detail::const_check(num_named_args != 0))
     detail::init_named_args(data_.named_args(), 0, 0, args...);
+  }
 };
@@ @@ -1828,14 +1844,15 @@ class format_arg_store @@
   \rst
   Constructs a `~fmt::format_arg_store` object that contains references to
   arguments and can be implicitly converted to `~fmt::format_args`. `Context`
-  can be omitted in which case it defaults to `~fmt::context`.
+  can be omitted in which case it defaults to `~fmt::format_context`.
   See `~fmt::arg` for lifetime considerations.
   \endrst
  */
 // Arguments are taken by lvalue references to avoid some lifetime issues.
 template <typename Context = format_context, typename... T>
-constexpr auto make_format_args(T&&... args)
 constexpr auto make_format_args(T&... args)
     -> format_arg_store<Context, remove_cvref_t<T>...> {
-  return {FMT_FORWARD(args)...};
   return {args...};
+}
 /**
@@ @@ -1863,7 +1880,7 @@ FMT_END_EXPORT @@
   ``vformat``::
     void vlog(string_view format_str, format_args args);  // OK
-    format_args args = make_format_args(42);  // Error: dangling reference
     format_args args = make_format_args();  // Error: dangling reference
   \endrst
  */
 template <typename Context> class basic_format_args {
@@ @@ -1980,7 +1997,7 @@ template <typename Context> class basic_ @@
 /** An alias to ``basic_format_args<format_context>``. */
 // A separate type would result in shorter symbols but break ABI compatibility
 // between clang and gcc on ARM (#1919).
-FMT_MODULE_EXPORT using format_args = basic_format_args<format_context>;
+FMT_EXPORT using format_args = basic_format_args<format_context>;
 // We cannot use enum classes as bit fields because of a gcc bug, so we put them
 // in namespaces instead (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414).
@@ @@ -2312,9 +2329,12 @@ FMT_CONSTEXPR FMT_INLINE auto parse_form @@
     dynamic_format_specs<Char>& specs;
     type arg_type;
     FMT_CONSTEXPR auto operator()(pres type, int set) -> const Char* {
       if (!in(arg_type, set)) throw_format_error("invalid format specifier");
       specs.type = type;
     FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
       if (!in(arg_type, set)) {
         if (arg_type == type::none_type) return begin;
         throw_format_error("invalid format specifier");
+      }
       specs.type = pres_type;
       return begin + 1;
+    }
   } parse_presentation_type{begin, specs, arg_type};
@@ @@ -2331,6 +2351,7 @@ FMT_CONSTEXPR FMT_INLINE auto parse_form @@
     case '+':
     case '-':
     case ' ':
       if (arg_type == type::none_type) return begin;
       enter_state(state::sign, in(arg_type, sint_set | float_set));
       switch (c) {
       case '+':
@@ @@ -2346,14 +2367,17 @@ FMT_CONSTEXPR FMT_INLINE auto parse_form @@
       ++begin;
       break;
     case '#':
       if (arg_type == type::none_type) return begin;
       enter_state(state::hash, is_arithmetic_type(arg_type));
       specs.alt = true;
       ++begin;
       break;
     case '0':
       enter_state(state::zero);
       if (!is_arithmetic_type(arg_type))
       if (!is_arithmetic_type(arg_type)) {
         if (arg_type == type::none_type) return begin;
         throw_format_error("format specifier requires numeric argument");
+      }
       if (specs.align == align::none) {
         // Ignore 0 if align is specified for compatibility with std::format.
         specs.align = align::numeric;
@@ @@ -2375,12 +2399,14 @@ FMT_CONSTEXPR FMT_INLINE auto parse_form @@
       begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx);
       break;
     case '.':
       if (arg_type == type::none_type) return begin;
       enter_state(state::precision,
                   in(arg_type, float_set | string_set | cstring_set));
       begin = parse_precision(begin, end, specs.precision, specs.precision_ref,
                               ctx);
       break;
     case 'L':
       if (arg_type == type::none_type) return begin;
       enter_state(state::locale, is_arithmetic_type(arg_type));
       specs.localized = true;
       ++begin;
@@ @@ -2414,6 +2440,8 @@ FMT_CONSTEXPR FMT_INLINE auto parse_form @@
     case 'G':
       return parse_presentation_type(pres::general_upper, float_set);
     case 'c':
       if (arg_type == type::bool_type)
         throw_format_error("invalid format specifier");
       return parse_presentation_type(pres::chr, integral_set);
     case 's':
       return parse_presentation_type(pres::string,
@@ @@ -2552,7 +2580,17 @@ FMT_CONSTEXPR auto parse_format_specs(Pa @@
       mapped_type_constant<T, context>::value != type::custom_type,
       decltype(arg_mapper<context>().map(std::declval<const T&>())),
       typename strip_named_arg<T>::type>;
 #if defined(__cpp_if_constexpr)
   if constexpr (std::is_default_constructible<
                     formatter<mapped_type, char_type>>::value) {
   return formatter<mapped_type, char_type>().parse(ctx);
   } else {
     type_is_unformattable_for<T, char_type> _;
     return ctx.begin();
+  }
 #else
   return formatter<mapped_type, char_type>().parse(ctx);
 #endif
+}
 // Checks char specs and returns true iff the presentation type is char-like.
@@ @@ -2568,8 +2606,6 @@ FMT_CONSTEXPR auto check_char_specs(cons @@
   return true;
+}
 constexpr FMT_INLINE_VARIABLE int invalid_arg_index = -1;
 #if FMT_USE_NONTYPE_TEMPLATE_ARGS
 template <int N, typename T, typename... Args, typename Char>
 constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
@@ @@ -2579,7 +2615,7 @@ constexpr auto get_arg_index_by_name(bas @@
   if constexpr (sizeof...(Args) > 0)
     return get_arg_index_by_name<N + 1, Args...>(name);
   (void)name;  // Workaround an MSVC bug about "unused" parameter.
-  return invalid_arg_index;
+  return -1;
+}
 #endif
@@ @@ -2590,7 +2626,7 @@ FMT_CONSTEXPR auto get_arg_index_by_name @@
     return get_arg_index_by_name<0, Args...>(name);
 #endif
   (void)name;
-  return invalid_arg_index;
+  return -1;
+}
 template <typename Char, typename... Args> class format_string_checker {
@@ @@ -2604,15 +2640,15 @@ template <typename Char, typename... Arg @@
   // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1.
   using parse_func = const Char* (*)(parse_context_type&);
   type types_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
   parse_context_type context_;
   parse_func parse_funcs_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
   type types_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
  public:
   explicit FMT_CONSTEXPR format_string_checker(basic_string_view<Char> fmt)
       : context_(fmt, num_args, types_),
         parse_funcs_{&parse_format_specs<Args, parse_context_type>...},
         types_{mapped_type_constant<Args, buffer_context<Char>>::value...} {}
       : types_{mapped_type_constant<Args, buffer_context<Char>>::value...},
         context_(fmt, num_args, types_),
         parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
   FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
@@ @@ -2623,7 +2659,7 @@ template <typename Char, typename... Arg @@
   FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
 #if FMT_USE_NONTYPE_TEMPLATE_ARGS
     auto index = get_arg_index_by_name<Args...>(id);
-    if (index == invalid_arg_index) on_error("named argument is not found");
+    if (index < 0) on_error("named argument is not found");
     return index;
 #else
     (void)id;
@@ @@ -2632,7 +2668,9 @@ template <typename Char, typename... Arg @@
 #endif
+  }
   FMT_CONSTEXPR void on_replacement_field(int, const Char*) {}
   FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) {
     on_format_specs(id, begin, begin);  // Call parse() on empty specs.
+  }
   FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*)
       -> const Char* {
@@ @@ -2669,7 +2707,9 @@ template <typename Char = char> struct v @@
   using type = basic_format_args<
       basic_format_context<std::back_insert_iterator<buffer<Char>>, Char>>;
 };
 template <> struct vformat_args<char> { using type = format_args; };
 template <> struct vformat_args<char> {
   using type = format_args;
 };
 // Use vformat_args and avoid type_identity to keep symbols short.
 template <typename Char>
@@ @@ -2715,27 +2755,6 @@ struct formatter<T, Char, @@
       -> decltype(ctx.out());
 };
 #define FMT_FORMAT_AS(Type, Base)                                        \
   template <typename Char>                                               \
   struct formatter<Type, Char> : formatter<Base, Char> {                 \
     template <typename FormatContext>                                    \
     auto format(const Type& val, FormatContext& ctx) const               \
         -> decltype(ctx.out()) {                                         \
       return formatter<Base, Char>::format(static_cast<Base>(val), ctx); \
     }                                                                    \
+  }
 FMT_FORMAT_AS(signed char, int);
 FMT_FORMAT_AS(unsigned char, unsigned);
 FMT_FORMAT_AS(short, int);
 FMT_FORMAT_AS(unsigned short, unsigned);
 FMT_FORMAT_AS(long, long long);
 FMT_FORMAT_AS(unsigned long, unsigned long long);
 FMT_FORMAT_AS(Char*, const Char*);
 FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
 FMT_FORMAT_AS(std::nullptr_t, const void*);
 FMT_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>);
 template <typename Char = char> struct runtime_format_string {
   basic_string_view<Char> str;
 };

src/3rdparty/fmt/format-inl.h

➞

Show inline comments

@@ @@ -18,7 +18,7 @@ @@
 #  include <locale>
 #endif
-#ifdef _WIN32
+#if defined(_WIN32) && !defined(FMT_WINDOWS_NO_WCHAR)
 #  include <io.h>  // _isatty
 #endif
@@ @@ -58,8 +58,8 @@ FMT_FUNC void format_error_code(detail:: @@
   error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
   auto it = buffer_appender<char>(out);
   if (message.size() <= inline_buffer_size - error_code_size)
     format_to(it, FMT_STRING("{}{}"), message, SEP);
   format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
     fmt::format_to(it, FMT_STRING("{}{}"), message, SEP);
   fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
   FMT_ASSERT(out.size() <= inline_buffer_size, "");
+}
@@ @@ -73,9 +73,8 @@ FMT_FUNC void report_error(format_func f @@
+}
 // A wrapper around fwrite that throws on error.
 inline void fwrite_fully(const void* ptr, size_t size, size_t count,
                          FILE* stream) {
   size_t written = std::fwrite(ptr, size, count, stream);
 inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) {
   size_t written = std::fwrite(ptr, 1, count, stream);
   if (written < count)
     FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
@@ @@ -86,7 +85,7 @@ locale_ref::locale_ref(const Locale& loc @@
   static_assert(std::is_same<Locale, std::locale>::value, "");
+}
-template <typename Locale> Locale locale_ref::get() const {
+template <typename Locale> auto locale_ref::get() const -> Locale {
   static_assert(std::is_same<Locale, std::locale>::value, "");
   return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
+}
@@ @@ -98,7 +97,8 @@ FMT_FUNC auto thousands_sep_impl(locale_ @@
   auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
   return {std::move(grouping), thousands_sep};
+}
 template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
 template <typename Char>
 FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char {
   return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
       .decimal_point();
+}
@@ @@ -144,24 +144,25 @@ FMT_API FMT_FUNC auto format_facet<std:: @@
+}
 #endif
 FMT_FUNC std::system_error vsystem_error(int error_code, string_view fmt,
                                          format_args args) {
 FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args)
     -> std::system_error {
   auto ec = std::error_code(error_code, std::generic_category());
   return std::system_error(ec, vformat(fmt, args));
+}
 namespace detail {
 template <typename F> inline bool operator==(basic_fp<F> x, basic_fp<F> y) {
 template <typename F>
 inline auto operator==(basic_fp<F> x, basic_fp<F> y) -> bool {
   return x.f == y.f && x.e == y.e;
+}
 // Compilers should be able to optimize this into the ror instruction.
-FMT_CONSTEXPR inline uint32_t rotr(uint32_t n, uint32_t r) noexcept {
+FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t {
   r &= 31;
   return (n >> r) | (n << (32 - r));
+}
-FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept {
+FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t {
   r &= 63;
   return (n >> r) | (n << (64 - r));
+}
@@ @@ -170,14 +171,14 @@ FMT_CONSTEXPR inline uint64_t rotr(uint6 @@
 namespace dragonbox {
 // Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
 // 64-bit unsigned integer.
-inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept {
+inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t {
   return umul128_upper64(static_cast<uint64_t>(x) << 32, y);
+}
 // Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a
 // 128-bit unsigned integer.
 inline uint128_fallback umul192_lower128(uint64_t x,
                                          uint128_fallback y) noexcept {
 inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept
     -> uint128_fallback {
   uint64_t high = x * y.high();
   uint128_fallback high_low = umul128(x, y.low());
   return {high + high_low.high(), high_low.low()};
@@ @@ -185,12 +186,12 @@ inline uint128_fallback umul192_lower128 @@
 // Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
 // 64-bit unsigned integer.
-inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept {
+inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t {
   return x * y;
+}
 // Various fast log computations.
-inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept {
+inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int {
   FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
   return (e * 631305 - 261663) >> 21;
+}
@@ @@ -204,7 +205,7 @@ FMT_INLINE_VARIABLE constexpr struct { @@
 // divisible by pow(10, N).
 // Precondition: n <= pow(10, N + 1).
 template <int N>
-bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept {
+auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool {
   // The numbers below are chosen such that:
   //   1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,
   //   2. nm mod 2^k < m if and only if n is divisible by d,
@@ @@ -229,7 +230,7 @@ bool check_divisibility_and_divide_by_po @@
 // Computes floor(n / pow(10, N)) for small n and N.
 // Precondition: n <= pow(10, N + 1).
-template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept {
+template <int N> auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t {
   constexpr auto info = div_small_pow10_infos[N - 1];
   FMT_ASSERT(n <= info.divisor * 10, "n is too large");
   constexpr uint32_t magic_number =
@@ @@ -238,12 +239,12 @@ template <int N> uint32_t small_division @@
+}
 // Computes floor(n / 10^(kappa + 1)) (float)
-inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept {
+inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t {
   // 1374389535 = ceil(2^37/100)
   return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37);
+}
 // Computes floor(n / 10^(kappa + 1)) (double)
-inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept {
+inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t {
   // 2361183241434822607 = ceil(2^(64+7)/1000)
   return umul128_upper64(n, 2361183241434822607ull) >> 7;
+}
@@ @@ -255,7 +256,7 @@ template <> struct cache_accessor<float> @@
   using carrier_uint = float_info<float>::carrier_uint;
   using cache_entry_type = uint64_t;
-  static uint64_t get_cached_power(int k) noexcept {
+  static auto get_cached_power(int k) noexcept -> uint64_t {
     FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
                "k is out of range");
     static constexpr const uint64_t pow10_significands[] = {
@@ @@ -297,20 +298,23 @@ template <> struct cache_accessor<float> @@
     bool is_integer;
   };
   static compute_mul_result compute_mul(
       carrier_uint u, const cache_entry_type& cache) noexcept {
   static auto compute_mul(carrier_uint u,
                           const cache_entry_type& cache) noexcept
       -> compute_mul_result {
     auto r = umul96_upper64(u, cache);
     return {static_cast<carrier_uint>(r >> 32),
             static_cast<carrier_uint>(r) == 0};
+  }
   static uint32_t compute_delta(const cache_entry_type& cache,
                                 int beta) noexcept {
   static auto compute_delta(const cache_entry_type& cache, int beta) noexcept
       -> uint32_t {
     return static_cast<uint32_t>(cache >> (64 - 1 - beta));
+  }
   static compute_mul_parity_result compute_mul_parity(
       carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
   static auto compute_mul_parity(carrier_uint two_f,
                                  const cache_entry_type& cache,
                                  int beta) noexcept
       -> compute_mul_parity_result {
     FMT_ASSERT(beta >= 1, "");
     FMT_ASSERT(beta < 64, "");
@@ @@ -319,22 +323,22 @@ template <> struct cache_accessor<float> @@
             static_cast<uint32_t>(r >> (32 - beta)) == 0};
+  }
   static carrier_uint compute_left_endpoint_for_shorter_interval_case(
       const cache_entry_type& cache, int beta) noexcept {
   static auto compute_left_endpoint_for_shorter_interval_case(
       const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return static_cast<carrier_uint>(
         (cache - (cache >> (num_significand_bits<float>() + 2))) >>
         (64 - num_significand_bits<float>() - 1 - beta));
+  }
   static carrier_uint compute_right_endpoint_for_shorter_interval_case(
       const cache_entry_type& cache, int beta) noexcept {
   static auto compute_right_endpoint_for_shorter_interval_case(
       const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return static_cast<carrier_uint>(
         (cache + (cache >> (num_significand_bits<float>() + 1))) >>
         (64 - num_significand_bits<float>() - 1 - beta));
+  }
   static carrier_uint compute_round_up_for_shorter_interval_case(
       const cache_entry_type& cache, int beta) noexcept {
   static auto compute_round_up_for_shorter_interval_case(
       const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return (static_cast<carrier_uint>(
                 cache >> (64 - num_significand_bits<float>() - 2 - beta)) +
 ) /
@@ @@ -346,7 +350,7 @@ template <> struct cache_accessor<double @@
   using carrier_uint = float_info<double>::carrier_uint;
   using cache_entry_type = uint128_fallback;
-  static uint128_fallback get_cached_power(int k) noexcept {
+  static auto get_cached_power(int k) noexcept -> uint128_fallback {
     FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
                "k is out of range");
@@ @@ -985,8 +989,7 @@ template <> struct cache_accessor<double @@
       {0xe0accfa875af45a7, 0x93eb1b80a33b8606},
       {0x8c6c01c9498d8b88, 0xbc72f130660533c4},
       {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
       { 0xdb68c2ca82ed2a05,
 xa67398db9f6820e2 }
       {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2},
 #else
       {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
       {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
@@ @@ -1071,19 +1074,22 @@ template <> struct cache_accessor<double @@
     bool is_integer;
   };
   static compute_mul_result compute_mul(
       carrier_uint u, const cache_entry_type& cache) noexcept {
   static auto compute_mul(carrier_uint u,
                           const cache_entry_type& cache) noexcept
       -> compute_mul_result {
     auto r = umul192_upper128(u, cache);
     return {r.high(), r.low() == 0};
+  }
   static uint32_t compute_delta(cache_entry_type const& cache,
                                 int beta) noexcept {
   static auto compute_delta(cache_entry_type const& cache, int beta) noexcept
       -> uint32_t {
     return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
+  }
   static compute_mul_parity_result compute_mul_parity(
       carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
   static auto compute_mul_parity(carrier_uint two_f,
                                  const cache_entry_type& cache,
                                  int beta) noexcept
       -> compute_mul_parity_result {
     FMT_ASSERT(beta >= 1, "");
     FMT_ASSERT(beta < 64, "");
@@ @@ -1092,35 +1098,35 @@ template <> struct cache_accessor<double @@
             ((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
+  }
   static carrier_uint compute_left_endpoint_for_shorter_interval_case(
       const cache_entry_type& cache, int beta) noexcept {
   static auto compute_left_endpoint_for_shorter_interval_case(
       const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return (cache.high() -
             (cache.high() >> (num_significand_bits<double>() + 2))) >>
            (64 - num_significand_bits<double>() - 1 - beta);
+  }
   static carrier_uint compute_right_endpoint_for_shorter_interval_case(
       const cache_entry_type& cache, int beta) noexcept {
   static auto compute_right_endpoint_for_shorter_interval_case(
       const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return (cache.high() +
             (cache.high() >> (num_significand_bits<double>() + 1))) >>
            (64 - num_significand_bits<double>() - 1 - beta);
+  }
   static carrier_uint compute_round_up_for_shorter_interval_case(
       const cache_entry_type& cache, int beta) noexcept {
   static auto compute_round_up_for_shorter_interval_case(
       const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) +
 ) /
 ;
+  }
 };
-FMT_FUNC uint128_fallback get_cached_power(int k) noexcept {
+FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback {
   return cache_accessor<double>::get_cached_power(k);
+}
 // Various integer checks
 template <typename T>
-bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
+auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool {
   const int case_shorter_interval_left_endpoint_lower_threshold = 2;
   const int case_shorter_interval_left_endpoint_upper_threshold = 3;
   return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
@@ @@ -1128,16 +1134,12 @@ bool is_left_endpoint_integer_shorter_in @@
+}
 // Remove trailing zeros from n and return the number of zeros removed (float)
 FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept {
+FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) 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 =
       static_cast<uint32_t>(uint64_t(mod_inv_5) * mod_inv_5);
   constexpr uint32_t mod_inv_5 = 0xcccccccd;
   constexpr uint32_t mod_inv_25 = 0xc28f5c29;  // = mod_inv_5 * mod_inv_5
   int s = 0;
   while (true) {
     auto q = rotr(n * mod_inv_25, 2);
     if (q > max_value<uint32_t>() / 100) break;
@@ @@ -1162,32 +1164,17 @@ FMT_INLINE int remove_trailing_zeros(uin @@
   // Is n is divisible by 10^8?
   if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) {
     // If yes, work with the quotient.
+    // If yes, work with the quotient...
     auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64));
     const uint32_t mod_inv_5 = 0xcccccccd;
     const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
     int s = 8;
     while (true) {
       auto q = rotr(n32 * mod_inv_25, 2);
       if (q > max_value<uint32_t>() / 100) break;
       n32 = q;
       s += 2;
+    }
     auto q = rotr(n32 * mod_inv_5, 1);
     if (q <= max_value<uint32_t>() / 10) {
       n32 = q;
       s |= 1;
+    }
     // ... and use the 32 bit variant of the function
     int s = remove_trailing_zeros(n32, 8);
     n = n32;
     return s;
+  }
   // If n is not divisible by 10^8, work with n itself.
   const uint64_t mod_inv_5 = 0xcccccccccccccccd;
   const uint64_t mod_inv_25 = mod_inv_5 * mod_inv_5;
   constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd;
   constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29;  // mod_inv_5 * mod_inv_5
   int s = 0;
   while (true) {
@@ @@ -1253,7 +1240,7 @@ FMT_INLINE decimal_fp<T> shorter_interva @@
   return ret_value;
+}
-template <typename T> decimal_fp<T> to_decimal(T x) noexcept {
+template <typename T> auto to_decimal(T x) noexcept -> decimal_fp<T> {
   // Step 1: integer promotion & Schubfach multiplier calculation.
   using carrier_uint = typename float_info<T>::carrier_uint;
@@ @@ -1392,14 +1379,14 @@ template <> struct formatter<detail::big @@
     for (auto i = n.bigits_.size(); i > 0; --i) {
       auto value = n.bigits_[i - 1u];
       if (first) {
         out = format_to(out, FMT_STRING("{:x}"), value);
+        out = fmt::format_to(out, FMT_STRING("{:x}"), value);
         first = false;
         continue;
+      }
       out = format_to(out, FMT_STRING("{:08x}"), value);
+      out = fmt::format_to(out, FMT_STRING("{:08x}"), value);
+    }
     if (n.exp_ > 0)
       out = format_to(out, FMT_STRING("p{}"),
+      out = fmt::format_to(out, FMT_STRING("p{}"),
                       n.exp_ * detail::bigint::bigit_bits);
     return out;
+  }
@@ @@ -1436,7 +1423,7 @@ FMT_FUNC void report_system_error(int er @@
   report_error(format_system_error, error_code, message);
+}
-FMT_FUNC std::string vformat(string_view fmt, format_args args) {
+FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
   // Don't optimize the "{}" case to keep the binary size small and because it
   // can be better optimized in fmt::format anyway.
   auto buffer = memory_buffer();
@@ @@ -1445,33 +1432,38 @@ FMT_FUNC std::string vformat(string_view @@
+}
 namespace detail {
 #ifndef _WIN32
 FMT_FUNC bool write_console(std::FILE*, string_view) { return false; }
 #if !defined(_WIN32) || defined(FMT_WINDOWS_NO_WCHAR)
 FMT_FUNC auto write_console(int, string_view) -> bool { return false; }
 #else
 using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
 extern "C" __declspec(dllimport) int __stdcall WriteConsoleW(  //
     void*, const void*, dword, dword*, void*);
 FMT_FUNC bool write_console(std::FILE* f, string_view text) {
   auto fd = _fileno(f);
   if (!_isatty(fd)) return false;
 FMT_FUNC bool write_console(int fd, string_view text) {
   auto u16 = utf8_to_utf16(text);
   auto written = dword();
   return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
-                       static_cast<uint32_t>(u16.size()), &written, nullptr);
+                       static_cast<dword>(u16.size()), nullptr, nullptr) != 0;
+}
 #endif
 #ifdef _WIN32
 // Print assuming legacy (non-Unicode) encoding.
 FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
   auto buffer = memory_buffer();
   detail::vformat_to(buffer, fmt,
                      basic_format_args<buffer_context<char>>(args));
   fwrite_fully(buffer.data(), 1, buffer.size(), f);
   detail::vformat_to(buffer, fmt, args);
   fwrite_fully(buffer.data(), buffer.size(), f);
+}
 #endif
 FMT_FUNC void print(std::FILE* f, string_view text) {
   if (!write_console(f, text)) fwrite_fully(text.data(), 1, text.size(), f);
 #ifdef _WIN32
   int fd = _fileno(f);
   if (_isatty(fd)) {
     std::fflush(f);
     if (write_console(fd, text)) return;
+  }
 #endif
   fwrite_fully(text.data(), text.size(), f);
+}
 }  // namespace detail

src/3rdparty/fmt/format.h

➞

Show inline comments

@@ @@ -43,14 +43,15 @@ @@
 #include <system_error>      // std::system_error
 #ifdef __cpp_lib_bit_cast
-#  include <bit>  // std::bitcast
+#  include <bit>  // std::bit_cast
 #endif
 #include "core.h"
 #ifndef FMT_BEGIN_DETAIL_NAMESPACE
 #  define FMT_BEGIN_DETAIL_NAMESPACE namespace detail {
 #  define FMT_END_DETAIL_NAMESPACE }
 #if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L
 #  define FMT_INLINE_VARIABLE inline
 #else
 #  define FMT_INLINE_VARIABLE
 #endif
 #if FMT_HAS_CPP17_ATTRIBUTE(fallthrough)
@@ @@ -78,16 +79,25 @@ @@
 #  endif
 #endif
 #if FMT_GCC_VERSION
 #  define FMT_GCC_VISIBILITY_HIDDEN __attribute__((visibility("hidden")))
 #else
 #  define FMT_GCC_VISIBILITY_HIDDEN
 #ifndef FMT_NO_UNIQUE_ADDRESS
 #  if FMT_CPLUSPLUS >= 202002L
 #    if FMT_HAS_CPP_ATTRIBUTE(no_unique_address)
 #      define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]]
 // VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485)
 #    elif (FMT_MSC_VERSION >= 1929) && !FMT_CLANG_VERSION
 #      define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
 #    endif
 #  endif
 #endif
 #ifdef __NVCC__
 #  define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
 #ifndef FMT_NO_UNIQUE_ADDRESS
 #  define FMT_NO_UNIQUE_ADDRESS
 #endif
 // Visibility when compiled as a shared library/object.
 #if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
 #  define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value)
 #else
-#  define FMT_CUDA_VERSION 0
+#  define FMT_SO_VISIBILITY(value)
 #endif
 #ifdef __has_builtin
@@ @@ -121,9 +131,7 @@ FMT_END_NAMESPACE @@
 #    endif
 #  else
 #    define FMT_THROW(x)               \
       do {                             \
         FMT_ASSERT(false, (x).what()); \
       } while (false)
       ::fmt::detail::assert_fail(__FILE__, __LINE__, (x).what())
 #  endif
 #endif
@@ @@ -145,7 +153,10 @@ FMT_END_NAMESPACE @@
 #ifndef FMT_USE_USER_DEFINED_LITERALS
 // EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs.
 #  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \
 //
 // GCC before 4.9 requires a space in `operator"" _a` which is invalid in later
 // compiler versions.
 #  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 409 || \
        FMT_MSC_VERSION >= 1900) &&                                     \
       (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480)
 #    define FMT_USE_USER_DEFINED_LITERALS 1
@@ @@ -266,19 +277,6 @@ FMT_END_NAMESPACE @@
 #endif
 FMT_BEGIN_NAMESPACE
 template <typename...> struct disjunction : std::false_type {};
 template <typename P> struct disjunction<P> : P {};
 template <typename P1, typename... Pn>
 struct disjunction<P1, Pn...>
     : conditional_t<bool(P1::value), P1, disjunction<Pn...>> {};
 template <typename...> struct conjunction : std::true_type {};
 template <typename P> struct conjunction<P> : P {};
 template <typename P1, typename... Pn>
 struct conjunction<P1, Pn...>
     : conditional_t<bool(P1::value), conjunction<Pn...>, P1> {};
 namespace detail {
 FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
@@ @@ -300,37 +298,6 @@ template <typename CharT, CharT... C> @@
 constexpr CharT string_literal<CharT, C...>::value[sizeof...(C)];
 #endif
 template <typename Streambuf> class formatbuf : public Streambuf {
  private:
   using char_type = typename Streambuf::char_type;
   using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
   using int_type = typename Streambuf::int_type;
   using traits_type = typename Streambuf::traits_type;
   buffer<char_type>& buffer_;
  public:
   explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
  protected:
   // The put area is always empty. This makes the implementation simpler and has
   // the advantage that the streambuf and the buffer are always in sync and
   // sputc never writes into uninitialized memory. A disadvantage is that each
   // call to sputc always results in a (virtual) call to overflow. There is no
   // disadvantage here for sputn since this always results in a call to xsputn.
   auto overflow(int_type ch) -> int_type override {
     if (!traits_type::eq_int_type(ch, traits_type::eof()))
       buffer_.push_back(static_cast<char_type>(ch));
     return ch;
+  }
   auto xsputn(const char_type* s, streamsize count) -> streamsize override {
     buffer_.append(s, s + count);
     return count;
+  }
 };
 // Implementation of std::bit_cast for pre-C++20.
 template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) == sizeof(From))>
 FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To {
@@ @@ -362,14 +329,12 @@ class uint128_fallback { @@
  private:
   uint64_t lo_, hi_;
   friend uint128_fallback umul128(uint64_t x, uint64_t y) noexcept;
  public:
   constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {}
   constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {}
   constexpr uint64_t high() const noexcept { return hi_; }
   constexpr uint64_t low() const noexcept { return lo_; }
   constexpr auto high() const noexcept -> uint64_t { return hi_; }
   constexpr auto low() const noexcept -> uint64_t { return lo_; }
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
   constexpr explicit operator T() const {
@@ @@ -445,7 +410,7 @@ class uint128_fallback { @@
     hi_ &= n.hi_;
+  }
-  FMT_CONSTEXPR20 uint128_fallback& operator+=(uint64_t n) noexcept {
+  FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& {
     if (is_constant_evaluated()) {
       lo_ += n;
       hi_ += (lo_ < n ? 1 : 0);
@@ @@ -536,6 +501,8 @@ FMT_INLINE void assume(bool condition) { @@
   (void)condition;
 #if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION
   __builtin_assume(condition);
 #elif FMT_GCC_VERSION
   if (!condition) __builtin_unreachable();
 #endif
+}
@@ @@ -554,20 +521,6 @@ inline auto get_data(Container& c) -> ty @@
   return c.data();
+}
 #if defined(_SECURE_SCL) && _SECURE_SCL
 // Make a checked iterator to avoid MSVC warnings.
 template <typename T> using checked_ptr = stdext::checked_array_iterator<T*>;
 template <typename T>
 constexpr auto make_checked(T* p, size_t size) -> checked_ptr<T> {
   return {p, size};
+}
 #else
 template <typename T> using checked_ptr = T*;
 template <typename T> constexpr auto make_checked(T* p, size_t) -> T* {
   return p;
+}
 #endif
 // Attempts to reserve space for n extra characters in the output range.
 // Returns a pointer to the reserved range or a reference to it.
 template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
@@ @@ -575,12 +528,12 @@ template <typename Container, FMT_ENABLE @@
 __attribute__((no_sanitize("undefined")))
 #endif
 inline auto
 reserve(std::back_insert_iterator<Container> it, size_t n)
     -> checked_ptr<typename Container::value_type> {
 reserve(std::back_insert_iterator<Container> it, size_t n) ->
     typename Container::value_type* {
   Container& c = get_container(it);
   size_t size = c.size();
   c.resize(size + n);
-  return make_checked(get_data(c) + size, n);
   return get_data(c) + size;
+}
 template <typename T>
@@ @@ -612,8 +565,8 @@ template <typename T> auto to_pointer(bu @@
+}
 template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
 inline auto base_iterator(std::back_insert_iterator<Container>& it,
                           checked_ptr<typename Container::value_type>)
 inline auto base_iterator(std::back_insert_iterator<Container> it,
                           typename Container::value_type*)
     -> std::back_insert_iterator<Container> {
   return it;
+}
@@ @@ -747,7 +700,7 @@ inline auto compute_width(basic_string_v @@
+}
 // Computes approximate display width of a UTF-8 string.
-FMT_CONSTEXPR inline size_t compute_width(string_view s) {
+FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t {
   size_t num_code_points = 0;
   // It is not a lambda for compatibility with C++14.
   struct count_code_points {
@@ @@ -794,12 +747,17 @@ inline auto code_point_index(basic_strin @@
 // Calculates the index of the nth code point in a UTF-8 string.
 inline auto code_point_index(string_view s, size_t n) -> size_t {
   const char* data = s.data();
   size_t num_code_points = 0;
   for (size_t i = 0, size = s.size(); i != size; ++i) {
     if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) return i;
+  }
   return s.size();
   size_t result = s.size();
   const char* begin = s.begin();
   for_each_codepoint(s, [begin, &n, &result](uint32_t, string_view sv) {
     if (n != 0) {
       --n;
       return true;
+    }
     result = to_unsigned(sv.begin() - begin);
     return false;
   });
   return result;
+}
 inline auto code_point_index(basic_string_view<char8_type> s, size_t n)
@@ @@ -881,7 +839,7 @@ void buffer<T>::append(const U* begin, c @@
     try_reserve(size_ + count);
     auto free_cap = capacity_ - size_;
     if (free_cap < count) count = free_cap;
-    std::uninitialized_copy_n(begin, count, make_checked(ptr_ + size_, count));
     std::uninitialized_copy_n(begin, count, ptr_ + size_);
     size_ += count;
     begin += count;
+  }
@@ @@ -909,7 +867,7 @@ enum { inline_buffer_size = 500 }; @@
   **Example**::
      auto out = fmt::memory_buffer();
      format_to(std::back_inserter(out), "The answer is {}.", 42);
+     fmt::format_to(std::back_inserter(out), "The answer is {}.", 42);
   This will append the following output to the ``out`` object:
@@ @@ -926,8 +884,8 @@ class basic_memory_buffer final : public @@
  private:
   T store_[SIZE];
   // Don't inherit from Allocator avoid generating type_info for it.
   Allocator alloc_;
   // Don't inherit from Allocator to avoid generating type_info for it.
   FMT_NO_UNIQUE_ADDRESS Allocator alloc_;
   // Deallocate memory allocated by the buffer.
   FMT_CONSTEXPR20 void deallocate() {
@@ @@ -948,9 +906,10 @@ class basic_memory_buffer final : public @@
     T* old_data = this->data();
     T* new_data =
         std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
     // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481).
     detail::assume(this->size() <= new_capacity);
     // The following code doesn't throw, so the raw pointer above doesn't leak.
     std::uninitialized_copy(old_data, old_data + this->size(),
                             detail::make_checked(new_data, new_capacity));
     std::uninitialized_copy_n(old_data, this->size(), new_data);
     this->set(new_data, new_capacity);
     // deallocate must not throw according to the standard, but even if it does,
     // the buffer already uses the new storage and will deallocate it in
@@ @@ -978,8 +937,7 @@ class basic_memory_buffer final : public @@
     size_t size = other.size(), capacity = other.capacity();
     if (data == other.store_) {
       this->set(store_, capacity);
       detail::copy_str<T>(other.store_, other.store_ + size,
                           detail::make_checked(store_, capacity));
       detail::copy_str<T>(other.store_, other.store_ + size, store_);
     } else {
       this->set(data, capacity);
       // Set pointer to the inline array so that delete is not called
@@ @@ -1025,7 +983,6 @@ class basic_memory_buffer final : public @@
   /** Increases the buffer capacity to *new_capacity*. */
   void reserve(size_t new_capacity) { this->try_reserve(new_capacity); }
   // Directly append data into the buffer
   using detail::buffer<T>::append;
   template <typename ContiguousRange>
   void append(const ContiguousRange& range) {
@@ @@ -1041,9 +998,10 @@ struct is_contiguous<basic_memory_buffer @@
 FMT_END_EXPORT
 namespace detail {
-FMT_API bool write_console(std::FILE* f, string_view text);
+FMT_API auto write_console(int fd, string_view text) -> bool;
 FMT_API void print(std::FILE*, string_view);
 }  // namespace detail
 FMT_BEGIN_EXPORT
 // Suppress a misleading warning in older versions of clang.
@@ @@ -1052,7 +1010,7 @@ FMT_BEGIN_EXPORT @@
 #endif
 /** An error reported from a formatting function. */
-class FMT_API format_error : public std::runtime_error {
+class FMT_SO_VISIBILITY("default") format_error : public std::runtime_error {
  public:
   using std::runtime_error::runtime_error;
 };
@@ @@ -1128,7 +1086,7 @@ template <typename Locale> class format_ @@
+  }
 };
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 // Returns true if value is negative, false otherwise.
 // Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
@@ @@ -1160,12 +1118,12 @@ template <typename T> @@
 using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>;
 #define FMT_POWERS_OF_10(factor)                                             \
   factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
       (factor)*1000000, (factor)*10000000, (factor)*100000000,               \
       (factor)*1000000000
   factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
       (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
       (factor) * 100000000, (factor) * 1000000000
 // Converts value in the range [0, 100) to a string.
-constexpr const char* digits2(size_t value) {
+constexpr auto digits2(size_t value) -> const char* {
   // GCC generates slightly better code when value is pointer-size.
   return &"0001020304050607080910111213141516171819"
          "2021222324252627282930313233343536373839"
@@ @@ -1175,7 +1133,7 @@ constexpr const char* digits2(size_t val @@
+}
 // Sign is a template parameter to workaround a bug in gcc 4.8.
-template <typename Char, typename Sign> constexpr Char sign(Sign s) {
+template <typename Char, typename Sign> constexpr auto sign(Sign s) -> Char {
 #if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 604
   static_assert(std::is_same<Sign, sign_t>::value, "");
 #endif
@@ @@ -1393,14 +1351,14 @@ FMT_CONSTEXPR auto format_uint(Char* buf @@
+}
 template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
 inline auto format_uint(It out, UInt value, int num_digits, bool upper = false)
     -> It {
 FMT_CONSTEXPR inline auto format_uint(It out, UInt value, int num_digits,
                                       bool upper = false) -> It {
   if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
     format_uint<BASE_BITS>(ptr, value, num_digits, upper);
     return out;
+  }
   // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
   char buffer[num_bits<UInt>() / BASE_BITS + 1];
+  char buffer[num_bits<UInt>() / BASE_BITS + 1] = {};
   format_uint<BASE_BITS>(buffer, value, num_digits, upper);
   return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out);
+}
@@ @@ -1418,47 +1376,54 @@ class utf8_to_utf16 { @@
   auto str() const -> std::wstring { return {&buffer_[0], size()}; }
 };
 enum class to_utf8_error_policy { abort, replace };
 // A converter from UTF-16/UTF-32 (host endian) to UTF-8.
 template <typename WChar, typename Buffer = memory_buffer>
 class unicode_to_utf8 {
 template <typename WChar, typename Buffer = memory_buffer> class to_utf8 {
  private:
   Buffer buffer_;
  public:
   unicode_to_utf8() {}
   explicit unicode_to_utf8(basic_string_view<WChar> s) {
   to_utf8() {}
   explicit to_utf8(basic_string_view<WChar> s,
                    to_utf8_error_policy policy = to_utf8_error_policy::abort) {
     static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4,
                   "Expect utf16 or utf32");
     if (!convert(s))
     if (!convert(s, policy))
       FMT_THROW(std::runtime_error(sizeof(WChar) == 2 ? "invalid utf16"
                                                       : "invalid utf32"));
+  }
   operator string_view() const { return string_view(&buffer_[0], size()); }
   size_t size() const { return buffer_.size() - 1; }
   const char* c_str() const { return &buffer_[0]; }
   std::string str() const { return std::string(&buffer_[0], size()); }
   auto size() const -> size_t { return buffer_.size() - 1; }
   auto c_str() const -> const char* { return &buffer_[0]; }
   auto str() const -> std::string { return std::string(&buffer_[0], size()); }
   // Performs conversion returning a bool instead of throwing exception on
   // conversion error. This method may still throw in case of memory allocation
   // error.
   bool convert(basic_string_view<WChar> s) {
     if (!convert(buffer_, s)) return false;
   auto convert(basic_string_view<WChar> s,
                to_utf8_error_policy policy = to_utf8_error_policy::abort)
       -> bool {
     if (!convert(buffer_, s, policy)) return false;
     buffer_.push_back(0);
     return true;
+  }
   static bool convert(Buffer& buf, basic_string_view<WChar> s) {
   static auto convert(Buffer& buf, basic_string_view<WChar> s,
                       to_utf8_error_policy policy = to_utf8_error_policy::abort)
       -> bool {
     for (auto p = s.begin(); p != s.end(); ++p) {
       uint32_t c = static_cast<uint32_t>(*p);
       if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) {
         // surrogate pair
+        // Handle a surrogate pair.
         ++p;
         if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) {
           return false;
+        }
           if (policy == to_utf8_error_policy::abort) return false;
           buf.append(string_view("\xEF\xBF\xBD"));
           --p;
         } else {
         c = (c << 10) + static_cast<uint32_t>(*p) - 0x35fdc00;
+      }
       if (c < 0x80) {
+      } else if (c < 0x80) {
         buf.push_back(static_cast<char>(c));
       } else if (c < 0x800) {
         buf.push_back(static_cast<char>(0xc0 | (c >> 6)));
@@ @@ -1481,14 +1446,14 @@ class unicode_to_utf8 { @@
 };
 // Computes 128-bit result of multiplication of two 64-bit unsigned integers.
-inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept {
+inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback {
 #if FMT_USE_INT128
   auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
   return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
 #elif defined(_MSC_VER) && defined(_M_X64)
   auto result = uint128_fallback();
   result.lo_ = _umul128(x, y, &result.hi_);
   return result;
   auto hi = uint64_t();
   auto lo = _umul128(x, y, &hi);
   return {hi, lo};
 #else
   const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
@@ @@ -1512,19 +1477,19 @@ inline uint128_fallback umul128(uint64_t @@
 namespace dragonbox {
 // Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from
 // https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1.
-inline int floor_log10_pow2(int e) noexcept {
+inline auto floor_log10_pow2(int e) noexcept -> int {
   FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
   static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
   return (e * 315653) >> 20;
+}
-inline int floor_log2_pow10(int e) noexcept {
+inline auto floor_log2_pow10(int e) noexcept -> int {
   FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
   return (e * 1741647) >> 19;
+}
 // Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
-inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept {
+inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t {
 #if FMT_USE_INT128
   auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
   return static_cast<uint64_t>(p >> 64);
@@ @@ -1537,14 +1502,14 @@ inline uint64_t umul128_upper64(uint64_t @@
 // Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a
 // 128-bit unsigned integer.
 inline uint128_fallback umul192_upper128(uint64_t x,
                                          uint128_fallback y) noexcept {
 inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept
     -> uint128_fallback {
   uint128_fallback r = umul128(x, y.high());
   r += umul128_upper64(x, y.low());
   return r;
+}
-FMT_API uint128_fallback get_cached_power(int k) noexcept;
+FMT_API auto get_cached_power(int k) noexcept -> uint128_fallback;
 // Type-specific information that Dragonbox uses.
 template <typename T, typename Enable = void> struct float_info;
@@ @@ -1598,14 +1563,14 @@ template <typename T> FMT_API auto to_de @@
 }  // namespace dragonbox
 // Returns true iff Float has the implicit bit which is not stored.
-template <typename Float> constexpr bool has_implicit_bit() {
+template <typename Float> constexpr auto has_implicit_bit() -> bool {
   // An 80-bit FP number has a 64-bit significand an no implicit bit.
   return std::numeric_limits<Float>::digits != 64;
+}
 // Returns the number of significand bits stored in Float. The implicit bit is
 // not counted since it is not stored.
-template <typename Float> constexpr int num_significand_bits() {
+template <typename Float> constexpr auto num_significand_bits() -> int {
   // std::numeric_limits may not support __float128.
   return is_float128<Float>() ? 112
                               : (std::numeric_limits<Float>::digits -
@@ @@ -1698,7 +1663,7 @@ using fp = basic_fp<unsigned long long>; @@
 // Normalizes the value converted from double and multiplied by (1 << SHIFT).
 template <int SHIFT = 0, typename F>
-FMT_CONSTEXPR basic_fp<F> normalize(basic_fp<F> value) {
+FMT_CONSTEXPR auto normalize(basic_fp<F> value) -> basic_fp<F> {
   // Handle subnormals.
   const auto implicit_bit = F(1) << num_significand_bits<double>();
   const auto shifted_implicit_bit = implicit_bit << SHIFT;
@@ @@ -1715,7 +1680,7 @@ FMT_CONSTEXPR basic_fp<F> normalize(basi @@
+}
 // Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
-FMT_CONSTEXPR inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
+FMT_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t {
 #if FMT_USE_INT128
   auto product = static_cast<__uint128_t>(lhs) * rhs;
   auto f = static_cast<uint64_t>(product >> 64);
@@ @@ -1732,124 +1697,13 @@ FMT_CONSTEXPR inline uint64_t multiply(u @@
 #endif
+}
-FMT_CONSTEXPR inline fp operator*(fp x, fp y) {
+FMT_CONSTEXPR inline auto operator*(fp x, fp y) -> fp {
   return {multiply(x.f, y.f), x.e + y.e + 64};
+}
 template <typename T = void> struct basic_data {
   // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
   // These are generated by support/compute-powers.py.
   static constexpr uint64_t pow10_significands[87] = {
 xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
 xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
 xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
 x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
 xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
 xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
 xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
 x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
 xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
 xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
 x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
 xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
 xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
 xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
 x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
 xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
 xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
 x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
 x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
 xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
 xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
 x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
 xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
 xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
 xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
 x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
 xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
 xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
 x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
   };
 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
 #  pragma GCC diagnostic push
 #  pragma GCC diagnostic ignored "-Wnarrowing"
 #endif
   // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
   // to significands above.
   static constexpr int16_t pow10_exponents[87] = {
       -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
       -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688, -661,
       -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396, -369,
       -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103, -77,
       -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
 ,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
 ,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
 ,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
 #  pragma GCC diagnostic pop
 #endif
   static constexpr uint64_t power_of_10_64[20] = {
 , FMT_POWERS_OF_10(1ULL), FMT_POWERS_OF_10(1000000000ULL),
       10000000000000000000ULL};
   // For checking rounding thresholds.
   // The kth entry is chosen to be the smallest integer such that the
   // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k.
   static constexpr uint32_t fractional_part_rounding_thresholds[8] = {
       2576980378,  // ceil(2^31 + 2^32/10^1)
       2190433321,  // ceil(2^31 + 2^32/10^2)
       2151778616,  // ceil(2^31 + 2^32/10^3)
       2147913145,  // ceil(2^31 + 2^32/10^4)
       2147526598,  // ceil(2^31 + 2^32/10^5)
       2147487943,  // ceil(2^31 + 2^32/10^6)
       2147484078,  // ceil(2^31 + 2^32/10^7)
       2147483691   // ceil(2^31 + 2^32/10^8)
   };
 };
 #if FMT_CPLUSPLUS < 201703L
 template <typename T> constexpr uint64_t basic_data<T>::pow10_significands[];
 template <typename T> constexpr int16_t basic_data<T>::pow10_exponents[];
 template <typename T> constexpr uint64_t basic_data<T>::power_of_10_64[];
 template <typename T>
 constexpr uint32_t basic_data<T>::fractional_part_rounding_thresholds[];
 #endif
 // This is a struct rather than an alias to avoid shadowing warnings in gcc.
 struct data : basic_data<> {};
 // Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
 // (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
 FMT_CONSTEXPR inline fp get_cached_power(int min_exponent,
                                          int& pow10_exponent) {
   const int shift = 32;
   // log10(2) = 0x0.4d104d427de7fbcc...
   const int64_t significand = 0x4d104d427de7fbcc;
   int index = static_cast<int>(
       ((min_exponent + fp::num_significand_bits - 1) * (significand >> shift) +
        ((int64_t(1) << shift) - 1))  // ceil
       >> 32                          // arithmetic shift
   );
   // Decimal exponent of the first (smallest) cached power of 10.
   const int first_dec_exp = -348;
   // Difference between 2 consecutive decimal exponents in cached powers of 10.
   const int dec_exp_step = 8;
   index = (index - first_dec_exp - 1) / dec_exp_step + 1;
   pow10_exponent = first_dec_exp + index * dec_exp_step;
   // Using *(x + index) instead of x[index] avoids an issue with some compilers
   // using the EDG frontend (e.g. nvhpc/22.3 in C++17 mode).
   return {*(data::pow10_significands + index),
           *(data::pow10_exponents + index)};
+}
 template <typename T>
 template <typename T, bool doublish = num_bits<T>() == num_bits<double>()>
 using convert_float_result =
     conditional_t<std::is_same<T, float>::value ||
                       std::numeric_limits<T>::digits ==
                           std::numeric_limits<double>::digits,
                   double, T>;
     conditional_t<std::is_same<T, float>::value || doublish, double, T>;
 template <typename T>
 constexpr auto convert_float(T value) -> convert_float_result<T> {
@@ @@ -1970,7 +1824,7 @@ inline auto find_escape(const char* begi @@
   [] {                                                                        \
     /* Use the hidden visibility as a workaround for a GCC bug (#1973). */    \
     /* Use a macro-like name to avoid shadowing warnings. */                  \
-    struct FMT_GCC_VISIBILITY_HIDDEN FMT_COMPILE_STRING : base {              \
+    struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base {               \
       using char_type FMT_MAYBE_UNUSED = fmt::remove_cvref_t<decltype(s[0])>; \
       FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit                                 \
       operator fmt::basic_string_view<char_type>() const {                    \
@@ @@ -2065,11 +1919,13 @@ auto write_escaped_string(OutputIt out, @@
 template <typename Char, typename OutputIt>
 auto write_escaped_char(OutputIt out, Char v) -> OutputIt {
   Char v_array[1] = {v};
   *out++ = static_cast<Char>('\'');
   if ((needs_escape(static_cast<uint32_t>(v)) && v != static_cast<Char>('"')) ||
       v == static_cast<Char>('\'')) {
     out = write_escaped_cp(
         out, find_escape_result<Char>{&v, &v + 1, static_cast<uint32_t>(v)});
     out = write_escaped_cp(out,
                            find_escape_result<Char>{v_array, v_array + 1,
                                                     static_cast<uint32_t>(v)});
   } else {
     *out++ = v;
+  }
@@ @@ -2158,10 +2014,10 @@ template <typename Char> class digit_gro @@
     std::string::const_iterator group;
     int pos;
   };
-  next_state initial_state() const { return {grouping_.begin(), 0}; }
+  auto initial_state() const -> next_state { return {grouping_.begin(), 0}; }
   // Returns the next digit group separator position.
-  int next(next_state& state) const {
+  auto next(next_state& state) const -> int {
     if (thousands_sep_.empty()) return max_value<int>();
     if (state.group == grouping_.end()) return state.pos += grouping_.back();
     if (*state.group <= 0 || *state.group == max_value<char>())
@@ @@ -2180,9 +2036,9 @@ template <typename Char> class digit_gro @@
   digit_grouping(std::string grouping, std::basic_string<Char> sep)
       : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {}
   bool has_separator() const { return !thousands_sep_.empty(); }
   int count_separators(int num_digits) const {
   auto has_separator() const -> bool { return !thousands_sep_.empty(); }
   auto count_separators(int num_digits) const -> int {
     int count = 0;
     auto state = initial_state();
     while (num_digits > next(state)) ++count;
@@ @@ -2191,7 +2047,7 @@ template <typename Char> class digit_gro @@
   // Applies grouping to digits and write the output to out.
   template <typename Out, typename C>
-  Out apply(Out out, basic_string_view<C> digits) const {
+  auto apply(Out out, basic_string_view<C> digits) const -> Out {
     auto num_digits = static_cast<int>(digits.size());
     auto separators = basic_memory_buffer<int>();
     separators.push_back(0);
@@ @@ -2214,24 +2070,66 @@ template <typename Char> class digit_gro @@
+  }
 };
 FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {
   prefix |= prefix != 0 ? value << 8 : value;
   prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
+}
 // Writes a decimal integer with digit grouping.
 template <typename OutputIt, typename UInt, typename Char>
 auto write_int(OutputIt out, UInt value, unsigned prefix,
                const format_specs<Char>& specs,
                const digit_grouping<Char>& grouping) -> OutputIt {
   static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
   int num_digits = count_digits(value);
   char digits[40];
   format_decimal(digits, value, num_digits);
   unsigned size = to_unsigned((prefix != 0 ? 1 : 0) + num_digits +
                               grouping.count_separators(num_digits));
   int num_digits = 0;
   auto buffer = memory_buffer();
   switch (specs.type) {
   case presentation_type::none:
   case presentation_type::dec: {
     num_digits = count_digits(value);
     format_decimal<char>(appender(buffer), value, num_digits);
     break;
+  }
   case presentation_type::hex_lower:
   case presentation_type::hex_upper: {
     bool upper = specs.type == presentation_type::hex_upper;
     if (specs.alt)
       prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
     num_digits = count_digits<4>(value);
     format_uint<4, char>(appender(buffer), value, num_digits, upper);
     break;
+  }
   case presentation_type::bin_lower:
   case presentation_type::bin_upper: {
     bool upper = specs.type == presentation_type::bin_upper;
     if (specs.alt)
       prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
     num_digits = count_digits<1>(value);
     format_uint<1, char>(appender(buffer), value, num_digits);
     break;
+  }
   case presentation_type::oct: {
     num_digits = count_digits<3>(value);
     // Octal prefix '0' is counted as a digit, so only add it if precision
     // is not greater than the number of digits.
     if (specs.alt && specs.precision <= num_digits && value != 0)
       prefix_append(prefix, '0');
     format_uint<3, char>(appender(buffer), value, num_digits);
     break;
+  }
   case presentation_type::chr:
     return write_char(out, static_cast<Char>(value), specs);
   default:
     throw_format_error("invalid format specifier");
+  }
   unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) +
                   to_unsigned(grouping.count_separators(num_digits));
   return write_padded<align::right>(
       out, specs, size, size, [&](reserve_iterator<OutputIt> it) {
         if (prefix != 0) {
           char sign = static_cast<char>(prefix);
           *it++ = static_cast<Char>(sign);
+        }
         return grouping.apply(it, string_view(digits, to_unsigned(num_digits)));
         for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
           *it++ = static_cast<Char>(p & 0xff);
         return grouping.apply(it, string_view(buffer.data(), buffer.size()));
       });
+}
@@ @@ -2244,11 +2142,6 @@ inline auto write_loc(OutputIt, loc_valu @@
   return false;
+}
 FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {
   prefix |= prefix != 0 ? value << 8 : value;
   prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
+}
 template <typename UInt> struct write_int_arg {
   UInt abs_value;
   unsigned prefix;
@@ @@ -2395,25 +2288,25 @@ class counting_iterator { @@
   FMT_CONSTEXPR counting_iterator() : count_(0) {}
   FMT_CONSTEXPR size_t count() const { return count_; }
   FMT_CONSTEXPR counting_iterator& operator++() {
   FMT_CONSTEXPR auto count() const -> size_t { return count_; }
   FMT_CONSTEXPR auto operator++() -> counting_iterator& {
     ++count_;
     return *this;
+  }
-  FMT_CONSTEXPR counting_iterator operator++(int) {
+  FMT_CONSTEXPR auto operator++(int) -> counting_iterator {
     auto it = *this;
     ++*this;
     return it;
+  }
   FMT_CONSTEXPR friend counting_iterator operator+(counting_iterator it,
                                                    difference_type n) {
   FMT_CONSTEXPR friend auto operator+(counting_iterator it, difference_type n)
       -> counting_iterator {
     it.count_ += static_cast<size_t>(n);
     return it;
+  }
-  FMT_CONSTEXPR value_type operator*() const { return {}; }
+  FMT_CONSTEXPR auto operator*() const -> value_type { return {}; }
 };
 template <typename Char, typename OutputIt>
@@ @@ -2448,9 +2341,10 @@ template <typename Char, typename Output @@
 FMT_CONSTEXPR auto write(OutputIt out, const Char* s,
                          const format_specs<Char>& specs, locale_ref)
     -> OutputIt {
   return specs.type != presentation_type::pointer
              ? write(out, basic_string_view<Char>(s), specs, {})
              : write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs);
   if (specs.type == presentation_type::pointer)
     return write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs);
   if (!s) throw_format_error("string pointer is null");
   return write(out, basic_string_view<Char>(s), specs, {});
+}
 template <typename Char, typename OutputIt, typename T,
@@ @@ -2475,6 +2369,49 @@ FMT_CONSTEXPR auto write(OutputIt out, T @@
   return base_iterator(out, it);
+}
 // DEPRECATED!
 template <typename Char>
 FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end,
                                format_specs<Char>& specs) -> const Char* {
   FMT_ASSERT(begin != end, "");
   auto align = align::none;
   auto p = begin + code_point_length(begin);
   if (end - p <= 0) p = begin;
   for (;;) {
     switch (to_ascii(*p)) {
     case '<':
       align = align::left;
       break;
     case '>':
       align = align::right;
       break;
     case '^':
       align = align::center;
       break;
+    }
     if (align != align::none) {
       if (p != begin) {
         auto c = *begin;
         if (c == '}') return begin;
         if (c == '{') {
           throw_format_error("invalid fill character '{'");
           return begin;
+        }
         specs.fill = {begin, to_unsigned(p - begin)};
         begin = p + 1;
       } else {
         ++begin;
+      }
       break;
     } else if (p == begin) {
       break;
+    }
     p = begin;
+  }
   specs.align = align;
   return begin;
+}
 // A floating-point presentation format.
 enum class float_format : unsigned char {
   general,  // General: exponent notation or fixed point based on magnitude.
@@ @@ -2493,9 +2430,8 @@ struct float_specs { @@
   bool showpoint : 1;
 };
 template <typename ErrorHandler = error_handler, typename Char>
 FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs,
                                          ErrorHandler&& eh = {})
 template <typename Char>
 FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs)
     -> float_specs {
   auto result = float_specs();
   result.showpoint = specs.alt;
@@ @@ -2531,7 +2467,7 @@ FMT_CONSTEXPR auto parse_float_type_spec @@
     result.format = float_format::hex;
     break;
   default:
-    eh.on_error("invalid format specifier");
+    throw_format_error("invalid format specifier");
     break;
+  }
   return result;
@@ @@ -2770,12 +2706,12 @@ template <typename Char> class fallback_ @@
  public:
   constexpr fallback_digit_grouping(locale_ref, bool) {}
   constexpr bool has_separator() const { return false; }
   constexpr int count_separators(int) const { return 0; }
   constexpr auto has_separator() const -> bool { return false; }
   constexpr auto count_separators(int) const -> int { return 0; }
   template <typename Out, typename C>
-  constexpr Out apply(Out out, basic_string_view<C>) const {
+  constexpr auto apply(Out out, basic_string_view<C>) const -> Out {
     return out;
+  }
 };
@@ @@ -2794,7 +2730,7 @@ FMT_CONSTEXPR20 auto write_float(OutputI @@
+  }
+}
-template <typename T> constexpr bool isnan(T value) {
+template <typename T> constexpr auto isnan(T value) -> bool {
   return !(value >= value);  // std::isnan doesn't support __float128.
+}
@@ @@ -2807,14 +2743,14 @@ struct has_isfinite<T, enable_if_t<sizeo @@
 template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value&&
                                         has_isfinite<T>::value)>
-FMT_CONSTEXPR20 bool isfinite(T value) {
+FMT_CONSTEXPR20 auto isfinite(T value) -> bool {
   constexpr T inf = T(std::numeric_limits<double>::infinity());
   if (is_constant_evaluated())
     return !detail::isnan(value) && value < inf && value > -inf;
   return std::isfinite(value);
+}
 template <typename T, FMT_ENABLE_IF(!has_isfinite<T>::value)>
-FMT_CONSTEXPR bool isfinite(T value) {
+FMT_CONSTEXPR auto isfinite(T value) -> bool {
   T inf = T(std::numeric_limits<double>::infinity());
   // std::isfinite doesn't support __float128.
   return !detail::isnan(value) && value < inf && value > -inf;
@@ @@ -2833,78 +2769,6 @@ FMT_INLINE FMT_CONSTEXPR bool signbit(T @@
   return std::signbit(static_cast<double>(value));
+}
 enum class round_direction { unknown, up, down };
 // Given the divisor (normally a power of 10), the remainder = v % divisor for
 // some number v and the error, returns whether v should be rounded up, down, or
 // whether the rounding direction can't be determined due to error.
 // error should be less than divisor / 2.
 FMT_CONSTEXPR inline round_direction get_round_direction(uint64_t divisor,
                                                          uint64_t remainder,
                                                          uint64_t error) {
   FMT_ASSERT(remainder < divisor, "");  // divisor - remainder won't overflow.
   FMT_ASSERT(error < divisor, "");      // divisor - error won't overflow.
   FMT_ASSERT(error < divisor - error, "");  // error * 2 won't overflow.
   // Round down if (remainder + error) * 2 <= divisor.
   if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
     return round_direction::down;
   // Round up if (remainder - error) * 2 >= divisor.
   if (remainder >= error &&
       remainder - error >= divisor - (remainder - error)) {
     return round_direction::up;
+  }
   return round_direction::unknown;
+}
 namespace digits {
 enum result {
   more,  // Generate more digits.
   done,  // Done generating digits.
   error  // Digit generation cancelled due to an error.
 };
+}
 struct gen_digits_handler {
   char* buf;
   int size;
   int precision;
   int exp10;
   bool fixed;
   FMT_CONSTEXPR digits::result on_digit(char digit, uint64_t divisor,
                                         uint64_t remainder, uint64_t error,
                                         bool integral) {
     FMT_ASSERT(remainder < divisor, "");
     buf[size++] = digit;
     if (!integral && error >= remainder) return digits::error;
     if (size < precision) return digits::more;
     if (!integral) {
       // Check if error * 2 < divisor with overflow prevention.
       // The check is not needed for the integral part because error = 1
       // and divisor > (1 << 32) there.
       if (error >= divisor || error >= divisor - error) return digits::error;
     } else {
       FMT_ASSERT(error == 1 && divisor > 2, "");
+    }
     auto dir = get_round_direction(divisor, remainder, error);
     if (dir != round_direction::up)
       return dir == round_direction::down ? digits::done : digits::error;
     ++buf[size - 1];
     for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
       buf[i] = '0';
       ++buf[i - 1];
+    }
     if (buf[0] > '9') {
       buf[0] = '1';
       if (fixed)
         buf[size++] = '0';
       else
         ++exp10;
+    }
     return digits::done;
+  }
 };
 inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) {
   // Adjust fixed precision by exponent because it is relative to decimal
   // point.
@@ @@ -2913,101 +2777,6 @@ inline FMT_CONSTEXPR20 void adjust_preci @@
   precision += exp10;
+}
 // Generates output using the Grisu digit-gen algorithm.
 // error: the size of the region (lower, upper) outside of which numbers
 // definitely do not round to value (Delta in Grisu3).
 FMT_INLINE FMT_CONSTEXPR20 auto grisu_gen_digits(fp value, uint64_t error,
                                                  int& exp,
                                                  gen_digits_handler& handler)
     -> digits::result {
   const fp one(1ULL << -value.e, value.e);
   // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
   // zero because it contains a product of two 64-bit numbers with MSB set (due
   // to normalization) - 1, shifted right by at most 60 bits.
   auto integral = static_cast<uint32_t>(value.f >> -one.e);
   FMT_ASSERT(integral != 0, "");
   FMT_ASSERT(integral == value.f >> -one.e, "");
   // The fractional part of scaled value (p2 in Grisu) c = value % one.
   uint64_t fractional = value.f & (one.f - 1);
   exp = count_digits(integral);  // kappa in Grisu.
   // Non-fixed formats require at least one digit and no precision adjustment.
   if (handler.fixed) {
     adjust_precision(handler.precision, exp + handler.exp10);
     // Check if precision is satisfied just by leading zeros, e.g.
     // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
     if (handler.precision <= 0) {
       if (handler.precision < 0) return digits::done;
       // Divide by 10 to prevent overflow.
       uint64_t divisor = data::power_of_10_64[exp - 1] << -one.e;
       auto dir = get_round_direction(divisor, value.f / 10, error * 10);
       if (dir == round_direction::unknown) return digits::error;
       handler.buf[handler.size++] = dir == round_direction::up ? '1' : '0';
       return digits::done;
+    }
+  }
   // Generate digits for the integral part. This can produce up to 10 digits.
   do {
     uint32_t digit = 0;
     auto divmod_integral = [&](uint32_t divisor) {
       digit = integral / divisor;
       integral %= divisor;
     };
     // This optimization by Milo Yip reduces the number of integer divisions by
     // one per iteration.
     switch (exp) {
     case 10:
       divmod_integral(1000000000);
       break;
     case 9:
       divmod_integral(100000000);
       break;
     case 8:
       divmod_integral(10000000);
       break;
     case 7:
       divmod_integral(1000000);
       break;
     case 6:
       divmod_integral(100000);
       break;
     case 5:
       divmod_integral(10000);
       break;
     case 4:
       divmod_integral(1000);
       break;
     case 3:
       divmod_integral(100);
       break;
     case 2:
       divmod_integral(10);
       break;
     case 1:
       digit = integral;
       integral = 0;
       break;
     default:
       FMT_ASSERT(false, "invalid number of digits");
+    }
     --exp;
     auto remainder = (static_cast<uint64_t>(integral) << -one.e) + fractional;
     auto result = handler.on_digit(static_cast<char>('0' + digit),
                                    data::power_of_10_64[exp] << -one.e,
                                    remainder, error, true);
     if (result != digits::more) return result;
   } while (exp > 0);
   // Generate digits for the fractional part.
   for (;;) {
     fractional *= 10;
     error *= 10;
     char digit = static_cast<char>('0' + (fractional >> -one.e));
     fractional &= one.f - 1;
     --exp;
     auto result = handler.on_digit(digit, one.f, fractional, error, false);
     if (result != digits::more) return result;
+  }
+}
 class bigint {
  private:
   // A bigint is stored as an array of bigits (big digits), with bigit at index
@@ @@ -3018,10 +2787,10 @@ class bigint { @@
   basic_memory_buffer<bigit, bigits_capacity> bigits_;
   int exp_;
-  FMT_CONSTEXPR20 bigit operator[](int index) const {
+  FMT_CONSTEXPR20 auto operator[](int index) const -> bigit {
     return bigits_[to_unsigned(index)];
+  }
-  FMT_CONSTEXPR20 bigit& operator[](int index) {
+  FMT_CONSTEXPR20 auto operator[](int index) -> bigit& {
     return bigits_[to_unsigned(index)];
+  }
@@ @@ -3108,7 +2877,7 @@ class bigint { @@
     auto size = other.bigits_.size();
     bigits_.resize(size);
     auto data = other.bigits_.data();
-    std::copy(data, data + size, make_checked(bigits_.data(), size));
+    copy_str<bigit>(data, data + size, bigits_.data());
     exp_ = other.exp_;
+  }
@@ @@ -3117,11 +2886,11 @@ class bigint { @@
     assign(uint64_or_128_t<Int>(n));
+  }
-  FMT_CONSTEXPR20 int num_bigits() const {
+  FMT_CONSTEXPR20 auto num_bigits() const -> int {
     return static_cast<int>(bigits_.size()) + exp_;
+  }
-  FMT_NOINLINE FMT_CONSTEXPR20 bigint& operator<<=(int shift) {
+  FMT_NOINLINE FMT_CONSTEXPR20 auto operator<<=(int shift) -> bigint& {
     FMT_ASSERT(shift >= 0, "");
     exp_ += shift / bigit_bits;
     shift %= bigit_bits;
@@ @@ -3136,13 +2905,15 @@ class bigint { @@
     return *this;
+  }
   template <typename Int> FMT_CONSTEXPR20 bigint& operator*=(Int value) {
   template <typename Int>
   FMT_CONSTEXPR20 auto operator*=(Int value) -> bigint& {
     FMT_ASSERT(value > 0, "");
     multiply(uint32_or_64_or_128_t<Int>(value));
     return *this;
+  }
   friend FMT_CONSTEXPR20 int compare(const bigint& lhs, const bigint& rhs) {
   friend FMT_CONSTEXPR20 auto compare(const bigint& lhs, const bigint& rhs)
       -> int {
     int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
     if (num_lhs_bigits != num_rhs_bigits)
       return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
@@ @@ -3159,8 +2930,9 @@ class bigint { @@
+  }
   // Returns compare(lhs1 + lhs2, rhs).
   friend FMT_CONSTEXPR20 int add_compare(const bigint& lhs1, const bigint& lhs2,
                                          const bigint& rhs) {
   friend FMT_CONSTEXPR20 auto add_compare(const bigint& lhs1,
                                           const bigint& lhs2, const bigint& rhs)
       -> int {
     auto minimum = [](int a, int b) { return a < b ? a : b; };
     auto maximum = [](int a, int b) { return a > b ? a : b; };
     int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits());
@@ @@ -3241,13 +3013,13 @@ class bigint { @@
     bigits_.resize(to_unsigned(num_bigits + exp_difference));
     for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
       bigits_[j] = bigits_[i];
-    std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
+    std::uninitialized_fill_n(bigits_.data(), exp_difference, 0u);
     exp_ -= exp_difference;
+  }
   // Divides this bignum by divisor, assigning the remainder to this and
   // returning the quotient.
-  FMT_CONSTEXPR20 int divmod_assign(const bigint& divisor) {
+  FMT_CONSTEXPR20 auto divmod_assign(const bigint& divisor) -> int {
     FMT_ASSERT(this != &divisor, "");
     if (compare(*this, divisor) < 0) return 0;
     FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
@@ @@ -3322,6 +3094,7 @@ FMT_CONSTEXPR20 inline void format_drago @@
+  }
   int even = static_cast<int>((value.f & 1) == 0);
   if (!upper) upper = &lower;
   bool shortest = num_digits < 0;
   if ((flags & dragon::fixup) != 0) {
     if (add_compare(numerator, *upper, denominator) + even <= 0) {
       --exp10;
@@ @@ -3334,7 +3107,7 @@ FMT_CONSTEXPR20 inline void format_drago @@
     if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1);
+  }
   // Invariant: value == (numerator / denominator) * pow(10, exp10).
-  if (num_digits < 0) {
+  if (shortest) {
     // Generate the shortest representation.
     num_digits = 0;
     char* data = buf.data();
@@ @@ -3364,7 +3137,7 @@ FMT_CONSTEXPR20 inline void format_drago @@
+  }
   // Generate the given number of digits.
   exp10 -= num_digits - 1;
-  if (num_digits == 0) {
+  if (num_digits <= 0) {
     denominator *= 10;
     auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
     buf.push_back(digit);
@@ @@ -3389,6 +3162,9 @@ FMT_CONSTEXPR20 inline void format_drago @@
+      }
       if (buf[0] == overflow) {
         buf[0] = '1';
         if ((flags & dragon::fixed) != 0)
           buf.push_back('0');
         else
         ++exp10;
+      }
       return;
@@ @@ -3486,6 +3262,17 @@ FMT_CONSTEXPR20 void format_hexfloat(Flo @@
   format_hexfloat(static_cast<double>(value), precision, specs, buf);
+}
 constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t {
   // For checking rounding thresholds.
   // The kth entry is chosen to be the smallest integer such that the
   // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k.
   // It is equal to ceil(2^31 + 2^32/10^(k + 1)).
   // These are stored in a string literal because we cannot have static arrays
   // in constexpr functions and non-static ones are poorly optimized.
   return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7"
          U"\x800001ae\x8000002b"[index];
+}
 template <typename Float>
 FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs,
                                   buffer<char>& buf) -> int {
@@ @@ -3508,7 +3295,7 @@ FMT_CONSTEXPR20 auto format_float(Float @@
   int exp = 0;
   bool use_dragon = true;
   unsigned dragon_flags = 0;
   if (!is_fast_float<Float>()) {
+  if (!is_fast_float<Float>() || is_constant_evaluated()) {
     const auto inv_log2_10 = 0.3010299956639812;  // 1 / log2(10)
     using info = dragonbox::float_info<decltype(converted_value)>;
     const auto f = basic_fp<typename info::carrier_uint>(converted_value);
@@ @@ -3516,10 +3303,11 @@ FMT_CONSTEXPR20 auto format_float(Float @@
     //   10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1).
     // This is based on log10(value) == log2(value) / log2(10) and approximation
     // of log2(value) by e + num_fraction_bits idea from double-conversion.
     exp = static_cast<int>(
         std::ceil((f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10));
     auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10;
     exp = static_cast<int>(e);
     if (e > exp) ++exp;  // Compute ceil.
     dragon_flags = dragon::fixup;
-  } else if (!is_constant_evaluated() && precision < 0) {
   } else if (precision < 0) {
     // Use Dragonbox for the shortest format.
     if (specs.binary32) {
       auto dec = dragonbox::to_decimal(static_cast<float>(value));
@@ @@ -3529,25 +3317,6 @@ FMT_CONSTEXPR20 auto format_float(Float @@
     auto dec = dragonbox::to_decimal(static_cast<double>(value));
     write<char>(buffer_appender<char>(buf), dec.significand);
     return dec.exponent;
   } else if (is_constant_evaluated()) {
     // Use Grisu + Dragon4 for the given precision:
     // https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf.
     const int min_exp = -60;  // alpha in Grisu.
     int cached_exp10 = 0;     // K in Grisu.
     fp normalized = normalize(fp(converted_value));
     const auto cached_pow = get_cached_power(
         min_exp - (normalized.e + fp::num_significand_bits), cached_exp10);
     normalized = normalized * cached_pow;
     gen_digits_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
     if (grisu_gen_digits(normalized, 1, exp, handler) != digits::error &&
         !is_constant_evaluated()) {
       exp += handler.exp10;
       buf.try_resize(to_unsigned(handler.size));
       use_dragon = false;
     } else {
       exp += handler.size - cached_exp10 - 1;
       precision = handler.precision;
+    }
   } else {
     // Extract significand bits and exponent bits.
     using info = dragonbox::float_info<double>;
@@ @@ -3566,7 +3335,7 @@ FMT_CONSTEXPR20 auto format_float(Float @@
       significand <<= 1;
     } else {
       // Normalize subnormal inputs.
-      FMT_ASSERT(significand != 0, "zeros should not appear hear");
+      FMT_ASSERT(significand != 0, "zeros should not appear here");
       int shift = countl_zero(significand);
       FMT_ASSERT(shift >= num_bits<uint64_t>() - num_significand_bits<double>(),
                  "");
@@ @@ -3603,9 +3372,7 @@ FMT_CONSTEXPR20 auto format_float(Float @@
+    }
     // Compute the actual number of decimal digits to print.
     if (fixed) {
       adjust_precision(precision, exp + digits_in_the_first_segment);
+    }
     if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment);
     // Use Dragon4 only when there might be not enough digits in the first
     // segment.
@@ @@ -3710,9 +3477,9 @@ FMT_CONSTEXPR20 auto format_float(Float @@
           //    fractional part is strictly larger than 1/2.
           if (precision < 9) {
             uint32_t fractional_part = static_cast<uint32_t>(prod);
             should_round_up = fractional_part >=
                                   data::fractional_part_rounding_thresholds
                                       [8 - number_of_digits_to_print] ||
             should_round_up =
                 fractional_part >= fractional_part_rounding_thresholds(
 - number_of_digits_to_print) ||
                               ((fractional_part >> 31) &
                                ((digits & 1) | (second_third_subsegments != 0) |
                                 has_more_segments)) != 0;
@@ @@ -3750,9 +3517,9 @@ FMT_CONSTEXPR20 auto format_float(Float @@
             // of 19 digits, so in this case the third segment should be
             // consisting of a genuine digit from the input.
             uint32_t fractional_part = static_cast<uint32_t>(prod);
             should_round_up = fractional_part >=
                                   data::fractional_part_rounding_thresholds
                                       [8 - number_of_digits_to_print] ||
             should_round_up =
                 fractional_part >= fractional_part_rounding_thresholds(
 - number_of_digits_to_print) ||
                               ((fractional_part >> 31) &
                                ((digits & 1) | (third_subsegment != 0) |
                                 has_more_segments)) != 0;
@@ @@ -3987,8 +3754,11 @@ template <typename Char, typename Output @@
 FMT_CONSTEXPR auto write(OutputIt out, const T& value)
     -> enable_if_t<mapped_type_constant<T, Context>::value == type::custom_type,
                    OutputIt> {
   auto formatter = typename Context::template formatter_type<T>();
   auto parse_ctx = typename Context::parse_context_type({});
   formatter.parse(parse_ctx);
   auto ctx = Context(out, {}, {});
-  return typename Context::template formatter_type<T>().format(value, ctx);
+  return formatter.format(value, ctx);
+}
 // An argument visitor that formats the argument and writes it via the output
@@ @@ -4031,74 +3801,50 @@ template <typename Char> struct arg_form @@
+  }
 };
 template <typename Char> struct custom_formatter {
   basic_format_parse_context<Char>& parse_ctx;
   buffer_context<Char>& ctx;
   void operator()(
       typename basic_format_arg<buffer_context<Char>>::handle h) const {
     h.format(parse_ctx, ctx);
+  }
   template <typename T> void operator()(T) const {}
 };
 template <typename ErrorHandler> class width_checker {
  public:
   explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}
 struct width_checker {
   template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
   FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
-    if (is_negative(value)) handler_.on_error("negative width");
+    if (is_negative(value)) throw_format_error("negative width");
     return static_cast<unsigned long long>(value);
+  }
   template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
   FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
-    handler_.on_error("width is not integer");
+    throw_format_error("width is not integer");
     return 0;
+  }
  private:
   ErrorHandler& handler_;
 };
 template <typename ErrorHandler> class precision_checker {
  public:
   explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}
 struct precision_checker {
   template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
   FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
-    if (is_negative(value)) handler_.on_error("negative precision");
+    if (is_negative(value)) throw_format_error("negative precision");
     return static_cast<unsigned long long>(value);
+  }
   template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
   FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
-    handler_.on_error("precision is not integer");
+    throw_format_error("precision is not integer");
     return 0;
+  }
  private:
   ErrorHandler& handler_;
 };
 template <template <typename> class Handler, typename FormatArg,
           typename ErrorHandler>
 FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg, ErrorHandler eh) -> int {
   unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
   if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
 template <typename Handler, typename FormatArg>
 FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg) -> int {
   unsigned long long value = visit_format_arg(Handler(), arg);
   if (value > to_unsigned(max_value<int>()))
     throw_format_error("number is too big");
   return static_cast<int>(value);
+}
 template <typename Context, typename ID>
 FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) ->
     typename Context::format_arg {
 FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> decltype(ctx.arg(id)) {
   auto arg = ctx.arg(id);
   if (!arg) ctx.on_error("argument not found");
   return arg;
+}
-template <template <typename> class Handler, typename Context>
 template <typename Handler, typename Context>
 FMT_CONSTEXPR void handle_dynamic_spec(int& value,
                                        arg_ref<typename Context::char_type> ref,
                                        Context& ctx) {
@@ @@ -4106,26 +3852,15 @@ FMT_CONSTEXPR void handle_dynamic_spec(i @@
   case arg_id_kind::none:
     break;
   case arg_id_kind::index:
     value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.index),
                                               ctx.error_handler());
     value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.index));
     break;
   case arg_id_kind::name:
     value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.name),
                                               ctx.error_handler());
     value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.name));
     break;
+  }
+}
 #if FMT_USE_USER_DEFINED_LITERALS
 template <typename Char> struct udl_formatter {
   basic_string_view<Char> str;
   template <typename... T>
   auto operator()(T&&... args) const -> std::basic_string<Char> {
     return vformat(str, fmt::make_format_args<buffer_context<Char>>(args...));
+  }
 };
 #  if FMT_USE_NONTYPE_TEMPLATE_ARGS
 template <typename T, typename Char, size_t N,
           fmt::detail_exported::fixed_string<Char, N> Str>
@@ @@ -4179,7 +3914,7 @@ FMT_API void format_error_code(buffer<ch @@
 FMT_API void report_error(format_func func, int error_code,
                           const char* message) noexcept;
-FMT_END_DETAIL_NAMESPACE
+}  // namespace detail
 FMT_API auto vsystem_error(int error_code, string_view format_str,
                            format_args args) -> std::system_error;
@@ @@ -4292,32 +4027,32 @@ class format_int { @@
 template <typename T, typename Char>
 struct formatter<T, Char, enable_if_t<detail::has_format_as<T>::value>>
     : private formatter<detail::format_as_t<T>> {
   using base = formatter<detail::format_as_t<T>>;
   using base::parse;
     : formatter<detail::format_as_t<T>, Char> {
   template <typename FormatContext>
   auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) {
     using base = formatter<detail::format_as_t<T>, Char>;
     return base::format(format_as(value), ctx);
+  }
 };
 template <typename Char>
 struct formatter<void*, Char> : formatter<const void*, Char> {
   template <typename FormatContext>
   auto format(void* val, FormatContext& ctx) const -> decltype(ctx.out()) {
     return formatter<const void*, Char>::format(val, ctx);
+  }
 };
 #define FMT_FORMAT_AS(Type, Base) \
   template <typename Char>        \
   struct formatter<Type, Char> : formatter<Base, Char> {}
 FMT_FORMAT_AS(signed char, int);
 FMT_FORMAT_AS(unsigned char, unsigned);
 FMT_FORMAT_AS(short, int);
 FMT_FORMAT_AS(unsigned short, unsigned);
 FMT_FORMAT_AS(long, detail::long_type);
 FMT_FORMAT_AS(unsigned long, detail::ulong_type);
 FMT_FORMAT_AS(Char*, const Char*);
 FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
 FMT_FORMAT_AS(std::nullptr_t, const void*);
 FMT_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>);
 FMT_FORMAT_AS(void*, const void*);
 template <typename Char, size_t N>
 struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
   template <typename FormatContext>
   FMT_CONSTEXPR auto format(const Char* val, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     return formatter<basic_string_view<Char>, Char>::format(val, ctx);
+  }
 };
 struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {};
 /**
   \rst
@@ @@ -4393,7 +4128,9 @@ template <> struct formatter<bytes> { @@
 };
 // group_digits_view is not derived from view because it copies the argument.
 template <typename T> struct group_digits_view { T value; };
 template <typename T> struct group_digits_view {
   T value;
 };
 /**
   \rst
@@ @@ -4434,6 +4171,59 @@ template <typename T> struct formatter<g @@
+  }
 };
 template <typename T> struct nested_view {
   const formatter<T>* fmt;
   const T* value;
 };
 template <typename T> struct formatter<nested_view<T>> {
   FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* {
     return ctx.begin();
+  }
   auto format(nested_view<T> view, format_context& ctx) const
       -> decltype(ctx.out()) {
     return view.fmt->format(*view.value, ctx);
+  }
 };
 template <typename T> struct nested_formatter {
  private:
   int width_;
   detail::fill_t<char> fill_;
   align_t align_ : 4;
   formatter<T> formatter_;
  public:
   constexpr nested_formatter() : width_(0), align_(align_t::none) {}
   FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* {
     auto specs = detail::dynamic_format_specs<char>();
     auto it = parse_format_specs(ctx.begin(), ctx.end(), specs, ctx,
                                  detail::type::none_type);
     width_ = specs.width;
     fill_ = specs.fill;
     align_ = specs.align;
     ctx.advance_to(it);
     return formatter_.parse(ctx);
+  }
   template <typename F>
   auto write_padded(format_context& ctx, F write) const -> decltype(ctx.out()) {
     if (width_ == 0) return write(ctx.out());
     auto buf = memory_buffer();
     write(std::back_inserter(buf));
     auto specs = format_specs<>();
     specs.width = width_;
     specs.fill = fill_;
     specs.align = align_;
     return detail::write(ctx.out(), string_view(buf.data(), buf.size()), specs);
+  }
   auto nested(const T& value) const -> nested_view<T> {
     return nested_view<T>{&formatter_, &value};
+  }
 };
 // DEPRECATED! join_view will be moved to ranges.h.
 template <typename It, typename Sentinel, typename Char = char>
 struct join_view : detail::view {
@@ @@ -4523,7 +4313,8 @@ auto join(Range&& range, string_view sep @@
     std::string answer = fmt::to_string(42);
   \endrst
  */
 template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
 template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value &&
                                     !detail::has_format_as<T>::value)>
 inline auto to_string(const T& value) -> std::string {
   auto buffer = memory_buffer();
   detail::write<char>(appender(buffer), value);
@@ @@ -4548,7 +4339,15 @@ FMT_NODISCARD auto to_string(const basic @@
   return std::basic_string<Char>(buf.data(), size);
+}
 FMT_BEGIN_DETAIL_NAMESPACE
 template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value &&
                                     detail::has_format_as<T>::value)>
 inline auto to_string(const T& value) -> std::string {
   return to_string(format_as(value));
+}
 FMT_END_EXPORT
 namespace detail {
 template <typename Char>
 void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
@@ @@ -4556,7 +4355,7 @@ void vformat_to(buffer<Char>& buf, basic @@
   auto out = buffer_appender<Char>(buf);
   if (fmt.size() == 2 && equal2(fmt.data(), "{}")) {
     auto arg = args.get(0);
-    if (!arg) error_handler().on_error("argument not found");
+    if (!arg) throw_format_error("argument not found");
     visit_format_arg(default_arg_formatter<Char>{out, args, loc}, arg);
     return;
+  }
@@ @@ -4583,7 +4382,7 @@ void vformat_to(buffer<Char>& buf, basic @@
+    }
     FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
       int arg_id = context.arg_id(id);
-      if (arg_id < 0) on_error("argument not found");
+      if (arg_id < 0) throw_format_error("argument not found");
       return arg_id;
+    }
@@ @@ -4598,11 +4397,9 @@ void vformat_to(buffer<Char>& buf, basic @@
     auto on_format_specs(int id, const Char* begin, const Char* end)
         -> const Char* {
       auto arg = get_arg(context, id);
       if (arg.type() == type::custom_type) {
         parse_context.advance_to(begin);
         visit_format_arg(custom_formatter<Char>{parse_context, context}, arg);
       // Not using a visitor for custom types gives better codegen.
       if (arg.format_custom(begin, parse_context, context))
         return parse_context.begin();
+      }
       auto specs = detail::dynamic_format_specs<Char>();
       begin = parse_format_specs(begin, end, specs, parse_context, arg.type());
       detail::handle_dynamic_spec<detail::width_checker>(
@@ @@ -4610,7 +4407,7 @@ void vformat_to(buffer<Char>& buf, basic @@
       detail::handle_dynamic_spec<detail::precision_checker>(
           specs.precision, specs.precision_ref, context);
       if (begin == end || *begin != '}')
-        on_error("missing '}' in format string");
+        throw_format_error("missing '}' in format string");
       auto f = arg_formatter<Char>{context.out(), specs, context.locale()};
       context.advance_to(visit_format_arg(f, arg));
       return begin;
@@ @@ -4619,6 +4416,8 @@ void vformat_to(buffer<Char>& buf, basic @@
   detail::parse_format_string<false>(fmt, format_handler(out, fmt, args, loc));
+}
 FMT_BEGIN_EXPORT
 #ifndef FMT_HEADER_ONLY
 extern template FMT_API void vformat_to(buffer<char>&, string_view,
                                         typename vformat_args<>::type,
@@ @@ -4631,7 +4430,7 @@ extern template FMT_API auto decimal_poi @@
 extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
 #endif  // FMT_HEADER_ONLY
-FMT_END_DETAIL_NAMESPACE
+}  // namespace detail
 #if FMT_USE_USER_DEFINED_LITERALS
 inline namespace literals {
@@ @@ -4711,8 +4510,10 @@ formatter<T, Char, @@
                       detail::type::custom_type>>::format(const T& val,
                                                           FormatContext& ctx)
     const -> decltype(ctx.out()) {
   if (specs_.width_ref.kind != detail::arg_id_kind::none ||
       specs_.precision_ref.kind != detail::arg_id_kind::none) {
   if (specs_.width_ref.kind == detail::arg_id_kind::none &&
       specs_.precision_ref.kind == detail::arg_id_kind::none) {
     return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
+  }
     auto specs = specs_;
     detail::handle_dynamic_spec<detail::width_checker>(specs.width,
                                                        specs.width_ref, ctx);
@@ @@ -4720,8 +4521,6 @@ formatter<T, Char, @@
         specs.precision, specs.precision_ref, ctx);
     return detail::write<Char>(ctx.out(), val, specs, ctx.locale());
+  }
   return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
+}
 FMT_END_NAMESPACE

src/3rdparty/fmt/ostream.h

➞

Show inline comments

@@ @@ -10,18 +10,49 @@ @@
 #include <fstream>  // std::filebuf
 #if defined(_WIN32) && defined(__GLIBCXX__)
 #ifdef _WIN32
 #  ifdef __GLIBCXX__
 #  include <ext/stdio_filebuf.h>
 #  include <ext/stdio_sync_filebuf.h>
 #elif defined(_WIN32) && defined(_LIBCPP_VERSION)
 #  include <__std_stream>
 #  endif
 #  include <io.h>
 #endif
 #include "format.h"
 FMT_BEGIN_NAMESPACE
 namespace detail {
 namespace detail {
 template <typename Streambuf> class formatbuf : public Streambuf {
  private:
   using char_type = typename Streambuf::char_type;
   using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
   using int_type = typename Streambuf::int_type;
   using traits_type = typename Streambuf::traits_type;
   buffer<char_type>& buffer_;
  public:
   explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
  protected:
   // The put area is always empty. This makes the implementation simpler and has
   // the advantage that the streambuf and the buffer are always in sync and
   // sputc never writes into uninitialized memory. A disadvantage is that each
   // call to sputc always results in a (virtual) call to overflow. There is no
   // disadvantage here for sputn since this always results in a call to xsputn.
   auto overflow(int_type ch) -> int_type override {
     if (!traits_type::eq_int_type(ch, traits_type::eof()))
       buffer_.push_back(static_cast<char_type>(ch));
     return ch;
+  }
   auto xsputn(const char_type* s, streamsize count) -> streamsize override {
     buffer_.append(s, s + count);
     return count;
+  }
 };
 // Generate a unique explicit instantion in every translation unit using a tag
 // type in an anonymous namespace.
@@ @@ -37,36 +68,40 @@ class file_access { @@
 template class file_access<file_access_tag, std::filebuf,
                            &std::filebuf::_Myfile>;
 auto get_file(std::filebuf&) -> FILE*;
 #elif defined(_WIN32) && defined(_LIBCPP_VERSION)
 template class file_access<file_access_tag, std::__stdoutbuf<char>,
                            &std::__stdoutbuf<char>::__file_>;
 auto get_file(std::__stdoutbuf<char>&) -> FILE*;
 #endif
 inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) {
 inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data)
     -> bool {
   FILE* f = nullptr;
 #if FMT_MSC_VERSION
   if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
     if (FILE* f = get_file(*buf)) return write_console(f, data);
     f = get_file(*buf);
   else
     return false;
 #elif defined(_WIN32) && defined(__GLIBCXX__)
   auto* rdbuf = os.rdbuf();
   FILE* c_file;
   if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
-    c_file = sfbuf->file();
+    f = sfbuf->file();
   else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
-    c_file = fbuf->file();
+    f = fbuf->file();
   else
     return false;
   if (c_file) return write_console(c_file, data);
 #elif defined(_WIN32) && defined(_LIBCPP_VERSION)
   if (auto* buf = dynamic_cast<std::__stdoutbuf<char>*>(os.rdbuf()))
     if (FILE* f = get_file(*buf)) return write_console(f, data);
 #else
   ignore_unused(os, data);
   ignore_unused(os, data, f);
 #endif
 #ifdef _WIN32
   if (f) {
     int fd = _fileno(f);
     if (_isatty(fd)) {
       os.flush();
       return write_console(fd, data);
+    }
+  }
 #endif
   return false;
+}
 inline bool write_ostream_unicode(std::wostream&,
                                   fmt::basic_string_view<wchar_t>) {
 inline auto write_ostream_unicode(std::wostream&,
                                   fmt::basic_string_view<wchar_t>) -> bool {
   return false;
+}
@@ @@ -87,18 +122,19 @@ void write_buffer(std::basic_ostream<Cha @@
+}
 template <typename Char, typename T>
 void format_value(buffer<Char>& buf, const T& value,
                   locale_ref loc = locale_ref()) {
 void format_value(buffer<Char>& buf, const T& value) {
   auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
   auto&& output = std::basic_ostream<Char>(&format_buf);
 #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-  if (loc) output.imbue(loc.get<std::locale>());
+  output.imbue(std::locale::classic());  // The default is always unlocalized.
 #endif
   output << value;
   output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+}
 template <typename T> struct streamed_view { const T& value; };
 template <typename T> struct streamed_view {
   const T& value;
 };
 }  // namespace detail
@@ @@ -111,7 +147,7 @@ struct basic_ostream_formatter : formatt @@
   auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
       -> OutputIt {
     auto buffer = basic_memory_buffer<Char>();
-    detail::format_value(buffer, value, ctx.locale());
     detail::format_value(buffer, value);
     return formatter<basic_string_view<Char>, Char>::format(
         {buffer.data(), buffer.size()}, ctx);
+  }
@@ @@ -140,7 +176,7 @@ struct formatter<detail::streamed_view<T @@
   \endrst
  */
 template <typename T>
 auto streamed(const T& value) -> detail::streamed_view<T> {
+constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
   return {value};
+}
@@ @@ -155,7 +191,7 @@ inline void vprint_directly(std::ostream @@
 }  // namespace detail
-FMT_MODULE_EXPORT template <typename Char>
+FMT_EXPORT template <typename Char>
 void vprint(std::basic_ostream<Char>& os,
             basic_string_view<type_identity_t<Char>> format_str,
             basic_format_args<buffer_context<type_identity_t<Char>>> args) {
@@ @@ -174,7 +210,7 @@ void vprint(std::basic_ostream<Char>& os @@
     fmt::print(cerr, "Don't {}!", "panic");
   \endrst
  */
-FMT_MODULE_EXPORT template <typename... T>
+FMT_EXPORT template <typename... T>
 void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
   const auto& vargs = fmt::make_format_args(args...);
   if (detail::is_utf8())
@@ @@ -183,7 +219,7 @@ void print(std::ostream& os, format_stri @@
     detail::vprint_directly(os, fmt, vargs);
+}
-FMT_MODULE_EXPORT
+FMT_EXPORT
 template <typename... Args>
 void print(std::wostream& os,
            basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
@@ @@ -191,12 +227,12 @@ void print(std::wostream& os, @@
   vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
+}
-FMT_MODULE_EXPORT template <typename... T>
+FMT_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
+FMT_EXPORT
 template <typename... Args>
 void println(std::wostream& os,
              basic_format_string<wchar_t, type_identity_t<Args>...> fmt,

src/3rdparty/fmt/ranges.h

➞

Show inline comments

-// Formatting library for C++ - experimental range support
+// Formatting library for C++ - range and tuple support
 //
 // Copyright (c) 2012 - present, Victor Zverovich
+// Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
 // All rights reserved.
 //
 // For the license information refer to format.h.
 //
 // Copyright (c) 2018 - present, Remotion (Igor Schulz)
 // All Rights Reserved
 // {fmt} support for ranges, containers and types tuple interface.
 #ifndef FMT_RANGES_H_
 #define FMT_RANGES_H_
@@ @@ -187,7 +183,7 @@ template <size_t N> using make_index_seq @@
 template <typename T, T... N> struct integer_sequence {
   using value_type = T;
-  static FMT_CONSTEXPR size_t size() { return sizeof...(N); }
+  static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); }
 };
 template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;
@@ @@ -211,15 +207,15 @@ class is_tuple_formattable_ { @@
 };
 template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
   template <std::size_t... Is>
   static std::true_type check2(index_sequence<Is...>,
                                integer_sequence<bool, (Is == Is)...>);
   static std::false_type check2(...);
   static auto check2(index_sequence<Is...>,
                      integer_sequence<bool, (Is == Is)...>) -> std::true_type;
   static auto check2(...) -> std::false_type;
   template <std::size_t... Is>
   static decltype(check2(
+  static auto check(index_sequence<Is...>) -> decltype(check2(
       index_sequence<Is...>{},
       integer_sequence<
           bool, (is_formattable<typename std::tuple_element<Is, T>::type,
                                 C>::value)...>{})) check(index_sequence<Is...>);
       integer_sequence<bool,
                        (is_formattable<typename std::tuple_element<Is, T>::type,
                                        C>::value)...>{}));
  public:
   static constexpr const bool value =
@@ @@ -421,6 +417,12 @@ struct is_formattable_delayed @@
 #endif
 }  // namespace detail
 template <typename...> struct conjunction : std::true_type {};
 template <typename P> struct conjunction<P> : P {};
 template <typename P1, typename... Pn>
 struct conjunction<P1, Pn...>
     : conditional_t<bool(P1::value), conjunction<Pn...>, P1> {};
 template <typename T, typename Char, typename Enable = void>
 struct range_formatter;
@@ @@ -486,7 +488,8 @@ struct range_formatter< @@
     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);
       auto&& item = *it;
       out = underlying_.format(mapper.map(item), ctx);
       ++i;
+    }
     out = detail::copy_str<Char>(closing_bracket_, out);
@@ @@ -668,8 +671,11 @@ template <typename Container> struct all @@
 }  // namespace detail
 template <typename T, typename Char>
 struct formatter<T, Char,
                  enable_if_t<detail::is_container_adaptor_like<T>::value>>
 struct formatter<
     T, Char,
     enable_if_t<conjunction<detail::is_container_adaptor_like<T>,
                             bool_constant<range_format_kind<T, Char>::value ==
                                           range_format::disabled>>::value>>
     : formatter<detail::all<typename T::container_type>, Char> {
   using all = detail::all<typename T::container_type>;
   template <typename FormatContext>

src/3rdparty/fmt/std.h

➞

Show inline comments

@@ @@ -8,6 +8,8 @@ @@
 #ifndef FMT_STD_H_
 #define FMT_STD_H_
 #include <atomic>
 #include <bitset>
 #include <cstdlib>
 #include <exception>
 #include <memory>
@@ @@ -15,7 +17,9 @@ @@
 #include <type_traits>
 #include <typeinfo>
 #include <utility>
 #include <vector>
 #include "format.h"
 #include "ostream.h"
 #if FMT_HAS_INCLUDE(<version>)
@@ @@ -34,6 +38,10 @@ @@
 #  endif
 #endif
 #if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
 #  include <source_location>
 #endif
 // GCC 4 does not support FMT_HAS_INCLUDE.
 #if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
 #  include <cxxabi.h>
@@ @@ -44,67 +52,155 @@ @@
 #  endif
 #endif
 // Check if typeid is available.
 #ifndef FMT_USE_TYPEID
 // __RTTI is for EDG compilers. In MSVC typeid is available without RTTI.
 #  if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || FMT_MSC_VERSION || \
       defined(__INTEL_RTTI__) || defined(__RTTI)
 #    define FMT_USE_TYPEID 1
 #  else
 #    define FMT_USE_TYPEID 0
 #  endif
 #endif
 // For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
 #ifndef FMT_CPP_LIB_FILESYSTEM
 #ifdef __cpp_lib_filesystem
 #    define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem
 #  else
 #    define FMT_CPP_LIB_FILESYSTEM 0
 #  endif
 #endif
 #ifndef FMT_CPP_LIB_VARIANT
 #  ifdef __cpp_lib_variant
 #    define FMT_CPP_LIB_VARIANT __cpp_lib_variant
 #  else
 #    define FMT_CPP_LIB_VARIANT 0
 #  endif
 #endif
 #if FMT_CPP_LIB_FILESYSTEM
 FMT_BEGIN_NAMESPACE
 namespace detail {
 template <typename Char>
 template <typename Char, typename PathChar>
 auto get_path_string(const std::filesystem::path& p,
                      const std::basic_string<PathChar>& native) {
   if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
     return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
   else
     return p.string<Char>();
+}
 template <typename Char, typename PathChar>
 void write_escaped_path(basic_memory_buffer<Char>& quoted,
                         const std::filesystem::path& p) {
                         const std::filesystem::path& p,
                         const std::basic_string<PathChar>& native) {
   if constexpr (std::is_same_v<Char, char> &&
                 std::is_same_v<PathChar, wchar_t>) {
     auto buf = basic_memory_buffer<wchar_t>();
     write_escaped_string<wchar_t>(std::back_inserter(buf), native);
     bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
     FMT_ASSERT(valid, "invalid utf16");
   } else if constexpr (std::is_same_v<Char, PathChar>) {
     write_escaped_string<std::filesystem::path::value_type>(
         std::back_inserter(quoted), native);
   } else {
   write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
+}
 #  ifdef _WIN32
 template <>
 inline void write_escaped_path<char>(memory_buffer& quoted,
                                      const std::filesystem::path& p) {
   auto buf = basic_memory_buffer<wchar_t>();
   write_escaped_string<wchar_t>(std::back_inserter(buf), p.native());
   // Convert UTF-16 to UTF-8.
   if (!unicode_to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()}))
     FMT_THROW(std::runtime_error("invalid utf16"));
+}
 #  endif
 template <>
 inline void write_escaped_path<std::filesystem::path::value_type>(
     basic_memory_buffer<std::filesystem::path::value_type>& quoted,
     const std::filesystem::path& p) {
   write_escaped_string<std::filesystem::path::value_type>(
       std::back_inserter(quoted), p.native());
+}
 }  // namespace detail
 FMT_MODULE_EXPORT
 template <typename Char>
 struct formatter<std::filesystem::path, Char>
     : formatter<basic_string_view<Char>> {
 FMT_EXPORT
 template <typename Char> struct formatter<std::filesystem::path, Char> {
  private:
   format_specs<Char> specs_;
   detail::arg_ref<Char> width_ref_;
   bool debug_ = false;
   char path_type_ = 0;
  public:
   FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
   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;
     auto it = ctx.begin(), end = ctx.end();
     if (it == end) return it;
     it = detail::parse_align(it, end, specs_);
     if (it == end) return it;
     it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
     if (it != end && *it == '?') {
       debug_ = true;
       ++it;
+  }
     if (it != end && (*it == 'g')) path_type_ = *it++;
     return it;
+  }
   template <typename FormatContext>
   auto format(const std::filesystem::path& p, FormatContext& ctx) const ->
       typename FormatContext::iterator {
   auto format(const std::filesystem::path& p, FormatContext& ctx) const {
     auto specs = specs_;
 #  ifdef _WIN32
     auto path_string = !path_type_ ? p.native() : p.generic_wstring();
 #  else
     auto path_string = !path_type_ ? p.native() : p.generic_string();
 #  endif
     detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
                                                        ctx);
     if (!debug_) {
       auto s = detail::get_path_string<Char>(p, path_string);
       return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
+    }
     auto quoted = basic_memory_buffer<Char>();
     detail::write_escaped_path(quoted, p);
     return formatter<basic_string_view<Char>>::format(
         basic_string_view<Char>(quoted.data(), quoted.size()), ctx);
     detail::write_escaped_path(quoted, p, path_string);
     return detail::write(ctx.out(),
                          basic_string_view<Char>(quoted.data(), quoted.size()),
                          specs);
+  }
 };
 FMT_END_NAMESPACE
 #endif
+#endif  // FMT_CPP_LIB_FILESYSTEM
 FMT_BEGIN_NAMESPACE
 FMT_MODULE_EXPORT
 FMT_EXPORT
 template <std::size_t N, typename Char>
 struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
  private:
   // Functor because C++11 doesn't support generic lambdas.
   struct writer {
     const std::bitset<N>& bs;
     template <typename OutputIt>
     FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {
       for (auto pos = N; pos > 0; --pos) {
         out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
+      }
       return out;
+    }
   };
  public:
   template <typename FormatContext>
   auto format(const std::bitset<N>& bs, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     return write_padded(ctx, writer{bs});
+  }
 };
 FMT_EXPORT
 template <typename Char>
 struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
 FMT_END_NAMESPACE
 #ifdef __cpp_lib_optional
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT
+FMT_EXPORT
 template <typename T, typename Char>
 struct formatter<std::optional<T>, Char,
                  std::enable_if_t<is_formattable<T, Char>::value>> {
@@ @@ -132,7 +228,7 @@ struct formatter<std::optional<T>, Char, @@
+  }
   template <typename FormatContext>
-  auto format(std::optional<T> const& opt, FormatContext& ctx) const
+  auto format(const std::optional<T>& opt, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     if (!opt) return detail::write<Char>(ctx.out(), none);
@@ @@ -146,24 +242,33 @@ struct formatter<std::optional<T>, Char, @@
 FMT_END_NAMESPACE
 #endif  // __cpp_lib_optional
-#ifdef __cpp_lib_variant
+#ifdef __cpp_lib_source_location
 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()) {
 FMT_EXPORT
 template <> struct formatter<std::source_location> {
   template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
     return ctx.begin();
+  }
   template <typename FormatContext>
-  auto format(const std::monostate&, FormatContext& ctx) const
+  auto format(const std::source_location& loc, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     auto out = ctx.out();
     out = detail::write<Char>(out, "monostate");
     out = detail::write(out, loc.file_name());
     out = detail::write(out, ':');
     out = detail::write<char>(out, loc.line());
     out = detail::write(out, ':');
     out = detail::write<char>(out, loc.column());
     out = detail::write(out, ": ");
     out = detail::write(out, loc.function_name());
     return out;
+  }
 };
 FMT_END_NAMESPACE
 #endif
 #if FMT_CPP_LIB_VARIANT
 FMT_BEGIN_NAMESPACE
 namespace detail {
 template <typename T>
@@ @@ -197,6 +302,7 @@ auto write_variant_alternative(OutputIt @@
+}
 }  // namespace detail
 template <typename T> struct is_variant_like {
   static constexpr const bool value = detail::is_variant_like_<T>::value;
 };
@@ @@ -206,7 +312,21 @@ template <typename T, typename C> struct @@
       detail::is_variant_formattable_<T, C>::value;
 };
 FMT_MODULE_EXPORT
 FMT_EXPORT
 template <typename Char> struct formatter<std::monostate, Char> {
   template <typename ParseContext>
   FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     return ctx.begin();
+  }
   template <typename FormatContext>
   auto format(const std::monostate&, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     return detail::write<Char>(ctx.out(), "monostate");
+  }
 };
 FMT_EXPORT
 template <typename Variant, typename Char>
 struct formatter<
     Variant, Char,
@@ @@ -223,13 +343,14 @@ struct formatter< @@
     auto out = ctx.out();
     out = detail::write<Char>(out, "variant(");
-    try {
+    FMT_TRY {
       std::visit(
           [&](const auto& v) {
             out = detail::write_variant_alternative<Char>(out, v);
           },
           value);
     } catch (const std::bad_variant_access&) {
+    }
     FMT_CATCH(const std::bad_variant_access&) {
       detail::write<Char>(out, "valueless by exception");
+    }
     *out++ = ')';
@@ @@ -237,10 +358,10 @@ struct formatter< @@
+  }
 };
 FMT_END_NAMESPACE
-#endif  // __cpp_lib_variant
+#endif  // FMT_CPP_LIB_VARIANT
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT
+FMT_EXPORT
 template <typename Char> struct formatter<std::error_code, Char> {
   template <typename ParseContext>
   FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
@@ @@ -258,10 +379,10 @@ template <typename Char> struct formatte @@
+  }
 };
-FMT_MODULE_EXPORT
+FMT_EXPORT
 template <typename T, typename Char>
 struct formatter<
     T, Char,
+    T, Char,  // DEPRECATED! Mixing code unit types.
     typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
  private:
   bool with_typename_ = false;
@@ @@ -274,7 +395,7 @@ struct formatter< @@
     if (it == end || *it == '}') return it;
     if (*it == 't') {
       ++it;
-      with_typename_ = true;
+      with_typename_ = FMT_USE_TYPEID != 0;
+    }
     return it;
+  }
@@ @@ -287,11 +408,12 @@ struct formatter< @@
     if (!with_typename_)
       return detail::write_bytes(out, string_view(ex.what()), spec);
 #if FMT_USE_TYPEID
     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(
+    std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
         abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
     string_view demangled_name_view;
@@ @@ -337,13 +459,79 @@ struct formatter< @@
 #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;
     *out++ = ':';
     *out++ = ' ';
     return detail::write_bytes(out, string_view(ex.what()), spec);
 #endif
+  }
 };
 FMT_END_NAMESPACE
 namespace detail {
 template <typename T, typename Enable = void>
 struct has_flip : std::false_type {};
 template <typename T>
 struct has_flip<T, void_t<decltype(std::declval<T>().flip())>>
     : std::true_type {};
 template <typename T> struct is_bit_reference_like {
   static constexpr const bool value =
       std::is_convertible<T, bool>::value &&
       std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
 };
 #ifdef _LIBCPP_VERSION
 // Workaround for libc++ incompatibility with C++ standard.
 // According to the Standard, `bitset::operator[] const` returns bool.
 template <typename C>
 struct is_bit_reference_like<std::__bit_const_reference<C>> {
   static constexpr const bool value = true;
 };
 #endif
 }  // namespace detail
 // We can't use std::vector<bool, Allocator>::reference and
 // std::bitset<N>::reference because the compiler can't deduce Allocator and N
 // in partial specialization.
 FMT_EXPORT
 template <typename BitRef, typename Char>
 struct formatter<BitRef, Char,
                  enable_if_t<detail::is_bit_reference_like<BitRef>::value>>
     : formatter<bool, Char> {
   template <typename FormatContext>
   FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     return formatter<bool, Char>::format(v, ctx);
+  }
 };
 FMT_EXPORT
 template <typename T, typename Char>
 struct formatter<std::atomic<T>, Char,
                  enable_if_t<is_formattable<T, Char>::value>>
     : formatter<T, Char> {
   template <typename FormatContext>
   auto format(const std::atomic<T>& v, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     return formatter<T, Char>::format(v.load(), ctx);
+  }
 };
 #ifdef __cpp_lib_atomic_flag_test
 FMT_EXPORT
 template <typename Char>
 struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
   template <typename FormatContext>
   auto format(const std::atomic_flag& v, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     return formatter<bool, Char>::format(v.test(), ctx);
+  }
 };
 #endif  // __cpp_lib_atomic_flag_test
 FMT_END_NAMESPACE
 #endif  // FMT_STD_H_

0 comments (0 inline, 0 general)