1db2944e3SMark de Wever // -*- C++ -*- 2db2944e3SMark de Wever //===----------------------------------------------------------------------===// 3db2944e3SMark de Wever // 4db2944e3SMark de Wever // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5db2944e3SMark de Wever // See https://llvm.org/LICENSE.txt for license information. 6db2944e3SMark de Wever // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7db2944e3SMark de Wever // 8db2944e3SMark de Wever //===----------------------------------------------------------------------===// 9db2944e3SMark de Wever 10db2944e3SMark de Wever #ifndef _LIBCPP___FORMAT_FORMATTER_FLOATING_POINT_H 11db2944e3SMark de Wever #define _LIBCPP___FORMAT_FORMATTER_FLOATING_POINT_H 12db2944e3SMark de Wever 13db2944e3SMark de Wever #include <__algorithm/copy_n.h> 14db2944e3SMark de Wever #include <__algorithm/find.h> 15f92c733cSMark de Wever #include <__algorithm/max.h> 16db2944e3SMark de Wever #include <__algorithm/min.h> 17db2944e3SMark de Wever #include <__algorithm/rotate.h> 18db2944e3SMark de Wever #include <__algorithm/transform.h> 1937dca605SLouis Dionne #include <__assert> 2057e20cabSMark de Wever #include <__charconv/chars_format.h> 2157e20cabSMark de Wever #include <__charconv/to_chars_floating_point.h> 2257e20cabSMark de Wever #include <__charconv/to_chars_result.h> 23db2944e3SMark de Wever #include <__concepts/arithmetic.h> 24eebbfbcdSLouis Dionne #include <__concepts/same_as.h> 25db2944e3SMark de Wever #include <__config> 2623e2a041SLouis Dionne #include <__cstddef/ptrdiff_t.h> 27a595fcf9SMark de Wever #include <__format/concepts.h> 28152d9222SMark de Wever #include <__format/format_parse_context.h> 29db2944e3SMark de Wever #include <__format/formatter.h> 30db2944e3SMark de Wever #include <__format/formatter_integral.h> 31152d9222SMark de Wever #include <__format/formatter_output.h> 32db2944e3SMark de Wever #include <__format/parser_std_format_spec.h> 333ab20c68SMark de Wever #include <__iterator/concepts.h> 34eebbfbcdSLouis Dionne #include <__memory/allocator.h> 35eb65912eSNikolas Klauser #include <__system_error/errc.h> 360a4aa8a1SNikolas Klauser #include <__type_traits/conditional.h> 37db2944e3SMark de Wever #include <__utility/move.h> 382a8f9a5eSNikolas Klauser #include <__utility/unreachable.h> 3957e20cabSMark de Wever #include <cmath> 40db2944e3SMark de Wever 41c6f3b7bcSNikolas Klauser #if _LIBCPP_HAS_LOCALIZATION 425bcb7814SNikolas Klauser # include <__locale> 43db2944e3SMark de Wever #endif 44db2944e3SMark de Wever 45db2944e3SMark de Wever #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 46db2944e3SMark de Wever # pragma GCC system_header 47db2944e3SMark de Wever #endif 48db2944e3SMark de Wever 49db2944e3SMark de Wever _LIBCPP_PUSH_MACROS 50db2944e3SMark de Wever #include <__undef_macros> 51db2944e3SMark de Wever 52db2944e3SMark de Wever _LIBCPP_BEGIN_NAMESPACE_STD 53db2944e3SMark de Wever 544f15267dSNikolas Klauser #if _LIBCPP_STD_VER >= 20 55db2944e3SMark de Wever 56152d9222SMark de Wever namespace __formatter { 57db2944e3SMark de Wever 58db2944e3SMark de Wever template <floating_point _Tp> 59db2944e3SMark de Wever _LIBCPP_HIDE_FROM_ABI char* __to_buffer(char* __first, char* __last, _Tp __value) { 6077a00c0dSLouis Dionne to_chars_result __r = std::to_chars(__first, __last, __value); 614f215fddSKonstantin Varlamov _LIBCPP_ASSERT_INTERNAL(__r.ec == errc(0), "Internal buffer too small"); 62db2944e3SMark de Wever return __r.ptr; 63db2944e3SMark de Wever } 64db2944e3SMark de Wever 65db2944e3SMark de Wever template <floating_point _Tp> 66db2944e3SMark de Wever _LIBCPP_HIDE_FROM_ABI char* __to_buffer(char* __first, char* __last, _Tp __value, chars_format __fmt) { 6777a00c0dSLouis Dionne to_chars_result __r = std::to_chars(__first, __last, __value, __fmt); 684f215fddSKonstantin Varlamov _LIBCPP_ASSERT_INTERNAL(__r.ec == errc(0), "Internal buffer too small"); 69db2944e3SMark de Wever return __r.ptr; 70db2944e3SMark de Wever } 71db2944e3SMark de Wever 72db2944e3SMark de Wever template <floating_point _Tp> 73db2944e3SMark de Wever _LIBCPP_HIDE_FROM_ABI char* __to_buffer(char* __first, char* __last, _Tp __value, chars_format __fmt, int __precision) { 7477a00c0dSLouis Dionne to_chars_result __r = std::to_chars(__first, __last, __value, __fmt, __precision); 754f215fddSKonstantin Varlamov _LIBCPP_ASSERT_INTERNAL(__r.ec == errc(0), "Internal buffer too small"); 76db2944e3SMark de Wever return __r.ptr; 77db2944e3SMark de Wever } 78db2944e3SMark de Wever 79db2944e3SMark de Wever // https://en.cppreference.com/w/cpp/language/types#cite_note-1 80db2944e3SMark de Wever // float min subnormal: +/-0x1p-149 max: +/- 3.402,823,4 10^38 81db2944e3SMark de Wever // double min subnormal: +/-0x1p-1074 max +/- 1.797,693,134,862,315,7 10^308 82db2944e3SMark de Wever // long double (x86) min subnormal: +/-0x1p-16446 max: +/- 1.189,731,495,357,231,765,021 10^4932 83db2944e3SMark de Wever // 84db2944e3SMark de Wever // The maximum number of digits required for the integral part is based on the 85db2944e3SMark de Wever // maximum's value power of 10. Every power of 10 requires one additional 86db2944e3SMark de Wever // decimal digit. 87db2944e3SMark de Wever // The maximum number of digits required for the fractional part is based on 88db2944e3SMark de Wever // the minimal subnormal hexadecimal output's power of 10. Every division of a 89db2944e3SMark de Wever // fraction's binary 1 by 2, requires one additional decimal digit. 90db2944e3SMark de Wever // 91db2944e3SMark de Wever // The maximum size of a formatted value depends on the selected output format. 92db2944e3SMark de Wever // Ignoring the fact the format string can request a precision larger than the 93db2944e3SMark de Wever // values maximum required, these values are: 94db2944e3SMark de Wever // 95db2944e3SMark de Wever // sign 1 code unit 96db2944e3SMark de Wever // __max_integral 97db2944e3SMark de Wever // radix point 1 code unit 98db2944e3SMark de Wever // __max_fractional 99db2944e3SMark de Wever // exponent character 1 code unit 100db2944e3SMark de Wever // sign 1 code unit 101db2944e3SMark de Wever // __max_fractional_value 102db2944e3SMark de Wever // ----------------------------------- 103db2944e3SMark de Wever // total 4 code units extra required. 104db2944e3SMark de Wever // 105db2944e3SMark de Wever // TODO FMT Optimize the storage to avoid storing digits that are known to be zero. 106db2944e3SMark de Wever // https://www.exploringbinary.com/maximum-number-of-decimal-digits-in-binary-floating-point-numbers/ 107db2944e3SMark de Wever 108db2944e3SMark de Wever // TODO FMT Add long double specialization when to_chars has proper long double support. 109db2944e3SMark de Wever template <class _Tp> 110db2944e3SMark de Wever struct __traits; 111db2944e3SMark de Wever 112db2944e3SMark de Wever template <floating_point _Fp> 11380c7e93aSNikolas Klauser _LIBCPP_HIDE_FROM_ABI constexpr size_t __float_buffer_size(int __precision) { 114db2944e3SMark de Wever using _Traits = __traits<_Fp>; 115db2944e3SMark de Wever return 4 + _Traits::__max_integral + __precision + _Traits::__max_fractional_value; 116db2944e3SMark de Wever } 117db2944e3SMark de Wever 118db2944e3SMark de Wever template <> 119db2944e3SMark de Wever struct __traits<float> { 120db2944e3SMark de Wever static constexpr int __max_integral = 38; 121db2944e3SMark de Wever static constexpr int __max_fractional = 149; 122db2944e3SMark de Wever static constexpr int __max_fractional_value = 3; 123db2944e3SMark de Wever static constexpr size_t __stack_buffer_size = 256; 124db2944e3SMark de Wever 125db2944e3SMark de Wever static constexpr int __hex_precision_digits = 3; 126db2944e3SMark de Wever }; 127db2944e3SMark de Wever 128db2944e3SMark de Wever template <> 129db2944e3SMark de Wever struct __traits<double> { 130db2944e3SMark de Wever static constexpr int __max_integral = 308; 131db2944e3SMark de Wever static constexpr int __max_fractional = 1074; 132db2944e3SMark de Wever static constexpr int __max_fractional_value = 4; 133db2944e3SMark de Wever static constexpr size_t __stack_buffer_size = 1024; 134db2944e3SMark de Wever 135db2944e3SMark de Wever static constexpr int __hex_precision_digits = 4; 136db2944e3SMark de Wever }; 137db2944e3SMark de Wever 138db2944e3SMark de Wever /// Helper class to store the conversion buffer. 139db2944e3SMark de Wever /// 140e2fc68c3SHans Wennborg /// Depending on the maximum size required for a value, the buffer is allocated 141db2944e3SMark de Wever /// on the stack or the heap. 142db2944e3SMark de Wever template <floating_point _Fp> 143db2944e3SMark de Wever class _LIBCPP_TEMPLATE_VIS __float_buffer { 144*f6958523SNikolas Klauser using _Traits _LIBCPP_NODEBUG = __traits<_Fp>; 145db2944e3SMark de Wever 146db2944e3SMark de Wever public: 147db2944e3SMark de Wever // TODO FMT Improve this constructor to do a better estimate. 148db2944e3SMark de Wever // When using a scientific formatting with a precision of 6 a stack buffer 149db2944e3SMark de Wever // will always suffice. At the moment that isn't important since floats and 150db2944e3SMark de Wever // doubles use a stack buffer, unless the precision used in the format string 151db2944e3SMark de Wever // is large. 152db2944e3SMark de Wever // When supporting long doubles the __max_integral part becomes 4932 which 153db2944e3SMark de Wever // may be too much for some platforms. For these cases a better estimate is 154db2944e3SMark de Wever // required. 155db2944e3SMark de Wever explicit _LIBCPP_HIDE_FROM_ABI __float_buffer(int __precision) 156db2944e3SMark de Wever : __precision_(__precision != -1 ? __precision : _Traits::__max_fractional) { 157db2944e3SMark de Wever // When the precision is larger than _Traits::__max_fractional the digits in 158db2944e3SMark de Wever // the range (_Traits::__max_fractional, precision] will contain the value 159db2944e3SMark de Wever // zero. There's no need to request to_chars to write these zeros: 160db2944e3SMark de Wever // - When the value is large a temporary heap buffer needs to be allocated. 161db2944e3SMark de Wever // - When to_chars writes the values they need to be "copied" to the output: 162db2944e3SMark de Wever // - char: std::fill on the output iterator is faster than std::copy. 163db2944e3SMark de Wever // - wchar_t: same argument as char, but additional std::copy won't work. 164db2944e3SMark de Wever // The input is always a char buffer, so every char in the buffer needs 165db2944e3SMark de Wever // to be converted from a char to a wchar_t. 166db2944e3SMark de Wever if (__precision_ > _Traits::__max_fractional) { 167db2944e3SMark de Wever __num_trailing_zeros_ = __precision_ - _Traits::__max_fractional; 168db2944e3SMark de Wever __precision_ = _Traits::__max_fractional; 169db2944e3SMark de Wever } 170db2944e3SMark de Wever 171152d9222SMark de Wever __size_ = __formatter::__float_buffer_size<_Fp>(__precision_); 172db2944e3SMark de Wever if (__size_ > _Traits::__stack_buffer_size) 173db2944e3SMark de Wever // The allocated buffer's contents don't need initialization. 174db2944e3SMark de Wever __begin_ = allocator<char>{}.allocate(__size_); 175db2944e3SMark de Wever else 176db2944e3SMark de Wever __begin_ = __buffer_; 177db2944e3SMark de Wever } 178db2944e3SMark de Wever 179db2944e3SMark de Wever _LIBCPP_HIDE_FROM_ABI ~__float_buffer() { 180db2944e3SMark de Wever if (__size_ > _Traits::__stack_buffer_size) 181db2944e3SMark de Wever allocator<char>{}.deallocate(__begin_, __size_); 182db2944e3SMark de Wever } 183db2944e3SMark de Wever _LIBCPP_HIDE_FROM_ABI __float_buffer(const __float_buffer&) = delete; 184db2944e3SMark de Wever _LIBCPP_HIDE_FROM_ABI __float_buffer& operator=(const __float_buffer&) = delete; 185db2944e3SMark de Wever 186db2944e3SMark de Wever _LIBCPP_HIDE_FROM_ABI char* begin() const { return __begin_; } 187db2944e3SMark de Wever _LIBCPP_HIDE_FROM_ABI char* end() const { return __begin_ + __size_; } 188db2944e3SMark de Wever 189db2944e3SMark de Wever _LIBCPP_HIDE_FROM_ABI int __precision() const { return __precision_; } 190db2944e3SMark de Wever _LIBCPP_HIDE_FROM_ABI int __num_trailing_zeros() const { return __num_trailing_zeros_; } 191db2944e3SMark de Wever _LIBCPP_HIDE_FROM_ABI void __remove_trailing_zeros() { __num_trailing_zeros_ = 0; } 192f92c733cSMark de Wever _LIBCPP_HIDE_FROM_ABI void __add_trailing_zeros(int __zeros) { __num_trailing_zeros_ += __zeros; } 193db2944e3SMark de Wever 194db2944e3SMark de Wever private: 195db2944e3SMark de Wever int __precision_; 196db2944e3SMark de Wever int __num_trailing_zeros_{0}; 197db2944e3SMark de Wever size_t __size_; 198db2944e3SMark de Wever char* __begin_; 199db2944e3SMark de Wever char __buffer_[_Traits::__stack_buffer_size]; 200db2944e3SMark de Wever }; 201db2944e3SMark de Wever 202db2944e3SMark de Wever struct __float_result { 203db2944e3SMark de Wever /// Points at the beginning of the integral part in the buffer. 204db2944e3SMark de Wever /// 205db2944e3SMark de Wever /// When there's no sign character this points at the start of the buffer. 206db2944e3SMark de Wever char* __integral; 207db2944e3SMark de Wever 208db2944e3SMark de Wever /// Points at the radix point, when not present it's the same as \ref __last. 209db2944e3SMark de Wever char* __radix_point; 210db2944e3SMark de Wever 211db2944e3SMark de Wever /// Points at the exponent character, when not present it's the same as \ref __last. 212db2944e3SMark de Wever char* __exponent; 213db2944e3SMark de Wever 214db2944e3SMark de Wever /// Points beyond the last written element in the buffer. 215db2944e3SMark de Wever char* __last; 216db2944e3SMark de Wever }; 217db2944e3SMark de Wever 218db2944e3SMark de Wever /// Finds the position of the exponent character 'e' at the end of the buffer. 219db2944e3SMark de Wever /// 220db2944e3SMark de Wever /// Assuming there is an exponent the input will terminate with 221db2944e3SMark de Wever /// eSdd and eSdddd (S = sign, d = digit) 222db2944e3SMark de Wever /// 223db2944e3SMark de Wever /// \returns a pointer to the exponent or __last when not found. 224db2944e3SMark de Wever constexpr inline _LIBCPP_HIDE_FROM_ABI char* __find_exponent(char* __first, char* __last) { 225db2944e3SMark de Wever ptrdiff_t __size = __last - __first; 226f92c733cSMark de Wever if (__size >= 4) { 22777a00c0dSLouis Dionne __first = __last - std::min(__size, ptrdiff_t(6)); 228db2944e3SMark de Wever for (; __first != __last - 3; ++__first) { 229db2944e3SMark de Wever if (*__first == 'e') 230db2944e3SMark de Wever return __first; 231db2944e3SMark de Wever } 232db2944e3SMark de Wever } 233db2944e3SMark de Wever return __last; 234db2944e3SMark de Wever } 235db2944e3SMark de Wever 236db2944e3SMark de Wever template <class _Fp, class _Tp> 2379783f28cSLouis Dionne _LIBCPP_HIDE_FROM_ABI __float_result 2389783f28cSLouis Dionne __format_buffer_default(const __float_buffer<_Fp>& __buffer, _Tp __value, char* __integral) { 239db2944e3SMark de Wever __float_result __result; 240db2944e3SMark de Wever __result.__integral = __integral; 241152d9222SMark de Wever __result.__last = __formatter::__to_buffer(__integral, __buffer.end(), __value); 242db2944e3SMark de Wever 243152d9222SMark de Wever __result.__exponent = __formatter::__find_exponent(__result.__integral, __result.__last); 244db2944e3SMark de Wever 245db2944e3SMark de Wever // Constrains: 246db2944e3SMark de Wever // - There's at least one decimal digit before the radix point. 247db2944e3SMark de Wever // - The radix point, when present, is placed before the exponent. 24877a00c0dSLouis Dionne __result.__radix_point = std::find(__result.__integral + 1, __result.__exponent, '.'); 249db2944e3SMark de Wever 250db2944e3SMark de Wever // When the radix point isn't found its position is the exponent instead of 251db2944e3SMark de Wever // __result.__last. 252db2944e3SMark de Wever if (__result.__radix_point == __result.__exponent) 253db2944e3SMark de Wever __result.__radix_point = __result.__last; 254db2944e3SMark de Wever 255db2944e3SMark de Wever // clang-format off 2564f215fddSKonstantin Varlamov _LIBCPP_ASSERT_INTERNAL((__result.__integral != __result.__last) && 257db2944e3SMark de Wever (__result.__radix_point == __result.__last || *__result.__radix_point == '.') && 258db2944e3SMark de Wever (__result.__exponent == __result.__last || *__result.__exponent == 'e'), 259db2944e3SMark de Wever "Post-condition failure."); 260db2944e3SMark de Wever // clang-format on 261db2944e3SMark de Wever 262db2944e3SMark de Wever return __result; 263db2944e3SMark de Wever } 264db2944e3SMark de Wever 265db2944e3SMark de Wever template <class _Fp, class _Tp> 2669783f28cSLouis Dionne _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_hexadecimal_lower_case( 2679783f28cSLouis Dionne const __float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) { 268db2944e3SMark de Wever __float_result __result; 269db2944e3SMark de Wever __result.__integral = __integral; 270db2944e3SMark de Wever if (__precision == -1) 271152d9222SMark de Wever __result.__last = __formatter::__to_buffer(__integral, __buffer.end(), __value, chars_format::hex); 272db2944e3SMark de Wever else 273152d9222SMark de Wever __result.__last = __formatter::__to_buffer(__integral, __buffer.end(), __value, chars_format::hex, __precision); 274db2944e3SMark de Wever 275db2944e3SMark de Wever // H = one or more hex-digits 276db2944e3SMark de Wever // S = sign 277db2944e3SMark de Wever // D = one or more decimal-digits 278db2944e3SMark de Wever // When the fractional part is zero and no precision the output is 0p+0 279db2944e3SMark de Wever // else the output is 0.HpSD 280db2944e3SMark de Wever // So testing the second position can differentiate between these two cases. 281db2944e3SMark de Wever char* __first = __integral + 1; 282db2944e3SMark de Wever if (*__first == '.') { 283db2944e3SMark de Wever __result.__radix_point = __first; 284db2944e3SMark de Wever // One digit is the minimum 285db2944e3SMark de Wever // 0.hpSd 286db2944e3SMark de Wever // ^-- last 287db2944e3SMark de Wever // ^---- integral = end of search 288db2944e3SMark de Wever // ^-------- start of search 289db2944e3SMark de Wever // 0123456 290db2944e3SMark de Wever // 291db2944e3SMark de Wever // Four digits is the maximum 292db2944e3SMark de Wever // 0.hpSdddd 293db2944e3SMark de Wever // ^-- last 294db2944e3SMark de Wever // ^---- integral = end of search 295db2944e3SMark de Wever // ^-------- start of search 296db2944e3SMark de Wever // 0123456789 297db2944e3SMark de Wever static_assert(__traits<_Fp>::__hex_precision_digits <= 4, "Guard against possible underflow."); 298db2944e3SMark de Wever 299db2944e3SMark de Wever char* __last = __result.__last - 2; 300db2944e3SMark de Wever __first = __last - __traits<_Fp>::__hex_precision_digits; 30177a00c0dSLouis Dionne __result.__exponent = std::find(__first, __last, 'p'); 302db2944e3SMark de Wever } else { 303db2944e3SMark de Wever __result.__radix_point = __result.__last; 304db2944e3SMark de Wever __result.__exponent = __first; 305db2944e3SMark de Wever } 306db2944e3SMark de Wever 307db2944e3SMark de Wever // clang-format off 3084f215fddSKonstantin Varlamov _LIBCPP_ASSERT_INTERNAL((__result.__integral != __result.__last) && 309db2944e3SMark de Wever (__result.__radix_point == __result.__last || *__result.__radix_point == '.') && 310db2944e3SMark de Wever (__result.__exponent != __result.__last && *__result.__exponent == 'p'), 311db2944e3SMark de Wever "Post-condition failure."); 312db2944e3SMark de Wever // clang-format on 313db2944e3SMark de Wever 314db2944e3SMark de Wever return __result; 315db2944e3SMark de Wever } 316db2944e3SMark de Wever 317db2944e3SMark de Wever template <class _Fp, class _Tp> 3189783f28cSLouis Dionne _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_hexadecimal_upper_case( 3199783f28cSLouis Dionne const __float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) { 320db2944e3SMark de Wever __float_result __result = 321152d9222SMark de Wever __formatter::__format_buffer_hexadecimal_lower_case(__buffer, __value, __precision, __integral); 32277a00c0dSLouis Dionne std::transform(__result.__integral, __result.__exponent, __result.__integral, __hex_to_upper); 323db2944e3SMark de Wever *__result.__exponent = 'P'; 324db2944e3SMark de Wever return __result; 325db2944e3SMark de Wever } 326db2944e3SMark de Wever 327db2944e3SMark de Wever template <class _Fp, class _Tp> 3289783f28cSLouis Dionne _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_scientific_lower_case( 3299783f28cSLouis Dionne const __float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) { 330db2944e3SMark de Wever __float_result __result; 331db2944e3SMark de Wever __result.__integral = __integral; 332db2944e3SMark de Wever __result.__last = 333152d9222SMark de Wever __formatter::__to_buffer(__integral, __buffer.end(), __value, chars_format::scientific, __precision); 334db2944e3SMark de Wever 335db2944e3SMark de Wever char* __first = __integral + 1; 3364f215fddSKonstantin Varlamov _LIBCPP_ASSERT_INTERNAL(__first != __result.__last, "No exponent present"); 337db2944e3SMark de Wever if (*__first == '.') { 338db2944e3SMark de Wever __result.__radix_point = __first; 339152d9222SMark de Wever __result.__exponent = __formatter::__find_exponent(__first + 1, __result.__last); 340db2944e3SMark de Wever } else { 341db2944e3SMark de Wever __result.__radix_point = __result.__last; 342db2944e3SMark de Wever __result.__exponent = __first; 343db2944e3SMark de Wever } 344db2944e3SMark de Wever 345db2944e3SMark de Wever // clang-format off 3464f215fddSKonstantin Varlamov _LIBCPP_ASSERT_INTERNAL((__result.__integral != __result.__last) && 347db2944e3SMark de Wever (__result.__radix_point == __result.__last || *__result.__radix_point == '.') && 348db2944e3SMark de Wever (__result.__exponent != __result.__last && *__result.__exponent == 'e'), 349db2944e3SMark de Wever "Post-condition failure."); 350db2944e3SMark de Wever // clang-format on 351db2944e3SMark de Wever return __result; 352db2944e3SMark de Wever } 353db2944e3SMark de Wever 354db2944e3SMark de Wever template <class _Fp, class _Tp> 3559783f28cSLouis Dionne _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_scientific_upper_case( 3569783f28cSLouis Dionne const __float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) { 357db2944e3SMark de Wever __float_result __result = 358152d9222SMark de Wever __formatter::__format_buffer_scientific_lower_case(__buffer, __value, __precision, __integral); 359db2944e3SMark de Wever *__result.__exponent = 'E'; 360db2944e3SMark de Wever return __result; 361db2944e3SMark de Wever } 362db2944e3SMark de Wever 363db2944e3SMark de Wever template <class _Fp, class _Tp> 3649783f28cSLouis Dionne _LIBCPP_HIDE_FROM_ABI __float_result 3659783f28cSLouis Dionne __format_buffer_fixed(const __float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) { 366db2944e3SMark de Wever __float_result __result; 367db2944e3SMark de Wever __result.__integral = __integral; 368152d9222SMark de Wever __result.__last = __formatter::__to_buffer(__integral, __buffer.end(), __value, chars_format::fixed, __precision); 369db2944e3SMark de Wever 370db2944e3SMark de Wever // When there's no precision there's no radix point. 371db2944e3SMark de Wever // Else the radix point is placed at __precision + 1 from the end. 372db2944e3SMark de Wever // By converting __precision to a bool the subtraction can be done 373db2944e3SMark de Wever // unconditionally. 374db2944e3SMark de Wever __result.__radix_point = __result.__last - (__precision + bool(__precision)); 375db2944e3SMark de Wever __result.__exponent = __result.__last; 376db2944e3SMark de Wever 377db2944e3SMark de Wever // clang-format off 3784f215fddSKonstantin Varlamov _LIBCPP_ASSERT_INTERNAL((__result.__integral != __result.__last) && 379db2944e3SMark de Wever (__result.__radix_point == __result.__last || *__result.__radix_point == '.') && 380db2944e3SMark de Wever (__result.__exponent == __result.__last), 381db2944e3SMark de Wever "Post-condition failure."); 382db2944e3SMark de Wever // clang-format on 383db2944e3SMark de Wever return __result; 384db2944e3SMark de Wever } 385db2944e3SMark de Wever 386db2944e3SMark de Wever template <class _Fp, class _Tp> 3879783f28cSLouis Dionne _LIBCPP_HIDE_FROM_ABI __float_result 3889783f28cSLouis Dionne __format_buffer_general_lower_case(__float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) { 389db2944e3SMark de Wever __buffer.__remove_trailing_zeros(); 390db2944e3SMark de Wever 391db2944e3SMark de Wever __float_result __result; 392db2944e3SMark de Wever __result.__integral = __integral; 393152d9222SMark de Wever __result.__last = __formatter::__to_buffer(__integral, __buffer.end(), __value, chars_format::general, __precision); 394db2944e3SMark de Wever 395db2944e3SMark de Wever char* __first = __integral + 1; 396db2944e3SMark de Wever if (__first == __result.__last) { 397db2944e3SMark de Wever __result.__radix_point = __result.__last; 398db2944e3SMark de Wever __result.__exponent = __result.__last; 399db2944e3SMark de Wever } else { 400152d9222SMark de Wever __result.__exponent = __formatter::__find_exponent(__first, __result.__last); 401db2944e3SMark de Wever if (__result.__exponent != __result.__last) 402db2944e3SMark de Wever // In scientific mode if there's a radix point it will always be after 403db2944e3SMark de Wever // the first digit. (This is the position __first points at). 404db2944e3SMark de Wever __result.__radix_point = *__first == '.' ? __first : __result.__last; 405db2944e3SMark de Wever else { 406db2944e3SMark de Wever // In fixed mode the algorithm truncates trailing spaces and possibly the 407db2944e3SMark de Wever // radix point. There's no good guess for the position of the radix point 408db2944e3SMark de Wever // therefore scan the output after the first digit. 40977a00c0dSLouis Dionne __result.__radix_point = std::find(__first, __result.__last, '.'); 410db2944e3SMark de Wever } 411db2944e3SMark de Wever } 412db2944e3SMark de Wever 413db2944e3SMark de Wever // clang-format off 4144f215fddSKonstantin Varlamov _LIBCPP_ASSERT_INTERNAL((__result.__integral != __result.__last) && 415db2944e3SMark de Wever (__result.__radix_point == __result.__last || *__result.__radix_point == '.') && 416db2944e3SMark de Wever (__result.__exponent == __result.__last || *__result.__exponent == 'e'), 417db2944e3SMark de Wever "Post-condition failure."); 418db2944e3SMark de Wever // clang-format on 419db2944e3SMark de Wever 420db2944e3SMark de Wever return __result; 421db2944e3SMark de Wever } 422db2944e3SMark de Wever 423db2944e3SMark de Wever template <class _Fp, class _Tp> 4249783f28cSLouis Dionne _LIBCPP_HIDE_FROM_ABI __float_result 4259783f28cSLouis Dionne __format_buffer_general_upper_case(__float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) { 426152d9222SMark de Wever __float_result __result = __formatter::__format_buffer_general_lower_case(__buffer, __value, __precision, __integral); 427db2944e3SMark de Wever if (__result.__exponent != __result.__last) 428db2944e3SMark de Wever *__result.__exponent = 'E'; 429db2944e3SMark de Wever return __result; 430db2944e3SMark de Wever } 431db2944e3SMark de Wever 432152d9222SMark de Wever /// Fills the buffer with the data based on the requested formatting. 433152d9222SMark de Wever /// 434152d9222SMark de Wever /// This function, when needed, turns the characters to upper case and 435152d9222SMark de Wever /// determines the "interesting" locations which are returned to the caller. 436152d9222SMark de Wever /// 437152d9222SMark de Wever /// This means the caller never has to convert the contents of the buffer to 438152d9222SMark de Wever /// upper case or search for radix points and the location of the exponent. 439152d9222SMark de Wever /// This gives a bit of overhead. The original code didn't do that, but due 440152d9222SMark de Wever /// to the number of possible additional work needed to turn this number to 441152d9222SMark de Wever /// the proper output the code was littered with tests for upper cases and 442152d9222SMark de Wever /// searches for radix points and exponents. 443152d9222SMark de Wever /// - When a precision larger than the type's precision is selected 444152d9222SMark de Wever /// additional zero characters need to be written before the exponent. 445152d9222SMark de Wever /// - alternate form needs to add a radix point when not present. 446152d9222SMark de Wever /// - localization needs to do grouping in the integral part. 447152d9222SMark de Wever template <class _Fp, class _Tp> 448152d9222SMark de Wever // TODO FMT _Fp should just be _Tp when to_chars has proper long double support. 449152d9222SMark de Wever _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer( 450152d9222SMark de Wever __float_buffer<_Fp>& __buffer, 451152d9222SMark de Wever _Tp __value, 452152d9222SMark de Wever bool __negative, 453152d9222SMark de Wever bool __has_precision, 454152d9222SMark de Wever __format_spec::__sign __sign, 455152d9222SMark de Wever __format_spec::__type __type) { 456152d9222SMark de Wever char* __first = __formatter::__insert_sign(__buffer.begin(), __negative, __sign); 457152d9222SMark de Wever switch (__type) { 458152d9222SMark de Wever case __format_spec::__type::__default: 459f92c733cSMark de Wever if (__has_precision) 460f92c733cSMark de Wever return __formatter::__format_buffer_general_lower_case(__buffer, __value, __buffer.__precision(), __first); 461f92c733cSMark de Wever else 462152d9222SMark de Wever return __formatter::__format_buffer_default(__buffer, __value, __first); 463152d9222SMark de Wever 464152d9222SMark de Wever case __format_spec::__type::__hexfloat_lower_case: 465152d9222SMark de Wever return __formatter::__format_buffer_hexadecimal_lower_case( 466152d9222SMark de Wever __buffer, __value, __has_precision ? __buffer.__precision() : -1, __first); 467152d9222SMark de Wever 468152d9222SMark de Wever case __format_spec::__type::__hexfloat_upper_case: 469152d9222SMark de Wever return __formatter::__format_buffer_hexadecimal_upper_case( 470152d9222SMark de Wever __buffer, __value, __has_precision ? __buffer.__precision() : -1, __first); 471152d9222SMark de Wever 472152d9222SMark de Wever case __format_spec::__type::__scientific_lower_case: 473152d9222SMark de Wever return __formatter::__format_buffer_scientific_lower_case(__buffer, __value, __buffer.__precision(), __first); 474152d9222SMark de Wever 475152d9222SMark de Wever case __format_spec::__type::__scientific_upper_case: 476152d9222SMark de Wever return __formatter::__format_buffer_scientific_upper_case(__buffer, __value, __buffer.__precision(), __first); 477152d9222SMark de Wever 478152d9222SMark de Wever case __format_spec::__type::__fixed_lower_case: 479152d9222SMark de Wever case __format_spec::__type::__fixed_upper_case: 480152d9222SMark de Wever return __formatter::__format_buffer_fixed(__buffer, __value, __buffer.__precision(), __first); 481152d9222SMark de Wever 482152d9222SMark de Wever case __format_spec::__type::__general_lower_case: 483152d9222SMark de Wever return __formatter::__format_buffer_general_lower_case(__buffer, __value, __buffer.__precision(), __first); 484152d9222SMark de Wever 485152d9222SMark de Wever case __format_spec::__type::__general_upper_case: 486152d9222SMark de Wever return __formatter::__format_buffer_general_upper_case(__buffer, __value, __buffer.__precision(), __first); 487152d9222SMark de Wever 488152d9222SMark de Wever default: 4894f215fddSKonstantin Varlamov _LIBCPP_ASSERT_INTERNAL(false, "The parser should have validated the type"); 490152d9222SMark de Wever __libcpp_unreachable(); 491152d9222SMark de Wever } 492152d9222SMark de Wever } 493152d9222SMark de Wever 494c6f3b7bcSNikolas Klauser # if _LIBCPP_HAS_LOCALIZATION 495db2944e3SMark de Wever template <class _OutIt, class _Fp, class _CharT> 496152d9222SMark de Wever _LIBCPP_HIDE_FROM_ABI _OutIt __format_locale_specific_form( 497152d9222SMark de Wever _OutIt __out_it, 498152d9222SMark de Wever const __float_buffer<_Fp>& __buffer, 499152d9222SMark de Wever const __float_result& __result, 50077a00c0dSLouis Dionne std::locale __loc, 501152d9222SMark de Wever __format_spec::__parsed_specifications<_CharT> __specs) { 502841399a2SNikolas Klauser const auto& __np = std::use_facet<numpunct<_CharT>>(__loc); 503db2944e3SMark de Wever string __grouping = __np.grouping(); 504db2944e3SMark de Wever char* __first = __result.__integral; 505db2944e3SMark de Wever // When no radix point or exponent are present __last will be __result.__last. 50677a00c0dSLouis Dionne char* __last = std::min(__result.__radix_point, __result.__exponent); 507db2944e3SMark de Wever 508db2944e3SMark de Wever ptrdiff_t __digits = __last - __first; 509db2944e3SMark de Wever if (!__grouping.empty()) { 510db2944e3SMark de Wever if (__digits <= __grouping[0]) 511db2944e3SMark de Wever __grouping.clear(); 512db2944e3SMark de Wever else 51338adfa91SMark de Wever __grouping = __formatter::__determine_grouping(__digits, __grouping); 514db2944e3SMark de Wever } 515db2944e3SMark de Wever 516152d9222SMark de Wever ptrdiff_t __size = 517152d9222SMark de Wever __result.__last - __buffer.begin() + // Formatted string 518db2944e3SMark de Wever __buffer.__num_trailing_zeros() + // Not yet rendered zeros 519db2944e3SMark de Wever __grouping.size() - // Grouping contains one 520db2944e3SMark de Wever !__grouping.empty(); // additional character 521db2944e3SMark de Wever 522207e7e4aSMark de Wever __formatter::__padding_size_result __padding = {0, 0}; 523152d9222SMark de Wever bool __zero_padding = __specs.__alignment_ == __format_spec::__alignment::__zero_padding; 524152d9222SMark de Wever if (__size < __specs.__width_) { 525db2944e3SMark de Wever if (__zero_padding) { 526152d9222SMark de Wever __specs.__alignment_ = __format_spec::__alignment::__right; 5275db033e2SMark de Wever __specs.__fill_.__data[0] = _CharT('0'); 528db2944e3SMark de Wever } 529db2944e3SMark de Wever 530207e7e4aSMark de Wever __padding = __formatter::__padding_size(__size, __specs.__width_, __specs.__alignment_); 531db2944e3SMark de Wever } 532db2944e3SMark de Wever 533db2944e3SMark de Wever // sign and (zero padding or alignment) 534db2944e3SMark de Wever if (__zero_padding && __first != __buffer.begin()) 535db2944e3SMark de Wever *__out_it++ = *__buffer.begin(); 53677a00c0dSLouis Dionne __out_it = __formatter::__fill(std::move(__out_it), __padding.__before_, __specs.__fill_); 537db2944e3SMark de Wever if (!__zero_padding && __first != __buffer.begin()) 538db2944e3SMark de Wever *__out_it++ = *__buffer.begin(); 539db2944e3SMark de Wever 540db2944e3SMark de Wever // integral part 541db2944e3SMark de Wever if (__grouping.empty()) { 54277a00c0dSLouis Dionne __out_it = __formatter::__copy(__first, __digits, std::move(__out_it)); 543db2944e3SMark de Wever } else { 544db2944e3SMark de Wever auto __r = __grouping.rbegin(); 545db2944e3SMark de Wever auto __e = __grouping.rend() - 1; 546db2944e3SMark de Wever _CharT __sep = __np.thousands_sep(); 547db2944e3SMark de Wever // The output is divided in small groups of numbers to write: 548db2944e3SMark de Wever // - A group before the first separator. 549db2944e3SMark de Wever // - A separator and a group, repeated for the number of separators. 550db2944e3SMark de Wever // - A group after the last separator. 551db2944e3SMark de Wever // This loop achieves that process by testing the termination condition 552db2944e3SMark de Wever // midway in the loop. 553db2944e3SMark de Wever while (true) { 55477a00c0dSLouis Dionne __out_it = __formatter::__copy(__first, *__r, std::move(__out_it)); 555db2944e3SMark de Wever __first += *__r; 556db2944e3SMark de Wever 557db2944e3SMark de Wever if (__r == __e) 558db2944e3SMark de Wever break; 559db2944e3SMark de Wever 560db2944e3SMark de Wever ++__r; 561db2944e3SMark de Wever *__out_it++ = __sep; 562db2944e3SMark de Wever } 563db2944e3SMark de Wever } 564db2944e3SMark de Wever 565db2944e3SMark de Wever // fractional part 566db2944e3SMark de Wever if (__result.__radix_point != __result.__last) { 567db2944e3SMark de Wever *__out_it++ = __np.decimal_point(); 56877a00c0dSLouis Dionne __out_it = __formatter::__copy(__result.__radix_point + 1, __result.__exponent, std::move(__out_it)); 56977a00c0dSLouis Dionne __out_it = __formatter::__fill(std::move(__out_it), __buffer.__num_trailing_zeros(), _CharT('0')); 570db2944e3SMark de Wever } 571db2944e3SMark de Wever 572db2944e3SMark de Wever // exponent 573db2944e3SMark de Wever if (__result.__exponent != __result.__last) 57477a00c0dSLouis Dionne __out_it = __formatter::__copy(__result.__exponent, __result.__last, std::move(__out_it)); 575db2944e3SMark de Wever 576db2944e3SMark de Wever // alignment 57777a00c0dSLouis Dionne return __formatter::__fill(std::move(__out_it), __padding.__after_, __specs.__fill_); 578db2944e3SMark de Wever } 579c6f3b7bcSNikolas Klauser # endif // _LIBCPP_HAS_LOCALIZATION 580db2944e3SMark de Wever 581152d9222SMark de Wever template <class _OutIt, class _CharT> 582152d9222SMark de Wever _LIBCPP_HIDE_FROM_ABI _OutIt __format_floating_point_non_finite( 583152d9222SMark de Wever _OutIt __out_it, __format_spec::__parsed_specifications<_CharT> __specs, bool __negative, bool __isnan) { 584152d9222SMark de Wever char __buffer[4]; 585152d9222SMark de Wever char* __last = __formatter::__insert_sign(__buffer, __negative, __specs.__std_.__sign_); 586db2944e3SMark de Wever 587152d9222SMark de Wever // to_chars can return inf, infinity, nan, and nan(n-char-sequence). 588152d9222SMark de Wever // The format library requires inf and nan. 589152d9222SMark de Wever // All in one expression to avoid dangling references. 590152d9222SMark de Wever bool __upper_case = 591152d9222SMark de Wever __specs.__std_.__type_ == __format_spec::__type::__hexfloat_upper_case || 592152d9222SMark de Wever __specs.__std_.__type_ == __format_spec::__type::__scientific_upper_case || 593152d9222SMark de Wever __specs.__std_.__type_ == __format_spec::__type::__fixed_upper_case || 594152d9222SMark de Wever __specs.__std_.__type_ == __format_spec::__type::__general_upper_case; 59577a00c0dSLouis Dionne __last = std::copy_n(&("infnanINFNAN"[6 * __upper_case + 3 * __isnan]), 3, __last); 596152d9222SMark de Wever 597152d9222SMark de Wever // [format.string.std]/13 598152d9222SMark de Wever // A zero (0) character preceding the width field pads the field with 599152d9222SMark de Wever // leading zeros (following any indication of sign or base) to the field 600152d9222SMark de Wever // width, except when applied to an infinity or NaN. 601152d9222SMark de Wever if (__specs.__alignment_ == __format_spec::__alignment::__zero_padding) 602152d9222SMark de Wever __specs.__alignment_ = __format_spec::__alignment::__right; 603152d9222SMark de Wever 60477a00c0dSLouis Dionne return __formatter::__write(__buffer, __last, std::move(__out_it), __specs); 605152d9222SMark de Wever } 606152d9222SMark de Wever 6073ab20c68SMark de Wever /// Writes additional zero's for the precision before the exponent. 6083ab20c68SMark de Wever /// This is used when the precision requested in the format string is larger 6093ab20c68SMark de Wever /// than the maximum precision of the floating-point type. These precision 6103ab20c68SMark de Wever /// digits are always 0. 6113ab20c68SMark de Wever /// 6123ab20c68SMark de Wever /// \param __exponent The location of the exponent character. 6133ab20c68SMark de Wever /// \param __num_trailing_zeros The number of 0's to write before the exponent 6143ab20c68SMark de Wever /// character. 6153ab20c68SMark de Wever template <class _CharT, class _ParserCharT> 6163ab20c68SMark de Wever _LIBCPP_HIDE_FROM_ABI auto __write_using_trailing_zeros( 6173ab20c68SMark de Wever const _CharT* __first, 6183ab20c68SMark de Wever const _CharT* __last, 6193ab20c68SMark de Wever output_iterator<const _CharT&> auto __out_it, 6203ab20c68SMark de Wever __format_spec::__parsed_specifications<_ParserCharT> __specs, 6213ab20c68SMark de Wever size_t __size, 6223ab20c68SMark de Wever const _CharT* __exponent, 6233ab20c68SMark de Wever size_t __num_trailing_zeros) -> decltype(__out_it) { 6244f215fddSKonstantin Varlamov _LIBCPP_ASSERT_INTERNAL(__first <= __last, "Not a valid range"); 6254f215fddSKonstantin Varlamov _LIBCPP_ASSERT_INTERNAL(__num_trailing_zeros > 0, "The overload not writing trailing zeros should have been used"); 6263ab20c68SMark de Wever 6273ab20c68SMark de Wever __padding_size_result __padding = 6283ab20c68SMark de Wever __formatter::__padding_size(__size + __num_trailing_zeros, __specs.__width_, __specs.__alignment_); 62977a00c0dSLouis Dionne __out_it = __formatter::__fill(std::move(__out_it), __padding.__before_, __specs.__fill_); 63077a00c0dSLouis Dionne __out_it = __formatter::__copy(__first, __exponent, std::move(__out_it)); 63177a00c0dSLouis Dionne __out_it = __formatter::__fill(std::move(__out_it), __num_trailing_zeros, _CharT('0')); 63277a00c0dSLouis Dionne __out_it = __formatter::__copy(__exponent, __last, std::move(__out_it)); 63377a00c0dSLouis Dionne return __formatter::__fill(std::move(__out_it), __padding.__after_, __specs.__fill_); 6343ab20c68SMark de Wever } 6353ab20c68SMark de Wever 636b51e8acdSMark de Wever template <floating_point _Tp, class _CharT, class _FormatContext> 637b51e8acdSMark de Wever _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator 638b51e8acdSMark de Wever __format_floating_point(_Tp __value, _FormatContext& __ctx, __format_spec::__parsed_specifications<_CharT> __specs) { 63977a00c0dSLouis Dionne bool __negative = std::signbit(__value); 640db2944e3SMark de Wever 64177a00c0dSLouis Dionne if (!std::isfinite(__value)) [[unlikely]] 64277a00c0dSLouis Dionne return __formatter::__format_floating_point_non_finite(__ctx.out(), __specs, __negative, std::isnan(__value)); 643db2944e3SMark de Wever 644db2944e3SMark de Wever // Depending on the std-format-spec string the sign and the value 645db2944e3SMark de Wever // might not be outputted together: 646db2944e3SMark de Wever // - zero-padding may insert additional '0' characters. 647db2944e3SMark de Wever // Therefore the value is processed as a non negative value. 648db2944e3SMark de Wever // The function @ref __insert_sign will insert a '-' when the value was 649db2944e3SMark de Wever // negative. 650db2944e3SMark de Wever 651db2944e3SMark de Wever if (__negative) 652152d9222SMark de Wever __value = -__value; 653db2944e3SMark de Wever 654db2944e3SMark de Wever // TODO FMT _Fp should just be _Tp when to_chars has proper long double support. 655db2944e3SMark de Wever using _Fp = conditional_t<same_as<_Tp, long double>, double, _Tp>; 656db2944e3SMark de Wever // Force the type of the precision to avoid -1 to become an unsigned value. 657152d9222SMark de Wever __float_buffer<_Fp> __buffer(__specs.__precision_); 658152d9222SMark de Wever __float_result __result = __formatter::__format_buffer( 659152d9222SMark de Wever __buffer, __value, __negative, (__specs.__has_precision()), __specs.__std_.__sign_, __specs.__std_.__type_); 660db2944e3SMark de Wever 661f92c733cSMark de Wever if (__specs.__std_.__alternate_form_) { 662f92c733cSMark de Wever if (__result.__radix_point == __result.__last) { 663db2944e3SMark de Wever *__result.__last++ = '.'; 664db2944e3SMark de Wever 665db2944e3SMark de Wever // When there is an exponent the point needs to be moved before the 666db2944e3SMark de Wever // exponent. When there's no exponent the rotate does nothing. Since 667db2944e3SMark de Wever // rotate tests whether the operation is a nop, call it unconditionally. 66877a00c0dSLouis Dionne std::rotate(__result.__exponent, __result.__last - 1, __result.__last); 669db2944e3SMark de Wever __result.__radix_point = __result.__exponent; 670db2944e3SMark de Wever 671db2944e3SMark de Wever // The radix point is always placed before the exponent. 672db2944e3SMark de Wever // - No exponent needs to point to the new last. 673db2944e3SMark de Wever // - An exponent needs to move one position to the right. 674db2944e3SMark de Wever // So it's safe to increment the value unconditionally. 675db2944e3SMark de Wever ++__result.__exponent; 676db2944e3SMark de Wever } 677db2944e3SMark de Wever 678f92c733cSMark de Wever // [format.string.std]/6 679f92c733cSMark de Wever // In addition, for g and G conversions, trailing zeros are not removed 680f92c733cSMark de Wever // from the result. 681f92c733cSMark de Wever // 682f92c733cSMark de Wever // If the type option for a floating-point type is none it may use the 683f92c733cSMark de Wever // general formatting, but it's not a g or G conversion. So in that case 684f92c733cSMark de Wever // the formatting should not append trailing zeros. 685f92c733cSMark de Wever bool __is_general = __specs.__std_.__type_ == __format_spec::__type::__general_lower_case || 686f92c733cSMark de Wever __specs.__std_.__type_ == __format_spec::__type::__general_upper_case; 687f92c733cSMark de Wever 688f92c733cSMark de Wever if (__is_general) { 689f92c733cSMark de Wever // https://en.cppreference.com/w/c/io/fprintf 690f92c733cSMark de Wever // Let P equal the precision if nonzero, 6 if the precision is not 691f92c733cSMark de Wever // specified, or 1 if the precision is 0. Then, if a conversion with 692f92c733cSMark de Wever // style E would have an exponent of X: 693e1830f58SBrian Cain int __p = std::max<int>(1, (__specs.__has_precision() ? __specs.__precision_ : 6)); 694f92c733cSMark de Wever if (__result.__exponent == __result.__last) 695f92c733cSMark de Wever // if P > X >= -4, the conversion is with style f or F and precision P - 1 - X. 696f92c733cSMark de Wever // By including the radix point it calculates P - (1 + X) 6975eaba4a9SMark de Wever __p -= __result.__radix_point - __result.__integral; 698f92c733cSMark de Wever else 699f92c733cSMark de Wever // otherwise, the conversion is with style e or E and precision P - 1. 700f92c733cSMark de Wever --__p; 701f92c733cSMark de Wever 702f92c733cSMark de Wever ptrdiff_t __precision = (__result.__exponent - __result.__radix_point) - 1; 703f92c733cSMark de Wever if (__precision < __p) 704f92c733cSMark de Wever __buffer.__add_trailing_zeros(__p - __precision); 705f92c733cSMark de Wever } 706f92c733cSMark de Wever } 707f92c733cSMark de Wever 708c6f3b7bcSNikolas Klauser # if _LIBCPP_HAS_LOCALIZATION 709152d9222SMark de Wever if (__specs.__std_.__locale_specific_form_) 710152d9222SMark de Wever return __formatter::__format_locale_specific_form(__ctx.out(), __buffer, __result, __ctx.locale(), __specs); 711db2944e3SMark de Wever # endif 712db2944e3SMark de Wever 713db2944e3SMark de Wever ptrdiff_t __size = __result.__last - __buffer.begin(); 714db2944e3SMark de Wever int __num_trailing_zeros = __buffer.__num_trailing_zeros(); 715152d9222SMark de Wever if (__size + __num_trailing_zeros >= __specs.__width_) { 716db2944e3SMark de Wever if (__num_trailing_zeros && __result.__exponent != __result.__last) 717db2944e3SMark de Wever // Insert trailing zeros before exponent character. 718f7c0df00SMark de Wever return __formatter::__copy( 719152d9222SMark de Wever __result.__exponent, 720152d9222SMark de Wever __result.__last, 721f7c0df00SMark de Wever __formatter::__fill(__formatter::__copy(__buffer.begin(), __result.__exponent, __ctx.out()), 722f7c0df00SMark de Wever __num_trailing_zeros, 723f7c0df00SMark de Wever _CharT('0'))); 724db2944e3SMark de Wever 725f7c0df00SMark de Wever return __formatter::__fill( 726f7c0df00SMark de Wever __formatter::__copy(__buffer.begin(), __result.__last, __ctx.out()), __num_trailing_zeros, _CharT('0')); 727db2944e3SMark de Wever } 728db2944e3SMark de Wever 729db2944e3SMark de Wever auto __out_it = __ctx.out(); 730db2944e3SMark de Wever char* __first = __buffer.begin(); 731152d9222SMark de Wever if (__specs.__alignment_ == __format_spec::__alignment ::__zero_padding) { 732db2944e3SMark de Wever // When there is a sign output it before the padding. Note the __size 733db2944e3SMark de Wever // doesn't need any adjustment, regardless whether the sign is written 734db2944e3SMark de Wever // here or in __formatter::__write. 735db2944e3SMark de Wever if (__first != __result.__integral) 736db2944e3SMark de Wever *__out_it++ = *__first++; 737db2944e3SMark de Wever // After the sign is written, zero padding is the same a right alignment 738db2944e3SMark de Wever // with '0'. 739152d9222SMark de Wever __specs.__alignment_ = __format_spec::__alignment::__right; 7405db033e2SMark de Wever __specs.__fill_.__data[0] = _CharT('0'); 741db2944e3SMark de Wever } 742db2944e3SMark de Wever 743db2944e3SMark de Wever if (__num_trailing_zeros) 744152d9222SMark de Wever return __formatter::__write_using_trailing_zeros( 74577a00c0dSLouis Dionne __first, __result.__last, std::move(__out_it), __specs, __size, __result.__exponent, __num_trailing_zeros); 746db2944e3SMark de Wever 74777a00c0dSLouis Dionne return __formatter::__write(__first, __result.__last, std::move(__out_it), __specs, __size); 748db2944e3SMark de Wever } 749db2944e3SMark de Wever 750152d9222SMark de Wever } // namespace __formatter 751db2944e3SMark de Wever 752a595fcf9SMark de Wever template <__fmt_char_type _CharT> 753152d9222SMark de Wever struct _LIBCPP_TEMPLATE_VIS __formatter_floating_point { 754152d9222SMark de Wever public: 755b51e8acdSMark de Wever template <class _ParseContext> 756b51e8acdSMark de Wever _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { 757b51e8acdSMark de Wever typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_floating_point); 758a0ffecccSMark de Wever __format_spec::__process_parsed_floating_point(__parser_, "a floating-point"); 759152d9222SMark de Wever return __result; 760db2944e3SMark de Wever } 761db2944e3SMark de Wever 762b51e8acdSMark de Wever template <floating_point _Tp, class _FormatContext> 763b51e8acdSMark de Wever _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(_Tp __value, _FormatContext& __ctx) const { 764152d9222SMark de Wever return __formatter::__format_floating_point(__value, __ctx, __parser_.__get_parsed_std_specifications(__ctx)); 765db2944e3SMark de Wever } 766152d9222SMark de Wever 767152d9222SMark de Wever __format_spec::__parser<_CharT> __parser_; 768db2944e3SMark de Wever }; 769db2944e3SMark de Wever 770a595fcf9SMark de Wever template <__fmt_char_type _CharT> 7719783f28cSLouis Dionne struct _LIBCPP_TEMPLATE_VIS formatter<float, _CharT> : public __formatter_floating_point<_CharT> {}; 772a595fcf9SMark de Wever template <__fmt_char_type _CharT> 7739783f28cSLouis Dionne struct _LIBCPP_TEMPLATE_VIS formatter<double, _CharT> : public __formatter_floating_point<_CharT> {}; 774a595fcf9SMark de Wever template <__fmt_char_type _CharT> 7759783f28cSLouis Dionne struct _LIBCPP_TEMPLATE_VIS formatter<long double, _CharT> : public __formatter_floating_point<_CharT> {}; 776db2944e3SMark de Wever 777f08df56dSMark de Wever # if _LIBCPP_STD_VER >= 23 778f08df56dSMark de Wever template <> 779f08df56dSMark de Wever inline constexpr bool enable_nonlocking_formatter_optimization<float> = true; 780f08df56dSMark de Wever template <> 781f08df56dSMark de Wever inline constexpr bool enable_nonlocking_formatter_optimization<double> = true; 782f08df56dSMark de Wever template <> 783f08df56dSMark de Wever inline constexpr bool enable_nonlocking_formatter_optimization<long double> = true; 784f08df56dSMark de Wever # endif // _LIBCPP_STD_VER >= 23 7854f15267dSNikolas Klauser #endif // _LIBCPP_STD_VER >= 20 786db2944e3SMark de Wever 787db2944e3SMark de Wever _LIBCPP_END_NAMESPACE_STD 788db2944e3SMark de Wever 789db2944e3SMark de Wever _LIBCPP_POP_MACROS 790db2944e3SMark de Wever 791db2944e3SMark de Wever #endif // _LIBCPP___FORMAT_FORMATTER_FLOATING_POINT_H 792