xref: /llvm-project/libcxx/include/__format/formatter_floating_point.h (revision f69585235ec85d54e0f3fc41b2d5700430907f99)
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