diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/fmt/args.h | 11 | ||||
| -rw-r--r-- | include/fmt/chrono.h | 267 | ||||
| -rw-r--r-- | include/fmt/color.h | 74 | ||||
| -rw-r--r-- | include/fmt/compile.h | 17 | ||||
| -rw-r--r-- | include/fmt/core.h | 68 | ||||
| -rw-r--r-- | include/fmt/format-inl.h | 116 | ||||
| -rw-r--r-- | include/fmt/format.h | 363 | ||||
| -rw-r--r-- | include/fmt/os.h | 34 | ||||
| -rw-r--r-- | include/fmt/ostream.h | 46 | ||||
| -rw-r--r-- | include/fmt/ranges.h | 25 | ||||
| -rw-r--r-- | include/fmt/std.h | 82 | ||||
| -rw-r--r-- | include/fmt/xchar.h | 17 |
12 files changed, 636 insertions, 484 deletions
diff --git a/include/fmt/args.h b/include/fmt/args.h index 2d684e7c..ad1654bb 100644 --- a/include/fmt/args.h +++ b/include/fmt/args.h @@ -22,8 +22,9 @@ template <typename T> struct is_reference_wrapper : std::false_type {}; template <typename T> struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {}; -template <typename T> const T& unwrap(const T& v) { return v; } -template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) { +template <typename T> auto unwrap(const T& v) -> const T& { return v; } +template <typename T> +auto unwrap(const std::reference_wrapper<T>& v) -> const T& { return static_cast<const T&>(v); } @@ -50,7 +51,7 @@ class dynamic_arg_list { std::unique_ptr<node<>> head_; public: - template <typename T, typename Arg> const T& push(const Arg& arg) { + template <typename T, typename Arg> auto push(const Arg& arg) -> const T& { auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg)); auto& value = new_node->value; new_node->next = std::move(head_); @@ -110,14 +111,14 @@ class dynamic_format_arg_store friend class basic_format_args<Context>; - unsigned long long get_types() const { + auto get_types() const -> unsigned long long { return detail::is_unpacked_bit | data_.size() | (named_info_.empty() ? 0ULL : static_cast<unsigned long long>(detail::has_named_args_bit)); } - const basic_format_arg<Context>* data() const { + auto data() const -> const basic_format_arg<Context>* { return named_info_.empty() ? data_.data() : data_.data() + 1; } diff --git a/include/fmt/chrono.h b/include/fmt/chrono.h index 7bd4206d..9d54574e 100644 --- a/include/fmt/chrono.h +++ b/include/fmt/chrono.h @@ -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_conversion(const From from, int& ec) { 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_conversion(const From from, int& ec) { // 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(const From from, int& ec) { 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(const From from, int& ec) { 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::duration<FromRep, FromPeriod> from, 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::duration<FromRep, FromPeriod> from, 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; } @@ -406,8 +409,7 @@ inline void do_write(buffer<Char>& buf, const std::tm& time, 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")); } @@ -430,6 +432,51 @@ auto write(OutputIt out, const std::tm& time, const std::locale& loc, 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 @@ -439,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; @@ -478,8 +525,8 @@ inline std::tm localtime(std::time_t time) { #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 @@ -488,29 +535,29 @@ inline auto localtime(std::chrono::local_time<Duration> time) -> std::tm { 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; @@ -523,9 +570,11 @@ inline std::tm gmtime(std::time_t time) { 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)); } namespace detail { @@ -564,7 +613,8 @@ inline void write_digit2_separated(char* buf, unsigned a, unsigned b, } } -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"; @@ -620,9 +670,8 @@ auto write_padding(OutputIt out, pad_type pad) -> OutputIt { // 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; @@ -953,25 +1002,25 @@ struct tm_format_checker : null_chrono_spec_handler<tm_format_checker> { 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", @@ -1003,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); } @@ -1051,13 +1100,12 @@ void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) { 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); @@ -1108,11 +1156,11 @@ void write_floating_seconds(memory_buffer& buf, Duration duration, num_fractional_digits = 6; } - 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)), - num_fractional_digits); + 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)), + num_fractional_digits); } template <typename OutputIt, typename Char, @@ -1173,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 = @@ -1314,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_); @@ -1578,6 +1625,7 @@ struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> { 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) {} @@ -1596,16 +1644,16 @@ struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> { 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)); } @@ -1620,49 +1668,38 @@ template <typename T> struct make_unsigned_or_unchanged<T, true> { 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 @@ -1671,12 +1708,12 @@ OutputIt format_duration_value(OutputIt out, Rep val, int precision) { } 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); @@ -1684,7 +1721,7 @@ OutputIt copy_unit(string_view unit, OutputIt out, wchar_t) { } 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++ = '['; @@ -1751,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; } @@ -1779,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); @@ -1857,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; @@ -1967,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 {}; @@ -2082,25 +2122,22 @@ struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>, 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::duration_cast<Duration>(std::chrono::seconds(1)); + 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); } }; @@ -2119,17 +2156,13 @@ struct formatter<std::chrono::local_time<Duration>, Char> 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 diff --git a/include/fmt/color.h b/include/fmt/color.h index 57b7f578..367849a8 100644 --- a/include/fmt/color.h +++ b/include/fmt/color.h @@ -233,7 +233,7 @@ class text_style { FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept : set_foreground_color(), set_background_color(), ems(em) {} - FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) { + FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& { if (!set_foreground_color) { set_foreground_color = rhs.set_foreground_color; foreground_color = rhs.foreground_color; @@ -257,29 +257,29 @@ class text_style { return *this; } - friend FMT_CONSTEXPR text_style operator|(text_style lhs, - const text_style& rhs) { + friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs) + -> text_style { return lhs |= rhs; } - FMT_CONSTEXPR bool has_foreground() const noexcept { + FMT_CONSTEXPR auto has_foreground() const noexcept -> bool { return set_foreground_color; } - FMT_CONSTEXPR bool has_background() const noexcept { + FMT_CONSTEXPR auto has_background() const noexcept -> bool { return set_background_color; } - FMT_CONSTEXPR bool has_emphasis() const noexcept { + FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool { return static_cast<uint8_t>(ems) != 0; } - FMT_CONSTEXPR detail::color_type get_foreground() const noexcept { + FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type { FMT_ASSERT(has_foreground(), "no foreground specified for this style"); return foreground_color; } - FMT_CONSTEXPR detail::color_type get_background() const noexcept { + FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type { FMT_ASSERT(has_background(), "no background specified for this style"); return background_color; } - FMT_CONSTEXPR emphasis get_emphasis() const noexcept { + FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis { FMT_ASSERT(has_emphasis(), "no emphasis specified for this style"); return ems; } @@ -297,9 +297,11 @@ class text_style { } } - friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept; + friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept + -> text_style; - friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept; + friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept + -> text_style; detail::color_type foreground_color; detail::color_type background_color; @@ -309,16 +311,19 @@ class text_style { }; /** Creates a text style from the foreground (text) color. */ -FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) noexcept { +FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept + -> text_style { return text_style(true, foreground); } /** Creates a text style from the background color. */ -FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept { +FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept + -> text_style { return text_style(false, background); } -FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept { +FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept + -> text_style { return text_style(lhs) | rhs; } @@ -384,8 +389,8 @@ template <typename Char> struct ansi_color_escape { } FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; } - FMT_CONSTEXPR const Char* begin() const noexcept { return buffer; } - FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const noexcept { + FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; } + FMT_CONSTEXPR_CHAR_TRAITS auto end() const noexcept -> const Char* { return buffer + std::char_traits<Char>::length(buffer); } @@ -400,25 +405,27 @@ template <typename Char> struct ansi_color_escape { out[2] = static_cast<Char>('0' + c % 10); out[3] = static_cast<Char>(delimiter); } - static FMT_CONSTEXPR bool has_emphasis(emphasis em, emphasis mask) noexcept { + static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept + -> bool { return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask); } }; template <typename Char> -FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color( - detail::color_type foreground) noexcept { +FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept + -> ansi_color_escape<Char> { return ansi_color_escape<Char>(foreground, "\x1b[38;2;"); } template <typename Char> -FMT_CONSTEXPR ansi_color_escape<Char> make_background_color( - detail::color_type background) noexcept { +FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept + -> ansi_color_escape<Char> { return ansi_color_escape<Char>(background, "\x1b[48;2;"); } template <typename Char> -FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept { +FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept + -> ansi_color_escape<Char> { return ansi_color_escape<Char>(em); } @@ -511,9 +518,10 @@ void print(const text_style& ts, const S& format_str, const Args&... args) { } template <typename S, typename Char = char_t<S>> -inline std::basic_string<Char> vformat( +inline auto vformat( const text_style& ts, const S& format_str, - basic_format_args<buffer_context<type_identity_t<Char>>> args) { + basic_format_args<buffer_context<type_identity_t<Char>>> args) + -> std::basic_string<Char> { basic_memory_buffer<Char> buf; detail::vformat_to(buf, ts, detail::to_string_view(format_str), args); return fmt::to_string(buf); @@ -532,8 +540,8 @@ inline std::basic_string<Char> vformat( \endrst */ template <typename S, typename... Args, typename Char = char_t<S>> -inline std::basic_string<Char> format(const text_style& ts, const S& format_str, - const Args&... args) { +inline auto format(const text_style& ts, const S& format_str, + const Args&... args) -> std::basic_string<Char> { return fmt::vformat(ts, detail::to_string_view(format_str), fmt::make_format_args<buffer_context<Char>>(args...)); } @@ -543,9 +551,10 @@ inline std::basic_string<Char> format(const text_style& ts, const S& format_str, */ template <typename OutputIt, typename Char, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)> -OutputIt vformat_to( - OutputIt out, const text_style& ts, basic_string_view<Char> format_str, - basic_format_args<buffer_context<type_identity_t<Char>>> args) { +auto vformat_to(OutputIt out, const text_style& ts, + basic_string_view<Char> format_str, + basic_format_args<buffer_context<type_identity_t<Char>>> args) + -> OutputIt { auto&& buf = detail::get_buffer<Char>(out); detail::vformat_to(buf, ts, format_str, args); return detail::get_iterator(buf, out); @@ -563,9 +572,10 @@ OutputIt vformat_to( fmt::emphasis::bold | fg(fmt::color::red), "{}", 42); \endrst */ -template <typename OutputIt, typename S, typename... Args, - bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&& - detail::is_string<S>::value> +template < + typename OutputIt, typename S, typename... Args, + bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value && + detail::is_string<S>::value> inline auto format_to(OutputIt out, const text_style& ts, const S& format_str, Args&&... args) -> typename std::enable_if<enable, OutputIt>::type { diff --git a/include/fmt/compile.h b/include/fmt/compile.h index a4c7e495..3b3f166e 100644 --- a/include/fmt/compile.h +++ b/include/fmt/compile.h @@ -14,8 +14,8 @@ FMT_BEGIN_NAMESPACE namespace detail { template <typename Char, typename InputIt> -FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end, - counting_iterator it) { +FMT_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end, + counting_iterator it) -> counting_iterator { return it + (end - begin); } @@ -57,7 +57,7 @@ struct udl_compiled_string : compiled_string { #endif template <typename T, typename... Tail> -const T& first(const T& value, const Tail&...) { +auto first(const T& value, const Tail&...) -> const T& { return value; } @@ -488,18 +488,19 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) { template <typename OutputIt, typename S, typename... Args, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> -format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n, - const S& format_str, Args&&... args) { +auto format_to_n(OutputIt out, size_t n, const S& format_str, Args&&... args) + -> format_to_n_result<OutputIt> { using traits = detail::fixed_buffer_traits; auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n); - format_to(std::back_inserter(buf), format_str, std::forward<Args>(args)...); + fmt::format_to(std::back_inserter(buf), format_str, + std::forward<Args>(args)...); return {buf.out(), buf.count()}; } template <typename S, typename... Args, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)> -FMT_CONSTEXPR20 size_t formatted_size(const S& format_str, - const Args&... args) { +FMT_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args) + -> size_t { return fmt::format_to(detail::counting_iterator(), format_str, args...) .count(); } diff --git a/include/fmt/core.h b/include/fmt/core.h index 18ebada2..94f3f22b 100644 --- a/include/fmt/core.h +++ b/include/fmt/core.h @@ -18,7 +18,7 @@ #include <type_traits> // The fmt library version in the form major * 10000 + minor * 100 + patch. -#define FMT_VERSION 100101 +#define FMT_VERSION 100200 #if defined(__clang__) && !defined(__ibmxl__) # define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) @@ -105,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 @@ -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,6 +248,15 @@ # endif #endif +// GCC < 5 requires this-> in decltype +#ifndef FMT_DECLTYPE_THIS +# if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 +# define FMT_DECLTYPE_THIS this-> +# else +# define FMT_DECLTYPE_THIS +# endif +#endif + // Enable minimal optimizations for more compact code in debug mode. FMT_GCC_PRAGMA("GCC push_options") #if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER) && !defined(__LCC__) && \ @@ -458,15 +471,15 @@ template <typename Char> class basic_string_view { 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)); } @@ -604,10 +617,10 @@ FMT_TYPE_CONSTANT(const Char*, cstring_type); 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; } @@ -631,6 +644,7 @@ enum { pointer_set = set(type::pointer_type) }; +// DEPRECATED! FMT_NORETURN FMT_API void throw_format_error(const char* message); struct error_handler { @@ -808,7 +822,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) {} @@ -823,6 +837,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: @@ -1309,6 +1324,7 @@ 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)); } }; @@ -1322,7 +1338,7 @@ using ulong_type = conditional_t<long_short, unsigned, unsigned long long>; 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))); @@ -1439,7 +1455,8 @@ template <typename Context> struct arg_mapper { // 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)); } @@ -1463,13 +1480,14 @@ template <typename Context> struct arg_mapper { !is_string<U>::value && !is_char<U>::value && !is_named_arg<U>::value && !std::is_arithmetic<format_as_t<U>>::value)> - FMT_CONSTEXPR FMT_INLINE auto map(T& val) -> decltype(this->do_map(val)) { + FMT_CONSTEXPR FMT_INLINE auto map(T& val) + -> decltype(FMT_DECLTYPE_THIS do_map(val)) { return do_map(val); } template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)> FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg) - -> decltype(this->map(named_arg.value)) { + -> decltype(FMT_DECLTYPE_THIS map(named_arg.value)) { return map(named_arg.value); } @@ -1604,8 +1622,8 @@ FMT_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg<Context> { } // namespace detail FMT_BEGIN_EXPORT -// A formatting argument. It is a trivially copyable/constructible type to -// allow storage in basic_memory_buffer. +// A formatting argument. Context is a template parameter for the compiled API +// where output can be unbuffered. template <typename Context> class basic_format_arg { private: detail::value<Context> value_; @@ -1657,6 +1675,15 @@ template <typename Context> class basic_format_arg { 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; + } }; /** @@ -1745,6 +1772,7 @@ template <typename OutputIt, typename Char> class basic_format_context { } 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); } @@ -2417,6 +2445,8 @@ FMT_CONSTEXPR FMT_INLINE auto parse_format_specs( 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, diff --git a/include/fmt/format-inl.h b/include/fmt/format-inl.h index 5f8c83a2..e9a4ca45 100644 --- a/include/fmt/format-inl.h +++ b/include/fmt/format-inl.h @@ -58,8 +58,8 @@ FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code, 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, ""); } @@ -85,7 +85,7 @@ locale_ref::locale_ref(const Locale& loc) : 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(); } @@ -97,7 +97,8 @@ FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> { 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(); } @@ -143,24 +144,25 @@ FMT_API FMT_FUNC auto format_facet<std::locale>::do_put( } #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)); } @@ -169,14 +171,14 @@ FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept { 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()}; @@ -184,12 +186,12 @@ inline uint128_fallback umul192_lower128(uint64_t x, // 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; } @@ -203,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, @@ -228,7 +230,7 @@ bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept { // 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 = @@ -237,12 +239,12 @@ template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept { } // 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; } @@ -254,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[] = { @@ -296,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, ""); @@ -318,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)) + 1) / @@ -345,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"); @@ -984,7 +989,7 @@ template <> struct cache_accessor<double> { {0xe0accfa875af45a7, 0x93eb1b80a33b8606}, {0x8c6c01c9498d8b88, 0xbc72f130660533c4}, {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5}, - {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2} + {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2}, #else {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, @@ -1069,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, ""); @@ -1090,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)) + 1) / 2; } }; -FMT_FUNC uint128_fallback get_cached_power(int k) noexcept { +FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback { return cache_accessor<double>::get_cached_power(k); } // Various integer checks template <typename T> -bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept { +auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool { const int case_shorter_interval_left_endpoint_lower_threshold = 2; const int case_shorter_interval_left_endpoint_upper_threshold = 3; return exponent >= case_shorter_interval_left_endpoint_lower_threshold && @@ -1232,7 +1240,7 @@ FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept { 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; @@ -1371,15 +1379,15 @@ template <> struct formatter<detail::bigint> { for (auto i = n.bigits_.size(); i > 0; --i) { auto value = n.bigits_[i - 1u]; if (first) { - out = format_to(out, FMT_STRING("{:x}"), value); + out = fmt::format_to(out, FMT_STRING("{:x}"), value); first = false; continue; } - out = format_to(out, FMT_STRING("{:08x}"), value); + out = fmt::format_to(out, FMT_STRING("{:08x}"), value); } if (n.exp_ > 0) - out = format_to(out, FMT_STRING("p{}"), - n.exp_ * detail::bigint::bigit_bits); + out = fmt::format_to(out, FMT_STRING("p{}"), + n.exp_ * detail::bigint::bigit_bits); return out; } }; @@ -1415,7 +1423,7 @@ FMT_FUNC void report_system_error(int error_code, 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(); @@ -1425,7 +1433,7 @@ FMT_FUNC std::string vformat(string_view fmt, format_args args) { namespace detail { #if !defined(_WIN32) || defined(FMT_WINDOWS_NO_WCHAR) -FMT_FUNC bool write_console(int, string_view) { return false; } +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( // diff --git a/include/fmt/format.h b/include/fmt/format.h index c8e1c46d..f0ca55cf 100644 --- a/include/fmt/format.h +++ b/include/fmt/format.h @@ -43,7 +43,7 @@ #include <system_error> // std::system_error #ifdef __cpp_lib_bit_cast -# include <bit> // std::bitcast +# include <bit> // std::bit_cast #endif #include "core.h" @@ -277,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) { @@ -311,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 { @@ -377,8 +333,8 @@ class uint128_fallback { 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 { @@ -454,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); @@ -744,7 +700,7 @@ inline auto compute_width(basic_string_view<Char> s) -> size_t { } // 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 { @@ -791,12 +747,17 @@ inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t { // 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) @@ -906,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: @@ -1022,7 +983,6 @@ class basic_memory_buffer final : public detail::buffer<T> { /** 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) { @@ -1038,7 +998,7 @@ struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type { FMT_END_EXPORT namespace detail { -FMT_API bool write_console(int fd, string_view text); +FMT_API auto write_console(int fd, string_view text) -> bool; FMT_API void print(std::FILE*, string_view); } // namespace detail @@ -1157,13 +1117,13 @@ using uint32_or_64_or_128_t = template <typename T> using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>; -#define FMT_POWERS_OF_10(factor) \ - factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \ - (factor)*1000000, (factor)*10000000, (factor)*100000000, \ - (factor)*1000000000 +#define FMT_POWERS_OF_10(factor) \ + factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \ + (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \ + (factor) * 100000000, (factor) * 1000000000 // Converts value in the range [0, 100) to a string. -constexpr const char* digits2(size_t value) { +constexpr auto digits2(size_t value) -> const char* { // GCC generates slightly better code when value is pointer-size. return &"0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" @@ -1173,7 +1133,7 @@ constexpr const char* digits2(size_t value) { } // 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 @@ -1434,22 +1394,23 @@ template <typename WChar, typename Buffer = memory_buffer> class to_utf8 { : "invalid utf32")); } operator string_view() const { return string_view(&buffer_[0], size()); } - size_t size() const { return buffer_.size() - 1; } - const char* c_str() const { return &buffer_[0]; } - std::string str() const { return std::string(&buffer_[0], size()); } + auto size() const -> size_t { return buffer_.size() - 1; } + auto c_str() const -> const char* { return &buffer_[0]; } + auto str() const -> std::string { return std::string(&buffer_[0], size()); } // Performs conversion returning a bool instead of throwing exception on // conversion error. This method may still throw in case of memory allocation // error. - bool convert(basic_string_view<WChar> s, - to_utf8_error_policy policy = to_utf8_error_policy::abort) { + auto convert(basic_string_view<WChar> s, + to_utf8_error_policy policy = to_utf8_error_policy::abort) + -> bool { if (!convert(buffer_, s, policy)) return false; buffer_.push_back(0); return true; } - static bool convert( - Buffer& buf, basic_string_view<WChar> s, - to_utf8_error_policy policy = to_utf8_error_policy::abort) { + static auto convert(Buffer& buf, basic_string_view<WChar> s, + to_utf8_error_policy policy = to_utf8_error_policy::abort) + -> bool { for (auto p = s.begin(); p != s.end(); ++p) { uint32_t c = static_cast<uint32_t>(*p); if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) { @@ -1485,7 +1446,7 @@ template <typename WChar, typename Buffer = memory_buffer> class 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)}; @@ -1516,19 +1477,19 @@ inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept { 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); @@ -1541,14 +1502,14 @@ inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept { // 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; @@ -1602,14 +1563,14 @@ template <typename T> FMT_API auto to_decimal(T x) noexcept -> decimal_fp<T>; } // 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 - @@ -1702,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; @@ -1719,7 +1680,7 @@ FMT_CONSTEXPR basic_fp<F> normalize(basic_fp<F> value) { } // 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); @@ -1736,7 +1697,7 @@ FMT_CONSTEXPR inline uint64_t multiply(uint64_t lhs, uint64_t rhs) { #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}; } @@ -1962,8 +1923,9 @@ auto write_escaped_char(OutputIt out, Char v) -> OutputIt { *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_array, v_array + 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; } @@ -2052,10 +2014,10 @@ template <typename Char> class digit_grouping { 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>()) @@ -2074,9 +2036,9 @@ template <typename Char> class digit_grouping { digit_grouping(std::string grouping, std::basic_string<Char> sep) : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {} - bool has_separator() const { return !thousands_sep_.empty(); } + auto has_separator() const -> bool { return !thousands_sep_.empty(); } - int count_separators(int num_digits) const { + auto count_separators(int num_digits) const -> int { int count = 0; auto state = initial_state(); while (num_digits > next(state)) ++count; @@ -2085,7 +2047,7 @@ template <typename Char> class digit_grouping { // 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); @@ -2108,24 +2070,66 @@ template <typename Char> class digit_grouping { } }; +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())); }); } @@ -2138,11 +2142,6 @@ inline auto write_loc(OutputIt, loc_value, const format_specs<Char>&, 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; @@ -2289,25 +2288,25 @@ class counting_iterator { FMT_CONSTEXPR counting_iterator() : count_(0) {} - FMT_CONSTEXPR size_t count() const { return count_; } + FMT_CONSTEXPR auto count() const -> size_t { return count_; } - FMT_CONSTEXPR counting_iterator& operator++() { + FMT_CONSTEXPR auto operator++() -> counting_iterator& { ++count_; return *this; } - FMT_CONSTEXPR counting_iterator operator++(int) { + FMT_CONSTEXPR auto operator++(int) -> counting_iterator { auto it = *this; ++*this; return it; } - FMT_CONSTEXPR friend counting_iterator operator+(counting_iterator it, - difference_type n) { + FMT_CONSTEXPR friend auto operator+(counting_iterator it, difference_type n) + -> counting_iterator { it.count_ += static_cast<size_t>(n); return it; } - FMT_CONSTEXPR value_type operator*() const { return {}; } + FMT_CONSTEXPR auto operator*() const -> value_type { return {}; } }; template <typename Char, typename OutputIt> @@ -2342,9 +2341,10 @@ template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write(OutputIt out, const Char* s, const format_specs<Char>& specs, locale_ref) -> OutputIt { - return specs.type != presentation_type::pointer - ? write(out, basic_string_view<Char>(s), specs, {}) - : write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs); + if (specs.type == presentation_type::pointer) + return write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs); + if (!s) throw_format_error("string pointer is null"); + return write(out, basic_string_view<Char>(s), specs, {}); } template <typename Char, typename OutputIt, typename T, @@ -2430,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; @@ -2468,7 +2467,7 @@ FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs, result.format = float_format::hex; break; default: - eh.on_error("invalid format specifier"); + throw_format_error("invalid format specifier"); break; } return result; @@ -2707,12 +2706,12 @@ template <typename Char> class fallback_digit_grouping { public: constexpr fallback_digit_grouping(locale_ref, bool) {} - constexpr bool has_separator() const { return false; } + constexpr auto has_separator() const -> bool { return false; } - constexpr int count_separators(int) const { return 0; } + constexpr auto count_separators(int) const -> int { return 0; } template <typename Out, typename C> - constexpr Out apply(Out out, basic_string_view<C>) const { + constexpr auto apply(Out out, basic_string_view<C>) const -> Out { return out; } }; @@ -2731,7 +2730,7 @@ FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f, } } -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. } @@ -2744,14 +2743,14 @@ struct has_isfinite<T, enable_if_t<sizeof(std::isfinite(T())) != 0>> 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(true)) 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; @@ -2788,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)]; } @@ -2887,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; @@ -2906,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; @@ -2929,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()); @@ -3017,7 +3019,7 @@ class bigint { // 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, ""); @@ -3260,7 +3262,7 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, format_hexfloat(static_cast<double>(value), precision, specs, buf); } -constexpr uint32_t fractional_part_rounding_thresholds(int index) { +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. @@ -3799,62 +3801,39 @@ template <typename Char> struct arg_formatter { } }; -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); } @@ -3865,7 +3844,7 @@ FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> decltype(ctx.arg(id)) { 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) { @@ -3873,12 +3852,10 @@ FMT_CONSTEXPR void handle_dynamic_spec(int& value, 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; } } @@ -4050,12 +4027,10 @@ 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>, Char> { - using base = formatter<detail::format_as_t<T>, Char>; - using base::parse; - + : formatter<detail::format_as_t<T>, Char> { template <typename FormatContext> auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) { + using base = formatter<detail::format_as_t<T>, Char>; return base::format(format_as(value), ctx); } }; @@ -4380,7 +4355,7 @@ void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt, 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; } @@ -4407,7 +4382,7 @@ void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt, } 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; } @@ -4422,11 +4397,9 @@ void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt, 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>( @@ -4434,7 +4407,7 @@ void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt, 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; @@ -4537,16 +4510,16 @@ 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) { - auto specs = specs_; - detail::handle_dynamic_spec<detail::width_checker>(specs.width, - specs.width_ref, ctx); - detail::handle_dynamic_spec<detail::precision_checker>( - specs.precision, specs.precision_ref, ctx); - return detail::write<Char>(ctx.out(), val, specs, ctx.locale()); - } - return detail::write<Char>(ctx.out(), val, specs_, ctx.locale()); + if (specs_.width_ref.kind == detail::arg_id_kind::none && + specs_.precision_ref.kind == detail::arg_id_kind::none) { + return detail::write<Char>(ctx.out(), val, specs_, ctx.locale()); + } + auto specs = specs_; + detail::handle_dynamic_spec<detail::width_checker>(specs.width, + specs.width_ref, ctx); + detail::handle_dynamic_spec<detail::precision_checker>( + specs.precision, specs.precision_ref, ctx); + return detail::write<Char>(ctx.out(), val, specs, ctx.locale()); } FMT_END_NAMESPACE diff --git a/include/fmt/os.h b/include/fmt/os.h index 2b517cd4..3c7b3ccb 100644 --- a/include/fmt/os.h +++ b/include/fmt/os.h @@ -48,6 +48,7 @@ // Calls to system functions are wrapped in FMT_SYSTEM for testability. #ifdef FMT_SYSTEM +# define FMT_HAS_SYSTEM # define FMT_POSIX_CALL(call) FMT_SYSTEM(call) #else # define FMT_SYSTEM(call) ::call @@ -116,7 +117,7 @@ template <typename Char> class basic_cstring_view { basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {} /** Returns the pointer to a C string. */ - const Char* c_str() const { return data_; } + auto c_str() const -> const Char* { return data_; } }; using cstring_view = basic_cstring_view<char>; @@ -171,7 +172,7 @@ std::system_error windows_error(int error_code, string_view message, // Can be used to report errors from destructors. FMT_API void report_windows_error(int error_code, const char* message) noexcept; #else -inline const std::error_category& system_category() noexcept { +inline auto system_category() noexcept -> const std::error_category& { return std::system_category(); } #endif // _WIN32 @@ -208,7 +209,7 @@ class buffered_file { other.file_ = nullptr; } - buffered_file& operator=(buffered_file&& other) { + auto operator=(buffered_file&& other) -> buffered_file& { close(); file_ = other.file_; other.file_ = nullptr; @@ -222,9 +223,9 @@ class buffered_file { FMT_API void close(); // Returns the pointer to a FILE object representing this file. - FILE* get() const noexcept { return file_; } + auto get() const noexcept -> FILE* { return file_; } - FMT_API int descriptor() const; + FMT_API auto descriptor() const -> int; void vprint(string_view format_str, format_args args) { fmt::vprint(file_, format_str, args); @@ -274,7 +275,7 @@ class FMT_API file { file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; } // Move assignment is not noexcept because close may throw. - file& operator=(file&& other) { + auto operator=(file&& other) -> file& { close(); fd_ = other.fd_; other.fd_ = -1; @@ -285,24 +286,24 @@ class FMT_API file { ~file() noexcept; // Returns the file descriptor. - int descriptor() const noexcept { return fd_; } + auto descriptor() const noexcept -> int { return fd_; } // Closes the file. void close(); // Returns the file size. The size has signed type for consistency with // stat::st_size. - long long size() const; + auto size() const -> long long; // Attempts to read count bytes from the file into the specified buffer. - size_t read(void* buffer, size_t count); + auto read(void* buffer, size_t count) -> size_t; // Attempts to write count bytes from the specified buffer to the file. - size_t write(const void* buffer, size_t count); + auto write(const void* buffer, size_t count) -> size_t; // Duplicates a file descriptor with the dup function and returns // the duplicate as a file object. - static file dup(int fd); + static auto dup(int fd) -> file; // Makes fd be the copy of this file descriptor, closing fd first if // necessary. @@ -314,11 +315,12 @@ class FMT_API file { // Creates a pipe setting up read_end and write_end file objects for reading // and writing respectively. + // DEPRECATED! Taking files as out parameters is deprecated. static void pipe(file& read_end, file& write_end); // Creates a buffered_file object associated with this file and detaches // this file object from the file. - buffered_file fdopen(const char* mode); + auto fdopen(const char* mode) -> buffered_file; # if defined(_WIN32) && !defined(__MINGW32__) // Opens a file and constructs a file object representing this file by @@ -328,14 +330,14 @@ class FMT_API file { }; // Returns the memory page size. -long getpagesize(); +auto getpagesize() -> long; namespace detail { struct buffer_size { buffer_size() = default; size_t value = 0; - buffer_size operator=(size_t val) const { + auto operator=(size_t val) const -> buffer_size { auto bs = buffer_size(); bs.value = val; return bs; @@ -412,7 +414,7 @@ class FMT_API ostream { void flush() { buffer_.flush(); } template <typename... T> - friend ostream output_file(cstring_view path, T... params); + friend auto output_file(cstring_view path, T... params) -> ostream; void close() { buffer_.close(); } @@ -442,7 +444,7 @@ class FMT_API ostream { \endrst */ template <typename... T> -inline ostream output_file(cstring_view path, T... params) { +inline auto output_file(cstring_view path, T... params) -> ostream { return {path, detail::ostream_params(params...)}; } #endif // FMT_USE_FCNTL diff --git a/include/fmt/ostream.h b/include/fmt/ostream.h index 782ace5c..26fb3b5a 100644 --- a/include/fmt/ostream.h +++ b/include/fmt/ostream.h @@ -21,9 +21,39 @@ #include "format.h" FMT_BEGIN_NAMESPACE - namespace detail { +template <typename Streambuf> class formatbuf : public Streambuf { + private: + using char_type = typename Streambuf::char_type; + using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0)); + using int_type = typename Streambuf::int_type; + using traits_type = typename Streambuf::traits_type; + + buffer<char_type>& buffer_; + + public: + explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {} + + protected: + // The put area is always empty. This makes the implementation simpler and has + // the advantage that the streambuf and the buffer are always in sync and + // sputc never writes into uninitialized memory. A disadvantage is that each + // call to sputc always results in a (virtual) call to overflow. There is no + // disadvantage here for sputn since this always results in a call to xsputn. + + auto overflow(int_type ch) -> int_type override { + if (!traits_type::eq_int_type(ch, traits_type::eof())) + buffer_.push_back(static_cast<char_type>(ch)); + return ch; + } + + auto xsputn(const char_type* s, streamsize count) -> streamsize override { + buffer_.append(s, s + count); + return count; + } +}; + // Generate a unique explicit instantion in every translation unit using a tag // type in an anonymous namespace. namespace { @@ -40,7 +70,8 @@ template class file_access<file_access_tag, std::filebuf, auto get_file(std::filebuf&) -> 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())) @@ -69,8 +100,8 @@ inline bool write_ostream_unicode(std::ostream& os, fmt::string_view 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; } @@ -91,12 +122,11 @@ void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) { } 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); @@ -117,7 +147,7 @@ struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> { auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const -> OutputIt { auto buffer = basic_memory_buffer<Char>(); - detail::format_value(buffer, value, ctx.locale()); + detail::format_value(buffer, value); return formatter<basic_string_view<Char>, Char>::format( {buffer.data(), buffer.size()}, ctx); } diff --git a/include/fmt/ranges.h b/include/fmt/ranges.h index c0b51aee..3638fffb 100644 --- a/include/fmt/ranges.h +++ b/include/fmt/ranges.h @@ -183,7 +183,7 @@ template <size_t N> using make_index_sequence = std::make_index_sequence<N>; 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...>; @@ -207,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 = @@ -417,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; @@ -482,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); diff --git a/include/fmt/std.h b/include/fmt/std.h index 4d1f97d2..7cff1159 100644 --- a/include/fmt/std.h +++ b/include/fmt/std.h @@ -38,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> @@ -59,13 +63,31 @@ # endif #endif -#ifdef __cpp_lib_filesystem +// For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined. +#ifndef FMT_CPP_LIB_FILESYSTEM +# ifdef __cpp_lib_filesystem +# define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem +# else +# define FMT_CPP_LIB_FILESYSTEM 0 +# endif +#endif + +#ifndef FMT_CPP_LIB_VARIANT +# ifdef __cpp_lib_variant +# define FMT_CPP_LIB_VARIANT __cpp_lib_variant +# else +# define FMT_CPP_LIB_VARIANT 0 +# endif +#endif + +#if FMT_CPP_LIB_FILESYSTEM FMT_BEGIN_NAMESPACE namespace detail { -template <typename Char, typename PathChar> auto get_path_string( - const std::filesystem::path& p, const std::basic_string<PathChar>& native) { +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 @@ -76,7 +98,8 @@ template <typename Char, typename PathChar> void write_escaped_path(basic_memory_buffer<Char>& quoted, 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>) { + 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()}); @@ -97,6 +120,7 @@ template <typename Char> struct formatter<std::filesystem::path, Char> { 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; } @@ -113,27 +137,34 @@ template <typename Char> struct formatter<std::filesystem::path, Char> { debug_ = true; ++it; } + if (it != end && (*it == 'g')) path_type_ = *it++; return it; } template <typename FormatContext> auto format(const std::filesystem::path& p, FormatContext& ctx) const { auto specs = specs_; +# ifdef _WIN32 + auto path_string = !path_type_ ? p.native() : p.generic_wstring(); +# else + auto path_string = !path_type_ ? p.native() : p.generic_string(); +# endif + detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_, ctx); if (!debug_) { - auto s = detail::get_path_string<Char>(p, p.native()); + 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, p.native()); + detail::write_escaped_path(quoted, p, path_string); return detail::write(ctx.out(), basic_string_view<Char>(quoted.data(), quoted.size()), specs); } }; FMT_END_NAMESPACE -#endif +#endif // FMT_CPP_LIB_FILESYSTEM FMT_BEGIN_NAMESPACE FMT_EXPORT @@ -145,7 +176,7 @@ struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> { const std::bitset<N>& bs; template <typename OutputIt> - FMT_CONSTEXPR OutputIt operator()(OutputIt out) { + 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')); } @@ -197,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); @@ -211,7 +242,32 @@ 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_EXPORT +template <> struct formatter<std::source_location> { + template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) { + return ctx.begin(); + } + + template <typename FormatContext> + auto format(const std::source_location& loc, FormatContext& ctx) const + -> decltype(ctx.out()) { + auto out = ctx.out(); + out = detail::write(out, loc.file_name()); + out = detail::write(out, ':'); + out = detail::write<char>(out, loc.line()); + out = detail::write(out, ':'); + out = detail::write<char>(out, loc.column()); + out = detail::write(out, ": "); + out = detail::write(out, loc.function_name()); + return out; + } +}; +FMT_END_NAMESPACE +#endif + +#if FMT_CPP_LIB_VARIANT FMT_BEGIN_NAMESPACE namespace detail { @@ -302,7 +358,7 @@ struct formatter< } }; FMT_END_NAMESPACE -#endif // __cpp_lib_variant +#endif // FMT_CPP_LIB_VARIANT FMT_BEGIN_NAMESPACE FMT_EXPORT @@ -326,7 +382,7 @@ template <typename Char> struct formatter<std::error_code, Char> { 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; @@ -357,7 +413,7 @@ struct formatter< # 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; diff --git a/include/fmt/xchar.h b/include/fmt/xchar.h index 625ec369..f609c5c4 100644 --- a/include/fmt/xchar.h +++ b/include/fmt/xchar.h @@ -63,14 +63,15 @@ template <> struct is_char<char16_t> : std::true_type {}; template <> struct is_char<char32_t> : std::true_type {}; template <typename... T> -constexpr format_arg_store<wformat_context, T...> make_wformat_args( - const T&... args) { +constexpr auto make_wformat_args(const T&... args) + -> format_arg_store<wformat_context, T...> { return {args...}; } inline namespace literals { #if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS -constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) { +constexpr auto operator""_a(const wchar_t* s, size_t) + -> detail::udl_arg<wchar_t> { return {s}; } #endif @@ -172,11 +173,11 @@ inline auto vformat_to( return detail::get_iterator(buf, out); } -template < - typename OutputIt, typename Locale, typename S, typename... T, - typename Char = char_t<S>, - bool enable = detail::is_output_iterator<OutputIt, Char>::value&& - detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value> +template <typename OutputIt, typename Locale, typename S, typename... T, + typename Char = char_t<S>, + bool enable = detail::is_output_iterator<OutputIt, Char>::value && + detail::is_locale<Locale>::value && + detail::is_exotic_char<Char>::value> inline auto format_to(OutputIt out, const Locale& loc, const S& format_str, T&&... args) -> typename std::enable_if<enable, OutputIt>::type { |