libstdc++: format Source File

libstdc++

format
Go to the documentation of this file.
1// <format> Formatting -*- C++ -*-
2
3// Copyright The GNU Toolchain Authors.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file include/format
26 * This is a Standard C++ Library header.
27 */
28
29#ifndef _GLIBCXX_FORMAT
30#define _GLIBCXX_FORMAT 1
31
32#ifdef _GLIBCXX_SYSHDR
33#pragma GCC system_header
34#endif
35
36#include <bits/requires_hosted.h> // for std::string
37
38#define __glibcxx_want_format
39#define __glibcxx_want_format_ranges
40#define __glibcxx_want_format_uchar
41#define __glibcxx_want_constexpr_exceptions
42#include <bits/version.h>
43
44#ifdef __cpp_lib_format // C++ >= 20 && HOSTED
45
46#include <array>
47#include <charconv>
48#include <concepts>
49#include <limits>
50#include <locale>
51#include <optional>
52#include <span>
53#include <string_view>
54#include <string>
55#include <bits/monostate.h>
56#include <bits/formatfwd.h>
57#include <bits/ranges_base.h> // input_range, range_reference_t
58#include <bits/ranges_util.h> // subrange
59#include <bits/ranges_algobase.h> // ranges::copy
60#include <bits/stl_iterator.h> // counted_iterator
61#include <bits/stl_pair.h> // __is_pair
62#include <bits/unicode.h> // __is_scalar_value, _Utf_view, etc.
63#include <bits/utility.h> // tuple_size_v
64#include <ext/numeric_traits.h> // __int_traits
65
66#if !__has_builtin(__builtin_toupper)
67# include <cctype>
68#endif
69
70#pragma GCC diagnostic push
71#pragma GCC diagnostic ignored "-Wpedantic" // __int128
72#pragma GCC diagnostic ignored "-Wc++23-extensions" // bf16
73
74namespace std _GLIBCXX_VISIBILITY(default)
75{
76_GLIBCXX_BEGIN_NAMESPACE_VERSION
77
78 // [format.fmt.string], class template basic_format_string
79 template<typename _CharT, typename... _Args> struct basic_format_string;
80
81/// @cond undocumented
82namespace __format
83{
84 // STATICALLY-WIDEN, see C++20 [time.general]
85 // It doesn't matter for format strings (which can only be char or wchar_t)
86 // but this returns the narrow string for anything that isn't wchar_t. This
87 // is done because const char* can be inserted into any ostream type, and
88 // will be widened at runtime if necessary.
89 template<typename _CharT>
90 consteval auto
91 _Widen(const char* __narrow, const wchar_t* __wide)
92 {
93 if constexpr (is_same_v<_CharT, wchar_t>)
94 return __wide;
95 else
96 return __narrow;
97 }
98#define _GLIBCXX_WIDEN_(C, S) ::std::__format::_Widen<C>(S, L##S)
99#define _GLIBCXX_WIDEN(S) _GLIBCXX_WIDEN_(_CharT, S)
100
101 // Size for stack located buffer
102 template<typename _CharT>
103 constexpr size_t __stackbuf_size = 32 * sizeof(void*) / sizeof(_CharT);
104
105 // Type-erased character sinks.
106 template<typename _CharT> class _Sink;
107 template<typename _CharT> class _Fixedbuf_sink;
108 template<typename _Out, typename _CharT> class _Padding_sink;
109 template<typename _Out, typename _CharT> class _Escaping_sink;
110
111 // Output iterator that writes to a type-erase character sink.
112 template<typename _CharT>
113 class _Sink_iter;
114
115 // Output iterator that ignores the characters
116 template<typename _CharT>
117 class _Drop_iter;
118
119 // An unspecified output iterator type used in the `formattable` concept.
120 template<typename _CharT>
121 struct _Iter_for
122 { using type = _Drop_iter<_CharT>; };
123
124 template<typename _CharT>
125 using __format_context = basic_format_context<_Sink_iter<_CharT>, _CharT>;
126
127 template<typename _CharT>
128 struct _Dynamic_format_string
129 {
130 [[__gnu__::__always_inline__]]
131 _Dynamic_format_string(basic_string_view<_CharT> __s) noexcept
132 : _M_str(__s) { }
133
134 _Dynamic_format_string(const _Dynamic_format_string&) = delete;
135 void operator=(const _Dynamic_format_string&) = delete;
136
137 private:
138 basic_string_view<_CharT> _M_str;
139
140 template<typename, typename...> friend struct std::basic_format_string;
141 };
142
143} // namespace __format
144/// @endcond
145
146 using format_context = __format::__format_context<char>;
147#ifdef _GLIBCXX_USE_WCHAR_T
148 using wformat_context = __format::__format_context<wchar_t>;
149#endif
150
151 // [format.args], class template basic_format_args
152 template<typename _Context> class basic_format_args;
153 using format_args = basic_format_args<format_context>;
154#ifdef _GLIBCXX_USE_WCHAR_T
155 using wformat_args = basic_format_args<wformat_context>;
156#endif
157
158 // [format.arguments], arguments
159 // [format.arg], class template basic_format_arg
160 template<typename _Context>
161 class basic_format_arg;
162
163 /** A compile-time checked format string for the specified argument types.
164 *
165 * @since C++23 but available as an extension in C++20.
166 */
167 template<typename _CharT, typename... _Args>
168 struct basic_format_string
169 {
170 template<typename _Tp>
171 requires convertible_to<const _Tp&, basic_string_view<_CharT>>
172 consteval
173 basic_format_string(const _Tp& __s);
174
175 [[__gnu__::__always_inline__]]
176 basic_format_string(__format::_Dynamic_format_string<_CharT> __s) noexcept
177 : _M_str(__s._M_str)
178 { }
179
180 [[__gnu__::__always_inline__]]
181 constexpr basic_string_view<_CharT>
182 get() const noexcept
183 { return _M_str; }
184
185 private:
186 basic_string_view<_CharT> _M_str;
187 };
188
189 template<typename... _Args>
190 using format_string = basic_format_string<char, type_identity_t<_Args>...>;
191
192#ifdef _GLIBCXX_USE_WCHAR_T
193 template<typename... _Args>
194 using wformat_string
195 = basic_format_string<wchar_t, type_identity_t<_Args>...>;
196#endif
197
198#if __cpp_lib_format >= 202603L // >= C++26
199 [[__gnu__::__always_inline__]]
200 inline __format::_Dynamic_format_string<char>
201 dynamic_format(string_view __fmt) noexcept
202 { return __fmt; }
203
204#ifdef _GLIBCXX_USE_WCHAR_T
205 [[__gnu__::__always_inline__]]
206 inline __format::_Dynamic_format_string<wchar_t>
207 dynamic_format(wstring_view __fmt) noexcept
208 { return __fmt; }
209#endif
210#endif // C++26
211
212 // [format.formatter], formatter
213
214 /// The primary template of std::formatter is disabled.
215 template<typename _Tp, typename _CharT>
216 struct formatter
217 {
218 formatter() = delete; // No std::formatter specialization for this type.
219 formatter(const formatter&) = delete;
220 formatter& operator=(const formatter&) = delete;
221 };
222
223#if __cpp_lib_constexpr_exceptions >= 202502L
224#define _GLIBCXX_CONSTEXPR_FORMAT_ERROR constexpr
225#else
226#define _GLIBCXX_CONSTEXPR_FORMAT_ERROR
227#endif
228
229 // [format.error], class format_error
230 class format_error : public runtime_error
231 {
232 public:
233 _GLIBCXX_CONSTEXPR_FORMAT_ERROR explicit format_error(const string& __what)
234 : runtime_error(__what) { }
235 _GLIBCXX_CONSTEXPR_FORMAT_ERROR explicit format_error(const char* __what)
236 : runtime_error(__what) { }
237 };
238
239 /// @cond undocumented
240 [[noreturn]]
241 inline void
242 __throw_format_error(const char* __what)
243 { _GLIBCXX_THROW_OR_ABORT(format_error(__what)); }
244
245#undef _GLIBCXX_CONSTEXPR_FORMAT_ERROR
246
247namespace __format
248{
249 // XXX use named functions for each constexpr error?
250
251 [[noreturn]]
252 inline void
253 __unmatched_left_brace_in_format_string()
254 { __throw_format_error("format error: unmatched '{' in format string"); }
255
256 [[noreturn]]
257 inline void
258 __unmatched_right_brace_in_format_string()
259 { __throw_format_error("format error: unmatched '}' in format string"); }
260
261 [[noreturn]]
262 inline void
263 __conflicting_indexing_in_format_string()
264 { __throw_format_error("format error: conflicting indexing style in format string"); }
265
266 [[noreturn]]
267 inline void
268 __invalid_arg_id_in_format_string()
269 { __throw_format_error("format error: invalid arg-id in format string"); }
270
271 [[noreturn]]
272 inline void
273 __failed_to_parse_format_spec()
274 { __throw_format_error("format error: failed to parse format-spec"); }
275
276 template<typename _CharT> class _Scanner;
277
278} // namespace __format
279 /// @endcond
280
281 // [format.parse.ctx], class template basic_format_parse_context
282 template<typename _CharT> class basic_format_parse_context;
283 using format_parse_context = basic_format_parse_context<char>;
284#ifdef _GLIBCXX_USE_WCHAR_T
285 using wformat_parse_context = basic_format_parse_context<wchar_t>;
286#endif
287
288 template<typename _CharT>
289 class basic_format_parse_context
290 {
291 public:
292 using char_type = _CharT;
293 using const_iterator = typename basic_string_view<_CharT>::const_iterator;
294 using iterator = const_iterator;
295
296 constexpr explicit
297 basic_format_parse_context(basic_string_view<_CharT> __fmt) noexcept
298 : _M_begin(__fmt.begin()), _M_end(__fmt.end())
299 { }
300
301 basic_format_parse_context(const basic_format_parse_context&) = delete;
302 void operator=(const basic_format_parse_context&) = delete;
303
304 constexpr const_iterator begin() const noexcept { return _M_begin; }
305 constexpr const_iterator end() const noexcept { return _M_end; }
306
307 constexpr void
308 advance_to(const_iterator __it) noexcept
309 { _M_begin = __it; }
310
311 constexpr size_t
312 next_arg_id()
313 {
314 if (_M_indexing == _Manual)
315 __format::__conflicting_indexing_in_format_string();
316 _M_indexing = _Auto;
317
318 // _GLIBCXX_RESOLVE_LIB_DEFECTS
319 // 3825. Missing compile-time argument id check in next_arg_id
320 if (std::is_constant_evaluated())
321 if (_M_next_arg_id == _M_num_args)
322 __format::__invalid_arg_id_in_format_string();
323 return _M_next_arg_id++;
324 }
325
326 constexpr void
327 check_arg_id(size_t __id)
328 {
329 if (_M_indexing == _Auto)
330 __format::__conflicting_indexing_in_format_string();
331 _M_indexing = _Manual;
332
333 if (std::is_constant_evaluated())
334 if (__id >= _M_num_args)
335 __format::__invalid_arg_id_in_format_string();
336 }
337
338#if __cpp_lib_format >= 202305L
339 template<typename... _Ts>
340 constexpr void
341 check_dynamic_spec(size_t __id) noexcept
342 {
343 static_assert(__valid_types_for_check_dynamic_spec<_Ts...>(),
344 "template arguments for check_dynamic_spec<Ts...>(id) "
345 "must be unique and must be one of the allowed types");
346 if consteval {
347 __check_dynamic_spec<_Ts...>(__id);
348 }
349 }
350
351 constexpr void
352 check_dynamic_spec_integral(size_t __id) noexcept
353 {
354 if consteval {
355 __check_dynamic_spec<int, unsigned, long long,
356 unsigned long long>(__id);
357 }
358 }
359
360 constexpr void
361 check_dynamic_spec_string(size_t __id) noexcept
362 {
363 if consteval {
364 __check_dynamic_spec<const _CharT*, basic_string_view<_CharT>>(__id);
365 }
366 }
367
368 private:
369 // True if _Tp occurs exactly once in _Ts.
370 template<typename _Tp, typename... _Ts>
371 static constexpr bool __once = (is_same_v<_Tp, _Ts> + ...) == 1;
372
373 template<typename... _Ts>
374 consteval bool
375 __valid_types_for_check_dynamic_spec()
376 {
377 // _GLIBCXX_RESOLVE_LIB_DEFECTS
378 // 4142. check_dynamic_spec should require at least one type
379 if constexpr (sizeof...(_Ts) == 0)
380 return false;
381 else
382 {
383 // The types in Ts... are unique. Each type in Ts... is one of
384 // bool, char_type, int, unsigned int, long long int,
385 // unsigned long long int, float, double, long double,
386 // const char_type*, basic_string_view<char_type>, or const void*.
387 unsigned __sum
388 = __once<bool, _Ts...>
389 + __once<char_type, _Ts...>
390 + __once<int, _Ts...>
391 + __once<unsigned int, _Ts...>
392 + __once<long long int, _Ts...>
393 + __once<unsigned long long int, _Ts...>
394 + __once<float, _Ts...>
395 + __once<double, _Ts...>
396 + __once<long double, _Ts...>
397 + __once<const char_type*, _Ts...>
398 + __once<basic_string_view<char_type>, _Ts...>
399 + __once<const void*, _Ts...>;
400 return __sum == sizeof...(_Ts);
401 }
402 }
403
404 template<typename... _Ts>
405 consteval void
406 __check_dynamic_spec(size_t __id) noexcept;
407
408 // This must not be constexpr.
409 static void __invalid_dynamic_spec(const char*);
410
411 friend __format::_Scanner<_CharT>;
412#endif
413
414 // This constructor should only be used by the implementation.
415 constexpr explicit
416 basic_format_parse_context(basic_string_view<_CharT> __fmt,
417 size_t __num_args) noexcept
418 : _M_begin(__fmt.begin()), _M_end(__fmt.end()), _M_num_args(__num_args)
419 { }
420
421 private:
422 iterator _M_begin;
423 iterator _M_end;
424 enum _Indexing { _Unknown, _Manual, _Auto };
425 _Indexing _M_indexing = _Unknown;
426 size_t _M_next_arg_id = 0;
427 size_t _M_num_args = 0;
428 };
429
430/// @cond undocumented
431 template<typename _Tp, template<typename...> class _Class>
432 constexpr bool __is_specialization_of = false;
433 template<template<typename...> class _Class, typename... _Args>
434 constexpr bool __is_specialization_of<_Class<_Args...>, _Class> = true;
435
436namespace __format
437{
438 // pre: first != last
439 template<typename _CharT>
440 constexpr pair<unsigned short, const _CharT*>
441 __parse_integer(const _CharT* __first, const _CharT* __last)
442 {
443 if (__first == __last)
444 __builtin_unreachable();
445
446 if constexpr (is_same_v<_CharT, char>)
447 {
448 const auto __start = __first;
449 unsigned short __val = 0;
450 // N.B. std::from_chars is not constexpr in C++20.
451 if (__detail::__from_chars_alnum<true>(__first, __last, __val, 10)
452 && __first != __start) [[likely]]
453 return {__val, __first};
454 }
455 else
456 {
457 constexpr int __n = 32;
458 char __buf[__n]{};
459 for (int __i = 0; __i < __n && (__first + __i) != __last; ++__i)
460 __buf[__i] = __first[__i];
461 auto [__v, __ptr] = __format::__parse_integer(__buf, __buf + __n);
462 if (__ptr) [[likely]]
463 return {__v, __first + (__ptr - __buf)};
464 }
465 return {0, nullptr};
466 }
467
468 template<typename _CharT>
469 constexpr pair<unsigned short, const _CharT*>
470 __parse_arg_id(const _CharT* __first, const _CharT* __last)
471 {
472 if (__first == __last)
473 __builtin_unreachable();
474
475 if (*__first == '0')
476 return {0, __first + 1}; // No leading zeros allowed, so '0...' == 0
477
478 if ('1' <= *__first && *__first <= '9')
479 {
480 const unsigned short __id = *__first - '0';
481 const auto __next = __first + 1;
482 // Optimize for most likely case of single digit arg-id.
483 if (__next == __last || !('0' <= *__next && *__next <= '9'))
484 return {__id, __next};
485 else
486 return __format::__parse_integer(__first, __last);
487 }
488 return {0, nullptr};
489 }
490
491 enum class _Pres_type : unsigned char {
492 _Pres_none = 0, // Default type (not valid for integer presentation types).
493 _Pres_s = 1, // For strings, bool, ranges
494 // Presentation types for integral types (including bool and charT).
495 _Pres_c = 2, _Pres_x, _Pres_X, _Pres_d, _Pres_o, _Pres_b, _Pres_B,
496 // Presentation types for floating-point types
497 _Pres_g = 1, _Pres_G, _Pres_a, _Pres_A, _Pres_e, _Pres_E, _Pres_f, _Pres_F,
498 // For pointers, the value are same as hexadecimal presentations for integers
499 _Pres_p = _Pres_x, _Pres_P = _Pres_X,
500 _Pres_max = 0xf,
501 };
502 using enum _Pres_type;
503
504 enum class _Sign : unsigned char {
505 _Sign_default,
506 _Sign_plus,
507 _Sign_minus, // XXX does this need to be distinct from _Sign_default?
508 _Sign_space,
509 };
510 using enum _Sign;
511
512 enum _WidthPrec : unsigned char {
513 _WP_none, // No width/prec specified.
514 _WP_value, // Fixed width/prec specified.
515 _WP_from_arg // Use a formatting argument for width/prec.
516 };
517 using enum _WidthPrec;
518
519 template<typename _Context>
520 size_t
521 __int_from_arg(const basic_format_arg<_Context>& __arg);
522
523 constexpr bool __is_digit(char __c)
524 { return std::__detail::__from_chars_alnum_to_val(__c) < 10; }
525
526 constexpr bool __is_xdigit(char __c)
527 { return std::__detail::__from_chars_alnum_to_val(__c) < 16; }
528
529 // Used to make _Spec a non-C++98 POD, so the tail-padding is used.
530 // https://itanium-cxx-abi.github.io/cxx-abi/abi.html#pod
531 struct _SpecBase
532 { };
533
534 template<typename _CharT>
535 struct _Spec : _SpecBase
536 {
537 unsigned short _M_width;
538 unsigned short _M_prec;
539 char32_t _M_fill = ' ';
540 _Align _M_align : 2;
541 _Sign _M_sign : 2;
542 unsigned _M_alt : 1;
543 unsigned _M_localized : 1;
544 unsigned _M_zero_fill : 1;
545 _WidthPrec _M_width_kind : 2;
546 _WidthPrec _M_prec_kind : 2;
547 unsigned _M_debug : 1;
548 _Pres_type _M_type : 4;
549 unsigned _M_reserved : 8;
550 // This class has 8 bits of tail padding, that can be used by
551 // derived classes.
552
553 using iterator = typename basic_string_view<_CharT>::iterator;
554
555 static constexpr _Align
556 _S_align(_CharT __c) noexcept
557 {
558 switch (__c)
559 {
560 case '<': return _Align_left;
561 case '>': return _Align_right;
562 case '^': return _Align_centre;
563 default: return _Align_default;
564 }
565 }
566
567 // pre: __first != __last
568 constexpr iterator
569 _M_parse_fill_and_align(iterator __first, iterator __last) noexcept
570 { return _M_parse_fill_and_align(__first, __last, "{"); }
571
572 // pre: __first != __last
573 constexpr iterator
574 _M_parse_fill_and_align(iterator __first, iterator __last, string_view __not_fill) noexcept
575 {
576 for (char __c : __not_fill)
577 if (*__first == static_cast<_CharT>(__c))
578 return __first;
579
580 using namespace __unicode;
581 if constexpr (__literal_encoding_is_unicode<_CharT>())
582 {
583 // Accept any UCS scalar value as fill character.
584 _Utf32_view<ranges::subrange<iterator>> __uv({__first, __last});
585 if (!__uv.empty())
586 {
587 auto __beg = __uv.begin();
588 char32_t __c = *__beg++;
589 if (__is_scalar_value(__c))
590 if (auto __next = __beg.base(); __next != __last)
591 if (_Align __align = _S_align(*__next); __align != _Align_default)
592 {
593 _M_fill = __c;
594 _M_align = __align;
595 return ++__next;
596 }
597 }
598 }
599 else if (__last - __first >= 2)
600 if (_Align __align = _S_align(__first[1]); __align != _Align_default)
601 {
602 _M_fill = *__first;
603 _M_align = __align;
604 return __first + 2;
605 }
606
607 if (_Align __align = _S_align(__first[0]); __align != _Align_default)
608 {
609 _M_fill = ' ';
610 _M_align = __align;
611 return __first + 1;
612 }
613 return __first;
614 }
615
616 static constexpr _Sign
617 _S_sign(_CharT __c) noexcept
618 {
619 switch (__c)
620 {
621 case '+': return _Sign_plus;
622 case '-': return _Sign_minus;
623 case ' ': return _Sign_space;
624 default: return _Sign_default;
625 }
626 }
627
628 // pre: __first != __last
629 constexpr iterator
630 _M_parse_sign(iterator __first, iterator) noexcept
631 {
632 if (_Sign __sign = _S_sign(*__first); __sign != _Sign_default)
633 {
634 _M_sign = __sign;
635 return __first + 1;
636 }
637 return __first;
638 }
639
640 // pre: *__first is valid
641 constexpr iterator
642 _M_parse_alternate_form(iterator __first, iterator) noexcept
643 {
644 if (*__first == '#')
645 {
646 _M_alt = true;
647 ++__first;
648 }
649 return __first;
650 }
651
652 // pre: __first != __last
653 constexpr iterator
654 _M_parse_zero_fill(iterator __first, iterator /* __last */) noexcept
655 {
656 if (*__first == '0')
657 {
658 _M_zero_fill = true;
659 ++__first;
660 }
661 return __first;
662 }
663
664 // pre: __first != __last
665 static constexpr iterator
666 _S_parse_width_or_precision(iterator __first, iterator __last,
667 unsigned short& __val, bool& __arg_id,
668 basic_format_parse_context<_CharT>& __pc)
669 {
670 if (__format::__is_digit(*__first))
671 {
672 auto [__v, __ptr] = __format::__parse_integer(__first, __last);
673 if (!__ptr)
674 __throw_format_error("format error: invalid width or precision "
675 "in format-spec");
676 __first = __ptr;
677 __val = __v;
678 }
679 else if (*__first == '{')
680 {
681 __arg_id = true;
682 ++__first;
683 if (__first == __last)
684 __format::__unmatched_left_brace_in_format_string();
685 if (*__first == '}')
686 __val = __pc.next_arg_id();
687 else
688 {
689 auto [__v, __ptr] = __format::__parse_arg_id(__first, __last);
690 if (__ptr == nullptr || __ptr == __last || *__ptr != '}')
691 __format::__invalid_arg_id_in_format_string();
692 __first = __ptr;
693 __pc.check_arg_id(__v);
694 __val = __v;
695 }
696#if __cpp_lib_format >= 202305L
697 __pc.check_dynamic_spec_integral(__val);
698#endif
699 ++__first; // past the '}'
700 }
701 return __first;
702 }
703
704 // pre: __first != __last
705 constexpr iterator
706 _M_parse_width(iterator __first, iterator __last,
707 basic_format_parse_context<_CharT>& __pc)
708 {
709 bool __arg_id = false;
710 if (*__first == '0')
711 __throw_format_error("format error: width must be non-zero in "
712 "format string");
713 auto __next = _S_parse_width_or_precision(__first, __last, _M_width,
714 __arg_id, __pc);
715 if (__next != __first)
716 _M_width_kind = __arg_id ? _WP_from_arg : _WP_value;
717 return __next;
718 }
719
720 // pre: __first != __last
721 constexpr iterator
722 _M_parse_precision(iterator __first, iterator __last,
723 basic_format_parse_context<_CharT>& __pc)
724 {
725 if (__first[0] != '.')
726 return __first;
727
728 iterator __next = ++__first;
729 bool __arg_id = false;
730 if (__next != __last)
731 __next = _S_parse_width_or_precision(__first, __last, _M_prec,
732 __arg_id, __pc);
733 if (__next == __first)
734 __throw_format_error("format error: missing precision after '.' in "
735 "format string");
736 _M_prec_kind = __arg_id ? _WP_from_arg : _WP_value;
737 return __next;
738 }
739
740 // pre: __first != __last
741 constexpr iterator
742 _M_parse_locale(iterator __first, iterator /* __last */) noexcept
743 {
744 if (*__first == 'L')
745 {
746 _M_localized = true;
747 ++__first;
748 }
749 return __first;
750 }
751
752 template<typename _Context>
753 size_t
754 _M_get_width(_Context& __ctx) const
755 {
756 size_t __width = 0;
757 if (_M_width_kind == _WP_value)
758 __width = _M_width;
759 else if (_M_width_kind == _WP_from_arg)
760 __width = __format::__int_from_arg(__ctx.arg(_M_width));
761 return __width;
762 }
763
764 template<typename _Context>
765 size_t
766 _M_get_precision(_Context& __ctx) const
767 {
768 size_t __prec = -1;
769 if (_M_prec_kind == _WP_value)
770 __prec = _M_prec;
771 else if (_M_prec_kind == _WP_from_arg)
772 __prec = __format::__int_from_arg(__ctx.arg(_M_prec));
773 return __prec;
774 }
775 };
776
777 template<typename _Int>
778 inline char*
779 __put_sign(_Int __i, _Sign __sign, char* __dest) noexcept
780 {
781 if (__i < 0)
782 *__dest = '-';
783 else if (__sign == _Sign_plus)
784 *__dest = '+';
785 else if (__sign == _Sign_space)
786 *__dest = ' ';
787 else
788 ++__dest;
789 return __dest;
790 }
791
792 // Write STR to OUT (and do so efficiently if OUT is a _Sink_iter).
793 template<typename _Out, typename _CharT>
794 requires output_iterator<_Out, const _CharT&>
795 inline _Out
796 __write(_Out __out, basic_string_view<_CharT> __str)
797 {
798 if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
799 {
800 if (__str.size())
801 __out = __str;
802 }
803 else
804 for (_CharT __c : __str)
805 *__out++ = __c;
806 return __out;
807 }
808
809 // Write STR to OUT with NFILL copies of FILL_CHAR specified by ALIGN.
810 // pre: __align != _Align_default
811 template<typename _Out, typename _CharT>
812 _Out
813 __write_padded(_Out __out, basic_string_view<_CharT> __str,
814 _Align __align, size_t __nfill, char32_t __fill_char)
815 {
816 const size_t __buflen = 0x20;
817 _CharT __padding_chars[__buflen];
818 __padding_chars[0] = _CharT();
819 basic_string_view<_CharT> __padding{__padding_chars, __buflen};
820
821 auto __pad = [&__padding] (size_t __n, _Out& __o) {
822 if (__n == 0)
823 return;
824 while (__n > __padding.size())
825 {
826 __o = __format::__write(std::move(__o), __padding);
827 __n -= __padding.size();
828 }
829 if (__n != 0)
830 __o = __format::__write(std::move(__o), __padding.substr(0, __n));
831 };
832
833 size_t __l, __r, __max;
834 if (__align == _Align_centre)
835 {
836 __l = __nfill / 2;
837 __r = __l + (__nfill & 1);
838 __max = __r;
839 }
840 else if (__align == _Align_right)
841 {
842 __l = __nfill;
843 __r = 0;
844 __max = __l;
845 }
846 else
847 {
848 __l = 0;
849 __r = __nfill;
850 __max = __r;
851 }
852
853 using namespace __unicode;
854 if constexpr (__literal_encoding_is_unicode<_CharT>())
855 if (!__is_single_code_unit<_CharT>(__fill_char)) [[unlikely]]
856 {
857 // Encode fill char as multiple code units of type _CharT.
858 const char32_t __arr[1]{ __fill_char };
859 _Utf_view<_CharT, span<const char32_t, 1>> __v(__arr);
860 basic_string<_CharT> __padstr(__v.begin(), __v.end());
861 __padding = __padstr;
862 while (__l-- > 0)
863 __out = __format::__write(std::move(__out), __padding);
864 __out = __format::__write(std::move(__out), __str);
865 while (__r-- > 0)
866 __out = __format::__write(std::move(__out), __padding);
867 return __out;
868 }
869
870 if (__max < __buflen)
871 __padding.remove_suffix(__buflen - __max);
872 else
873 __max = __buflen;
874
875 char_traits<_CharT>::assign(__padding_chars, __max, __fill_char);
876 __pad(__l, __out);
877 __out = __format::__write(std::move(__out), __str);
878 __pad(__r, __out);
879
880 return __out;
881 }
882
883 // Write STR to OUT, with alignment and padding as determined by SPEC.
884 // pre: __spec._M_align != _Align_default || __align != _Align_default
885 template<typename _CharT, typename _Out>
886 _Out
887 __write_padded_as_spec(basic_string_view<type_identity_t<_CharT>> __str,
888 size_t __estimated_width,
889 basic_format_context<_Out, _CharT>& __fc,
890 const _Spec<_CharT>& __spec,
891 _Align __align = _Align_left)
892 {
893 size_t __width = __spec._M_get_width(__fc);
894
895 if (__width <= __estimated_width)
896 return __format::__write(__fc.out(), __str);
897
898 const size_t __nfill = __width - __estimated_width;
899
900 if (__spec._M_align != _Align_default)
901 __align = __spec._M_align;
902
903 return __format::__write_padded(__fc.out(), __str, __align, __nfill,
904 __spec._M_fill);
905 }
906
907 template<typename _CharT>
908 size_t
909 __truncate(basic_string_view<_CharT>& __s, size_t __prec)
910 {
911 if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
912 {
913 if (__prec != (size_t)-1)
914 return __unicode::__truncate(__s, __prec);
915 else
916 return __unicode::__field_width(__s);
917 }
918 else
919 {
920 __s = __s.substr(0, __prec);
921 return __s.size();
922 }
923 }
924
925 enum class _Term_char : unsigned char {
926 _Term_none,
927 _Term_quote,
928 _Term_apos,
929 };
930 using enum _Term_char;
931
932 template<typename _CharT>
933 struct _Escapes
934 {
935 using _Str_view = basic_string_view<_CharT>;
936
937 static consteval
938 _Str_view _S_all()
939 { return _GLIBCXX_WIDEN("\t\\t\n\\n\r\\r\\\\\\\"\\\"'\\'\\u\\x"); }
940
941 static consteval
942 _Str_view _S_tab()
943 { return _S_all().substr(0, 3); }
944
945 static consteval
946 _Str_view _S_newline()
947 { return _S_all().substr(3, 3); }
948
949 static consteval
950 _Str_view _S_return()
951 { return _S_all().substr(6, 3); }
952
953 static consteval
954 _Str_view _S_bslash()
955 { return _S_all().substr(9, 3); }
956
957 static consteval
958 _Str_view _S_quote()
959 { return _S_all().substr(12, 3); }
960
961 static consteval
962 _Str_view _S_apos()
963 { return _S_all().substr(15, 3); }
964
965 static consteval
966 _Str_view _S_u()
967 { return _S_all().substr(18, 2); }
968
969 static consteval
970 _Str_view _S_x()
971 { return _S_all().substr(20, 2); }
972
973 static constexpr
974 _Str_view _S_term(_Term_char __term)
975 {
976 switch (__term)
977 {
978 case _Term_none:
979 return _Str_view();
980 case _Term_quote:
981 return _S_quote().substr(0, 1);
982 case _Term_apos:
983 return _S_apos().substr(0, 1);
984 }
985 __builtin_unreachable();
986 }
987 };
988
989 template<typename _CharT>
990 struct _Separators
991 {
992 using _Str_view = basic_string_view<_CharT>;
993
994 static consteval
995 _Str_view _S_all()
996 { return _GLIBCXX_WIDEN("[]{}(), : "); }
997
998 static consteval
999 _Str_view _S_squares()
1000 { return _S_all().substr(0, 2); }
1001
1002 static consteval
1003 _Str_view _S_braces()
1004 { return _S_all().substr(2, 2); }
1005
1006 static consteval
1007 _Str_view _S_parens()
1008 { return _S_all().substr(4, 2); }
1009
1010 static consteval
1011 _Str_view _S_comma()
1012 { return _S_all().substr(6, 2); }
1013
1014 static consteval
1015 _Str_view _S_colon()
1016 { return _S_all().substr(8, 2); }
1017 };
1018
1019 template<typename _CharT>
1020 constexpr bool __should_escape_ascii(_CharT __c, _Term_char __term)
1021 {
1022 using _Esc = _Escapes<_CharT>;
1023 switch (__c)
1024 {
1025 case _Esc::_S_tab()[0]:
1026 case _Esc::_S_newline()[0]:
1027 case _Esc::_S_return()[0]:
1028 case _Esc::_S_bslash()[0]:
1029 return true;
1030 case _Esc::_S_quote()[0]:
1031 return __term == _Term_quote;
1032 case _Esc::_S_apos()[0]:
1033 return __term == _Term_apos;
1034 default:
1035 return (__c >= 0 && __c < 0x20) || __c == 0x7f;
1036 };
1037 }
1038
1039 // @pre __c <= 0x10FFFF
1040 constexpr bool __should_escape_unicode(char32_t __c, bool __prev_esc)
1041 {
1042 if (__unicode::__should_escape_category(__c))
1043 return __c != U' ';
1044 if (!__prev_esc)
1045 return false;
1046 return __unicode::__grapheme_cluster_break_property(__c)
1047 == __unicode::_Gcb_property::_Gcb_Extend;
1048 }
1049
1050 using uint_least32_t = __UINT_LEAST32_TYPE__;
1051 template<typename _Out, typename _CharT>
1052 _Out
1053 __write_escape_seq(_Out __out, uint_least32_t __val,
1054 basic_string_view<_CharT> __prefix)
1055 {
1056 using _Str_view = basic_string_view<_CharT>;
1057 constexpr size_t __max = 8;
1058 char __buf[__max];
1059 const string_view __narrow(
1060 __buf,
1061 std::__to_chars_i<uint_least32_t>(__buf, __buf + __max, __val, 16).ptr);
1062
1063 __out = __format::__write(__out, __prefix);
1064 *__out = _Separators<_CharT>::_S_braces()[0];
1065 ++__out;
1066 if constexpr (is_same_v<char, _CharT>)
1067 __out = __format::__write(__out, __narrow);
1068#ifdef _GLIBCXX_USE_WCHAR_T
1069 else
1070 {
1071 _CharT __wbuf[__max];
1072 const size_t __n = __narrow.size();
1073 std::__to_wstring_numeric(__narrow.data(), __n, __wbuf);
1074 __out = __format::__write(__out, _Str_view(__wbuf, __n));
1075 }
1076#endif
1077 *__out = _Separators<_CharT>::_S_braces()[1];
1078 return ++__out;
1079 }
1080
1081 template<typename _Out, typename _CharT>
1082 _Out
1083 __write_escape_seqs(_Out __out, basic_string_view<_CharT> __units)
1084 {
1085 using _UChar = make_unsigned_t<_CharT>;
1086 for (_CharT __c : __units)
1087 __out = __format::__write_escape_seq(
1088 __out, static_cast<_UChar>(__c), _Escapes<_CharT>::_S_x());
1089 return __out;
1090 }
1091
1092 template<typename _Out, typename _CharT>
1093 _Out
1094 __write_escaped_char(_Out __out, _CharT __c)
1095 {
1096 using _UChar = make_unsigned_t<_CharT>;
1097 using _Esc = _Escapes<_CharT>;
1098 switch (__c)
1099 {
1100 case _Esc::_S_tab()[0]:
1101 return __format::__write(__out, _Esc::_S_tab().substr(1, 2));
1102 case _Esc::_S_newline()[0]:
1103 return __format::__write(__out, _Esc::_S_newline().substr(1, 2));
1104 case _Esc::_S_return()[0]:
1105 return __format::__write(__out, _Esc::_S_return().substr(1, 2));
1106 case _Esc::_S_bslash()[0]:
1107 return __format::__write(__out, _Esc::_S_bslash().substr(1, 2));
1108 case _Esc::_S_quote()[0]:
1109 return __format::__write(__out, _Esc::_S_quote().substr(1, 2));
1110 case _Esc::_S_apos()[0]:
1111 return __format::__write(__out, _Esc::_S_apos().substr(1, 2));
1112 default:
1113 return __format::__write_escape_seq(
1114 __out, static_cast<_UChar>(__c), _Esc::_S_u());
1115 }
1116 }
1117
1118 template<typename _CharT, typename _Out>
1119 _Out
1120 __write_escaped_ascii(_Out __out,
1121 basic_string_view<_CharT> __str,
1122 _Term_char __term)
1123 {
1124 using _Str_view = basic_string_view<_CharT>;
1125 auto __first = __str.begin();
1126 auto const __last = __str.end();
1127 while (__first != __last)
1128 {
1129 auto __print = __first;
1130 // assume anything outside ASCII is printable
1131 while (__print != __last
1132 && !__format::__should_escape_ascii(*__print, __term))
1133 ++__print;
1134
1135 if (__print != __first)
1136 __out = __format::__write(__out, _Str_view(__first, __print));
1137
1138 if (__print == __last)
1139 return __out;
1140
1141 __first = __print;
1142 __out = __format::__write_escaped_char(__out, *__first);
1143 ++__first;
1144 }
1145 return __out;
1146 }
1147
1148 template<typename _CharT, typename _Out>
1149 _Out
1150 __write_escaped_unicode_part(_Out __out, basic_string_view<_CharT>& __str,
1151 bool& __prev_esc, _Term_char __term)
1152 {
1153 using _Str_view = basic_string_view<_CharT>;
1154 using _Esc = _Escapes<_CharT>;
1155
1156 static constexpr char32_t __replace = U'\uFFFD';
1157 static constexpr _Str_view __replace_rep = []
1158 {
1159 // N.B. "\uFFFD" is ill-formed if encoding is not unicode.
1160 if constexpr (is_same_v<char, _CharT>)
1161 return "\xEF\xBF\xBD";
1162 else
1163 return L"\xFFFD";
1164 }();
1165
1166 __unicode::_Utf_view<char32_t, _Str_view> __v(std::move(__str));
1167 __str = {};
1168
1169 auto __first = __v.begin();
1170 auto const __last = __v.end();
1171 while (__first != __last)
1172 {
1173 bool __esc_ascii = false;
1174 bool __esc_unicode = false;
1175 bool __esc_replace = false;
1176 auto __should_escape = [&](auto const& __it)
1177 {
1178 if (*__it <= 0x7f)
1179 return __esc_ascii
1180 = __format::__should_escape_ascii(*__it.base(), __term);
1181 if (__format::__should_escape_unicode(*__it, __prev_esc))
1182 return __esc_unicode = true;
1183 if (*__it == __replace)
1184 {
1185 _Str_view __units(__it.base(), __it._M_units());
1186 return __esc_replace = (__units != __replace_rep);
1187 }
1188 return false;
1189 };
1190
1191 auto __print = __first;
1192 while (__print != __last && !__should_escape(__print))
1193 {
1194 __prev_esc = false;
1195 ++__print;
1196 }
1197
1198 if (__print != __first)
1199 __out = __format::__write(__out, _Str_view(__first.base(), __print.base()));
1200
1201 if (__print == __last)
1202 return __out;
1203
1204 __first = __print;
1205 if (__esc_ascii)
1206 __out = __format::__write_escaped_char(__out, *__first.base());
1207 else if (__esc_unicode)
1208 __out = __format::__write_escape_seq(__out, *__first, _Esc::_S_u());
1209 // __esc_replace
1210 else if (_Str_view __units(__first.base(), __first._M_units());
1211 __units.end() != __last.base())
1212 __out = __format::__write_escape_seqs(__out, __units);
1213 else
1214 {
1215 __str = __units;
1216 return __out;
1217 }
1218
1219 __prev_esc = true;
1220 ++__first;
1221 }
1222
1223 return __out;
1224 }
1225
1226 template<typename _CharT, typename _Out>
1227 _Out
1228 __write_escaped_unicode(_Out __out, basic_string_view<_CharT> __str,
1229 _Term_char __term)
1230 {
1231 bool __prev_escape = true;
1232 __out = __format::__write_escaped_unicode_part(__out, __str,
1233 __prev_escape, __term);
1234 __out = __format::__write_escape_seqs(__out, __str);
1235 return __out;
1236 }
1237
1238 template<typename _CharT, typename _Out>
1239 _Out
1240 __write_escaped(_Out __out, basic_string_view<_CharT> __str, _Term_char __term)
1241 {
1242 __out = __format::__write(__out, _Escapes<_CharT>::_S_term(__term));
1243
1244 if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
1245 __out = __format::__write_escaped_unicode(__out, __str, __term);
1246 else if constexpr (is_same_v<char, _CharT>
1247 && __unicode::__literal_encoding_is_extended_ascii())
1248 __out = __format::__write_escaped_ascii(__out, __str, __term);
1249 else
1250 // TODO Handle non-ascii extended encoding
1251 __out = __format::__write_escaped_ascii(__out, __str, __term);
1252
1253 return __format::__write(__out, _Escapes<_CharT>::_S_term(__term));
1254 }
1255
1256 // A lightweight optional<locale>.
1257 struct _Optional_locale
1258 {
1259 [[__gnu__::__always_inline__]]
1260 _Optional_locale() : _M_dummy(), _M_hasval(false) { }
1261
1262 _Optional_locale(const locale& __loc) noexcept
1263 : _M_loc(__loc), _M_hasval(true)
1264 { }
1265
1266 _Optional_locale(const _Optional_locale& __l) noexcept
1267 : _M_dummy(), _M_hasval(__l._M_hasval)
1268 {
1269 if (_M_hasval)
1270 std::construct_at(&_M_loc, __l._M_loc);
1271 }
1272
1273 _Optional_locale&
1274 operator=(const _Optional_locale& __l) noexcept
1275 {
1276 if (_M_hasval)
1277 {
1278 if (__l._M_hasval)
1279 _M_loc = __l._M_loc;
1280 else
1281 {
1282 _M_loc.~locale();
1283 _M_hasval = false;
1284 }
1285 }
1286 else if (__l._M_hasval)
1287 {
1288 std::construct_at(&_M_loc, __l._M_loc);
1289 _M_hasval = true;
1290 }
1291 return *this;
1292 }
1293
1294 ~_Optional_locale() { if (_M_hasval) _M_loc.~locale(); }
1295
1296 _Optional_locale&
1297 operator=(locale&& __loc) noexcept
1298 {
1299 if (_M_hasval)
1300 _M_loc = std::move(__loc);
1301 else
1302 {
1303 std::construct_at(&_M_loc, std::move(__loc));
1304 _M_hasval = true;
1305 }
1306 return *this;
1307 }
1308
1309 const locale&
1310 value() noexcept
1311 {
1312 if (!_M_hasval)
1313 {
1314 std::construct_at(&_M_loc);
1315 _M_hasval = true;
1316 }
1317 return _M_loc;
1318 }
1319
1320 bool has_value() const noexcept { return _M_hasval; }
1321
1322 union {
1323 char _M_dummy = '\0';
1324 std::locale _M_loc;
1325 };
1326 bool _M_hasval = false;
1327 };
1328
1329 template<__char _CharT>
1330 struct __formatter_str
1331 {
1332 __formatter_str() = default;
1333
1334 constexpr
1335 __formatter_str(_Spec<_CharT> __spec) noexcept
1336 : _M_spec(__spec)
1337 { }
1338
1339 constexpr typename basic_format_parse_context<_CharT>::iterator
1340 parse(basic_format_parse_context<_CharT>& __pc)
1341 {
1342 auto __first = __pc.begin();
1343 const auto __last = __pc.end();
1344 _Spec<_CharT> __spec{};
1345
1346 auto __finalize = [this, &__spec] {
1347 _M_spec = __spec;
1348 };
1349
1350 auto __finished = [&] {
1351 if (__first == __last || *__first == '}')
1352 {
1353 __finalize();
1354 return true;
1355 }
1356 return false;
1357 };
1358
1359 if (__finished())
1360 return __first;
1361
1362 __first = __spec._M_parse_fill_and_align(__first, __last);
1363 if (__finished())
1364 return __first;
1365
1366 __first = __spec._M_parse_width(__first, __last, __pc);
1367 if (__finished())
1368 return __first;
1369
1370 __first = __spec._M_parse_precision(__first, __last, __pc);
1371 if (__finished())
1372 return __first;
1373
1374 if (*__first == 's')
1375 {
1376 __spec._M_type = _Pres_s;
1377 ++__first;
1378 }
1379#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
1380 else if (*__first == '?')
1381 {
1382 __spec._M_debug = true;
1383 ++__first;
1384 }
1385#endif
1386
1387 if (__finished())
1388 return __first;
1389
1390 __format::__failed_to_parse_format_spec();
1391 }
1392
1393 template<typename _Out>
1394 _Out
1395 format(basic_string_view<_CharT> __s,
1396 basic_format_context<_Out, _CharT>& __fc) const
1397 {
1398 if (_M_spec._M_debug)
1399 return _M_format_escaped(__s, __fc);
1400
1401 if (_M_spec._M_width_kind == _WP_none
1402 && _M_spec._M_prec_kind == _WP_none)
1403 return __format::__write(__fc.out(), __s);
1404
1405 const size_t __maxwidth = _M_spec._M_get_precision(__fc);
1406 const size_t __width = __format::__truncate(__s, __maxwidth);
1407 return __format::__write_padded_as_spec(__s, __width, __fc, _M_spec);
1408 }
1409
1410 template<typename _Out>
1411 _Out
1412 _M_format_escaped(basic_string_view<_CharT> __s,
1413 basic_format_context<_Out, _CharT>& __fc) const
1414 {
1415 const size_t __padwidth = _M_spec._M_get_width(__fc);
1416 if (__padwidth == 0 && _M_spec._M_prec_kind == _WP_none)
1417 return __format::__write_escaped(__fc.out(), __s, _Term_quote);
1418
1419 const size_t __maxwidth = _M_spec._M_get_precision(__fc);
1420 const size_t __width = __truncate(__s, __maxwidth);
1421 // N.B. Escaping only increases width
1422 if (__padwidth <= __width && _M_spec._M_prec_kind == _WP_none)
1423 return __format::__write_escaped(__fc.out(), __s, _Term_quote);
1424
1425 // N.B. [tab:format.type.string] defines '?' as
1426 // Copies the escaped string ([format.string.escaped]) to the output,
1427 // so precision seem to appy to escaped string.
1428 _Padding_sink<_Out, _CharT> __sink(__fc.out(), __padwidth, __maxwidth);
1429 __format::__write_escaped(__sink.out(), __s, _Term_quote);
1430 return __sink._M_finish(_M_spec._M_align, _M_spec._M_fill);
1431 }
1432
1433#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
1434 template<ranges::input_range _Rg, typename _Out>
1435 requires same_as<remove_cvref_t<ranges::range_reference_t<_Rg>>, _CharT>
1436 _Out
1437 _M_format_range(_Rg&& __rg, basic_format_context<_Out, _CharT>& __fc) const
1438 {
1439 using _Range = remove_reference_t<_Rg>;
1440 using _String_view = basic_string_view<_CharT>;
1441 if constexpr (!is_lvalue_reference_v<_Rg>)
1442 return _M_format_range<_Range&>(__rg, __fc);
1443 else if constexpr (!is_const_v<_Range>
1444 && __simply_formattable_range<_Range, _CharT>)
1445 return _M_format_range<const _Range&>(__rg, __fc);
1446 else if constexpr (ranges::contiguous_range<_Rg>)
1447 {
1448 _String_view __str(ranges::data(__rg),
1449 size_t(ranges::distance(__rg)));
1450 return format(__str, __fc);
1451 }
1452 else
1453 {
1454 auto __handle_debug = [this, &__rg]<typename _NOut>(_NOut __nout)
1455 {
1456 if (!_M_spec._M_debug)
1457 return ranges::copy(__rg, std::move(__nout)).out;
1458
1459 _Escaping_sink<_NOut, _CharT>
1460 __sink(std::move(__nout), _Term_quote);
1461 ranges::copy(__rg, __sink.out());
1462 return __sink._M_finish();
1463 };
1464
1465 const size_t __padwidth = _M_spec._M_get_width(__fc);
1466 if (__padwidth == 0 && _M_spec._M_prec_kind == _WP_none)
1467 return __handle_debug(__fc.out());
1468
1469 _Padding_sink<_Out, _CharT>
1470 __sink(__fc.out(), __padwidth, _M_spec._M_get_precision(__fc));
1471 __handle_debug(__sink.out());
1472 return __sink._M_finish(_M_spec._M_align, _M_spec._M_fill);
1473 }
1474 }
1475
1476 constexpr void
1477 set_debug_format() noexcept
1478 { _M_spec._M_debug = true; }
1479#endif
1480
1481 private:
1482 _Spec<_CharT> _M_spec{};
1483 };
1484
1485 template<__char _CharT>
1486 struct __formatter_int
1487 {
1488 // If no presentation type is specified, meaning of "none" depends
1489 // whether we are formatting an integer or a char or a bool.
1490 static constexpr _Pres_type _AsInteger = _Pres_d;
1491 static constexpr _Pres_type _AsBool = _Pres_s;
1492 static constexpr _Pres_type _AsChar = _Pres_c;
1493
1494 __formatter_int() = default;
1495
1496 constexpr
1497 __formatter_int(_Spec<_CharT> __spec) noexcept
1498 : _M_spec(__spec)
1499 {
1500 if (_M_spec._M_type == _Pres_none)
1501 _M_spec._M_type = _Pres_d;
1502 }
1503
1504 constexpr typename basic_format_parse_context<_CharT>::iterator
1505 _M_do_parse(basic_format_parse_context<_CharT>& __pc, _Pres_type __type)
1506 {
1507 _Spec<_CharT> __spec{};
1508 __spec._M_type = __type;
1509
1510 const auto __last = __pc.end();
1511 auto __first = __pc.begin();
1512
1513 auto __finalize = [this, &__spec] {
1514 _M_spec = __spec;
1515 };
1516
1517 auto __finished = [&] {
1518 if (__first == __last || *__first == '}')
1519 {
1520 __finalize();
1521 return true;
1522 }
1523 return false;
1524 };
1525
1526 if (__finished())
1527 return __first;
1528
1529 __first = __spec._M_parse_fill_and_align(__first, __last);
1530 if (__finished())
1531 return __first;
1532
1533 __first = __spec._M_parse_sign(__first, __last);
1534 if (__finished())
1535 return __first;
1536
1537 __first = __spec._M_parse_alternate_form(__first, __last);
1538 if (__finished())
1539 return __first;
1540
1541 __first = __spec._M_parse_zero_fill(__first, __last);
1542 if (__finished())
1543 return __first;
1544
1545 __first = __spec._M_parse_width(__first, __last, __pc);
1546 if (__finished())
1547 return __first;
1548
1549 __first = __spec._M_parse_locale(__first, __last);
1550 if (__finished())
1551 return __first;
1552
1553 switch (*__first)
1554 {
1555 case 'b':
1556 __spec._M_type = _Pres_b;
1557 ++__first;
1558 break;
1559 case 'B':
1560 __spec._M_type = _Pres_B;
1561 ++__first;
1562 break;
1563 case 'c':
1564 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1565 // 3586. format should not print bool with 'c'
1566 if (__type != _AsBool)
1567 {
1568 __spec._M_type = _Pres_c;
1569 ++__first;
1570 }
1571 break;
1572 case 'd':
1573 __spec._M_type = _Pres_d;
1574 ++__first;
1575 break;
1576 case 'o':
1577 __spec._M_type = _Pres_o;
1578 ++__first;
1579 break;
1580 case 'x':
1581 __spec._M_type = _Pres_x;
1582 ++__first;
1583 break;
1584 case 'X':
1585 __spec._M_type = _Pres_X;
1586 ++__first;
1587 break;
1588 case 's':
1589 if (__type == _AsBool)
1590 {
1591 __spec._M_type = _Pres_s; // same meaning as "none" for bool
1592 ++__first;
1593 }
1594 break;
1595#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
1596 case '?':
1597 if (__type == _AsChar)
1598 {
1599 __spec._M_debug = true;
1600 ++__first;
1601 }
1602#endif
1603 break;
1604 }
1605
1606 if (__finished())
1607 return __first;
1608
1609 __format::__failed_to_parse_format_spec();
1610 }
1611
1612 template<typename _Tp>
1613 constexpr typename basic_format_parse_context<_CharT>::iterator
1614 _M_parse(basic_format_parse_context<_CharT>& __pc)
1615 {
1616 if constexpr (is_same_v<_Tp, bool>)
1617 {
1618 auto __end = _M_do_parse(__pc, _AsBool);
1619 if (_M_spec._M_type == _Pres_s)
1620 if (_M_spec._M_sign != _Sign_default || _M_spec._M_alt
1621 || _M_spec._M_zero_fill)
1622 __throw_format_error("format error: format-spec contains "
1623 "invalid formatting options for "
1624 "'bool'");
1625 return __end;
1626 }
1627 else if constexpr (__char<_Tp>)
1628 {
1629 auto __end = _M_do_parse(__pc, _AsChar);
1630 if (_M_spec._M_type == _Pres_c)
1631 if (_M_spec._M_sign != _Sign_default || _M_spec._M_alt
1632 || _M_spec._M_zero_fill
1633 /* XXX should be invalid? || _M_spec._M_localized */)
1634 __throw_format_error("format error: format-spec contains "
1635 "invalid formatting options for "
1636 "'charT'");
1637 return __end;
1638 }
1639 else
1640 return _M_do_parse(__pc, _AsInteger);
1641 }
1642
1643 template<typename _Int, typename _Out>
1644 typename basic_format_context<_Out, _CharT>::iterator
1645 format(_Int __i, basic_format_context<_Out, _CharT>& __fc) const
1646 {
1647 if (_M_spec._M_type == _Pres_c)
1648 return _M_format_character(_S_to_character(__i), __fc);
1649
1650 constexpr size_t __buf_size = sizeof(_Int) * __CHAR_BIT__ + 3;
1651 char __buf[__buf_size];
1652 to_chars_result __res{};
1653
1654 string_view __base_prefix;
1655 make_unsigned_t<_Int> __u;
1656 if (__i < 0)
1657 __u = -static_cast<make_unsigned_t<_Int>>(__i);
1658 else
1659 __u = __i;
1660
1661 char* __start = __buf + 3;
1662 char* const __end = __buf + sizeof(__buf);
1663 char* const __start_digits = __start;
1664
1665 switch (_M_spec._M_type)
1666 {
1667 case _Pres_b:
1668 case _Pres_B:
1669 __base_prefix = _M_spec._M_type == _Pres_b ? "0b" : "0B";
1670 __res = to_chars(__start, __end, __u, 2);
1671 break;
1672#if 0
1673 case _Pres_c:
1674 return _M_format_character(_S_to_character(__i), __fc);
1675#endif
1676 case _Pres_none:
1677 // Should not reach here with _Pres_none for bool or charT, so:
1678 [[fallthrough]];
1679 case _Pres_d:
1680 __res = to_chars(__start, __end, __u, 10);
1681 break;
1682 case _Pres_o:
1683 if (__i != 0)
1684 __base_prefix = "0";
1685 __res = to_chars(__start, __end, __u, 8);
1686 break;
1687 case _Pres_x:
1688 case _Pres_X:
1689 __base_prefix = _M_spec._M_type == _Pres_x ? "0x" : "0X";
1690 __res = to_chars(__start, __end, __u, 16);
1691 if (_M_spec._M_type == _Pres_X)
1692 for (auto __p = __start; __p != __res.ptr; ++__p)
1693#if __has_builtin(__builtin_toupper)
1694 *__p = __builtin_toupper(*__p);
1695#else
1696 *__p = std::toupper(*__p);
1697#endif
1698 break;
1699 default:
1700 __builtin_unreachable();
1701 }
1702
1703 if (_M_spec._M_alt && __base_prefix.size())
1704 {
1705 __start -= __base_prefix.size();
1706 __builtin_memcpy(__start, __base_prefix.data(),
1707 __base_prefix.size());
1708 }
1709 __start = __format::__put_sign(__i, _M_spec._M_sign, __start - 1);
1710
1711
1712 string_view __narrow_str(__start, __res.ptr - __start);
1713 size_t __prefix_len = __start_digits - __start;
1714 if constexpr (is_same_v<char, _CharT>)
1715 return _M_format_int(__narrow_str, __prefix_len, __fc);
1716#ifdef _GLIBCXX_USE_WCHAR_T
1717 else
1718 {
1719 _CharT __wbuf[__buf_size];
1720 size_t __n = __narrow_str.size();
1721 std::__to_wstring_numeric(__narrow_str.data(), __n, __wbuf);
1722 return _M_format_int(basic_string_view<_CharT>(__wbuf, __n),
1723 __prefix_len, __fc);
1724 }
1725#endif
1726 }
1727
1728 template<typename _Out>
1729 typename basic_format_context<_Out, _CharT>::iterator
1730 format(bool __i, basic_format_context<_Out, _CharT>& __fc) const
1731 {
1732 if (_M_spec._M_type == _Pres_c)
1733 return _M_format_character(static_cast<unsigned char>(__i), __fc);
1734 if (_M_spec._M_type != _Pres_s)
1735 return format(static_cast<unsigned char>(__i), __fc);
1736
1737 basic_string<_CharT> __s;
1738 size_t __est_width;
1739 if (_M_spec._M_localized) [[unlikely]]
1740 {
1741 auto& __np = std::use_facet<numpunct<_CharT>>(__fc.locale());
1742 __s = __i ? __np.truename() : __np.falsename();
1743 __est_width = __s.size(); // TODO Unicode-aware estimate
1744 }
1745 else
1746 {
1747 if constexpr (is_same_v<char, _CharT>)
1748 __s = __i ? "true" : "false";
1749 else
1750 __s = __i ? L"true" : L"false";
1751 __est_width = __s.size();
1752 }
1753
1754 return __format::__write_padded_as_spec(__s, __est_width, __fc,
1755 _M_spec);
1756 }
1757
1758 template<typename _Out>
1759 typename basic_format_context<_Out, _CharT>::iterator
1760 _M_format_character(_CharT __c,
1761 basic_format_context<_Out, _CharT>& __fc) const
1762 {
1763 basic_string_view<_CharT> __in(&__c, 1u);
1764 size_t __width = 1u;
1765 // N.B. single byte cannot encode character of width greater than 1
1766 if constexpr (sizeof(_CharT) > 1u &&
1767 __unicode::__literal_encoding_is_unicode<_CharT>())
1768 __width = __unicode::__field_width(__c);
1769
1770 if (!_M_spec._M_debug)
1771 return __format::__write_padded_as_spec(__in, __width,
1772 __fc, _M_spec);
1773
1774 __width += 2;
1775 if (_M_spec._M_get_width(__fc) <= __width)
1776 return __format::__write_escaped(__fc.out(), __in, _Term_apos);
1777
1778 _CharT __buf[12];
1779 _Fixedbuf_sink<_CharT> __sink(__buf);
1780 __format::__write_escaped(__sink.out(), __in, _Term_apos);
1781
1782 __in = __sink.view();
1783 if (__in[1] == _Escapes<_CharT>::_S_bslash()[0]) // escape sequence
1784 __width = __in.size();
1785 return __format::__write_padded_as_spec(__in, __width,
1786 __fc, _M_spec);
1787 }
1788
1789 template<typename _Int>
1790 static _CharT
1791 _S_to_character(_Int __i)
1792 {
1793 using _Traits = __gnu_cxx::__int_traits<_CharT>;
1794 if constexpr (is_signed_v<_Int> == is_signed_v<_CharT>)
1795 {
1796 if (_Traits::__min <= __i && __i <= _Traits::__max)
1797 return static_cast<_CharT>(__i);
1798 }
1799 else if constexpr (is_signed_v<_Int>)
1800 {
1801 if (__i >= 0 && make_unsigned_t<_Int>(__i) <= _Traits::__max)
1802 return static_cast<_CharT>(__i);
1803 }
1804 else if (__i <= make_unsigned_t<_CharT>(_Traits::__max))
1805 return static_cast<_CharT>(__i);
1806 __throw_format_error("format error: integer not representable as "
1807 "character");
1808 }
1809
1810 template<typename _Out>
1811 typename basic_format_context<_Out, _CharT>::iterator
1812 _M_format_int(basic_string_view<_CharT> __str, size_t __prefix_len,
1813 basic_format_context<_Out, _CharT>& __fc) const
1814 {
1815 size_t __width = _M_spec._M_get_width(__fc);
1816 if (_M_spec._M_localized)
1817 {
1818 const auto& __l = __fc.locale();
1819 if (__l.name() != "C")
1820 {
1821 auto& __np = use_facet<numpunct<_CharT>>(__l);
1822 string __grp = __np.grouping();
1823 if (!__grp.empty())
1824 {
1825 size_t __n = __str.size() - __prefix_len;
1826 auto __p = (_CharT*)__builtin_alloca(2 * __n
1827 * sizeof(_CharT)
1828 + __prefix_len);
1829 auto __s = __str.data();
1830 char_traits<_CharT>::copy(__p, __s, __prefix_len);
1831 __s += __prefix_len;
1832 auto __end = std::__add_grouping(__p + __prefix_len,
1833 __np.thousands_sep(),
1834 __grp.data(),
1835 __grp.size(),
1836 __s, __s + __n);
1837 __str = {__p, size_t(__end - __p)};
1838 }
1839 }
1840 }
1841
1842 if (__width <= __str.size())
1843 return __format::__write(__fc.out(), __str);
1844
1845 char32_t __fill_char = _M_spec._M_fill;
1846 _Align __align = _M_spec._M_align;
1847
1848 size_t __nfill = __width - __str.size();
1849 auto __out = __fc.out();
1850 if (__align == _Align_default)
1851 {
1852 __align = _Align_right;
1853 if (_M_spec._M_zero_fill)
1854 {
1855 __fill_char = _CharT('0');
1856 // Write sign and base prefix before zero filling.
1857 if (__prefix_len != 0)
1858 {
1859 __out = __format::__write(std::move(__out),
1860 __str.substr(0, __prefix_len));
1861 __str.remove_prefix(__prefix_len);
1862 }
1863 }
1864 else
1865 __fill_char = _CharT(' ');
1866 }
1867 return __format::__write_padded(std::move(__out), __str,
1868 __align, __nfill, __fill_char);
1869 }
1870
1871 _Spec<_CharT> _M_spec{};
1872 };
1873
1874#ifdef __BFLT16_DIG__
1875 using __bflt16_t = decltype(0.0bf16);
1876#endif
1877
1878 // Decide how 128-bit floating-point types should be formatted (or not).
1879 // When supported, the typedef __format::__flt128_t is the type that format
1880 // arguments should be converted to before passing them to __formatter_fp.
1881 // Define the macro _GLIBCXX_FORMAT_F128 to say they're supported.
1882 // The __float128, _Float128 will be formatted by converting them to:
1883 // __ieee128 (same as __float128) when _GLIBCXX_FORMAT_F128=1,
1884 // long double when _GLIBCXX_FORMAT_F128=2,
1885 // _Float128 when _GLIBCXX_FORMAT_F128=3.
1886#undef _GLIBCXX_FORMAT_F128
1887
1888#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
1889
1890 // Format 128-bit floating-point types using __ieee128.
1891 using __flt128_t = __ieee128;
1892# define _GLIBCXX_FORMAT_F128 1
1893
1894#ifdef __LONG_DOUBLE_IEEE128__
1895 // These overloads exist in the library, but are not declared.
1896 // Make them available as std::__format::to_chars.
1897 to_chars_result
1898 to_chars(char*, char*, __ibm128) noexcept
1899 __asm("_ZSt8to_charsPcS_e");
1900
1901 to_chars_result
1902 to_chars(char*, char*, __ibm128, chars_format) noexcept
1903 __asm("_ZSt8to_charsPcS_eSt12chars_format");
1904
1905 to_chars_result
1906 to_chars(char*, char*, __ibm128, chars_format, int) noexcept
1907 __asm("_ZSt8to_charsPcS_eSt12chars_formati");
1908#elif __cplusplus == 202002L
1909 to_chars_result
1910 to_chars(char*, char*, __ieee128) noexcept
1911 __asm("_ZSt8to_charsPcS_u9__ieee128");
1912
1913 to_chars_result
1914 to_chars(char*, char*, __ieee128, chars_format) noexcept
1915 __asm("_ZSt8to_charsPcS_u9__ieee128St12chars_format");
1916
1917 to_chars_result
1918 to_chars(char*, char*, __ieee128, chars_format, int) noexcept
1919 __asm("_ZSt8to_charsPcS_u9__ieee128St12chars_formati");
1920#endif
1921
1922#elif defined _GLIBCXX_LDOUBLE_IS_IEEE_BINARY128
1923
1924 // Format 128-bit floating-point types using long double.
1925 using __flt128_t = long double;
1926# define _GLIBCXX_FORMAT_F128 2
1927
1928#elif __FLT128_DIG__ && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
1929
1930 // Format 128-bit floating-point types using _Float128.
1931 using __flt128_t = _Float128;
1932# define _GLIBCXX_FORMAT_F128 3
1933
1934# if __cplusplus == 202002L
1935 // These overloads exist in the library, but are not declared for C++20.
1936 // Make them available as std::__format::to_chars.
1937 to_chars_result
1938 to_chars(char*, char*, _Float128) noexcept
1939# if _GLIBCXX_INLINE_VERSION
1940 __asm("_ZNSt3__88to_charsEPcS0_DF128_");
1941# else
1942 __asm("_ZSt8to_charsPcS_DF128_");
1943# endif
1944
1945 to_chars_result
1946 to_chars(char*, char*, _Float128, chars_format) noexcept
1947# if _GLIBCXX_INLINE_VERSION
1948 __asm("_ZNSt3__88to_charsEPcS0_DF128_NS_12chars_formatE");
1949# else
1950 __asm("_ZSt8to_charsPcS_DF128_St12chars_format");
1951# endif
1952
1953 to_chars_result
1954 to_chars(char*, char*, _Float128, chars_format, int) noexcept
1955# if _GLIBCXX_INLINE_VERSION
1956 __asm("_ZNSt3__88to_charsEPcS0_DF128_NS_12chars_formatEi");
1957# else
1958 __asm("_ZSt8to_charsPcS_DF128_St12chars_formati");
1959# endif
1960# endif
1961#endif
1962
1963 using std::to_chars;
1964
1965 // We can format a floating-point type iff it is usable with to_chars.
1966 template<typename _Tp>
1967 concept __formattable_float
1968 = is_same_v<remove_cv_t<_Tp>, _Tp> && requires (_Tp __t, char* __p)
1969 { __format::to_chars(__p, __p, __t, chars_format::scientific, 6); };
1970
1971 template<__char _CharT>
1972 struct __formatter_fp
1973 {
1974 constexpr typename basic_format_parse_context<_CharT>::iterator
1975 parse(basic_format_parse_context<_CharT>& __pc)
1976 {
1977 _Spec<_CharT> __spec{};
1978 const auto __last = __pc.end();
1979 auto __first = __pc.begin();
1980
1981 auto __finalize = [this, &__spec] {
1982 _M_spec = __spec;
1983 };
1984
1985 auto __finished = [&] {
1986 if (__first == __last || *__first == '}')
1987 {
1988 __finalize();
1989 return true;
1990 }
1991 return false;
1992 };
1993
1994 if (__finished())
1995 return __first;
1996
1997 __first = __spec._M_parse_fill_and_align(__first, __last);
1998 if (__finished())
1999 return __first;
2000
2001 __first = __spec._M_parse_sign(__first, __last);
2002 if (__finished())
2003 return __first;
2004
2005 __first = __spec._M_parse_alternate_form(__first, __last);
2006 if (__finished())
2007 return __first;
2008
2009 __first = __spec._M_parse_zero_fill(__first, __last);
2010 if (__finished())
2011 return __first;
2012
2013 if (__first[0] != '.')
2014 {
2015 __first = __spec._M_parse_width(__first, __last, __pc);
2016 if (__finished())
2017 return __first;
2018 }
2019
2020 __first = __spec._M_parse_precision(__first, __last, __pc);
2021 if (__finished())
2022 return __first;
2023
2024 __first = __spec._M_parse_locale(__first, __last);
2025 if (__finished())
2026 return __first;
2027
2028 switch (*__first)
2029 {
2030 case 'a':
2031 __spec._M_type = _Pres_a;
2032 ++__first;
2033 break;
2034 case 'A':
2035 __spec._M_type = _Pres_A;
2036 ++__first;
2037 break;
2038 case 'e':
2039 __spec._M_type = _Pres_e;
2040 ++__first;
2041 break;
2042 case 'E':
2043 __spec._M_type = _Pres_E;
2044 ++__first;
2045 break;
2046 case 'f':
2047 __spec._M_type = _Pres_f;
2048 ++__first;
2049 break;
2050 case 'F':
2051 __spec._M_type = _Pres_F;
2052 ++__first;
2053 break;
2054 case 'g':
2055 __spec._M_type = _Pres_g;
2056 ++__first;
2057 break;
2058 case 'G':
2059 __spec._M_type = _Pres_G;
2060 ++__first;
2061 break;
2062 }
2063
2064 if (__finished())
2065 return __first;
2066
2067 __format::__failed_to_parse_format_spec();
2068 }
2069
2070 template<typename _Fp, typename _Out>
2071 typename basic_format_context<_Out, _CharT>::iterator
2072 format(_Fp __v, basic_format_context<_Out, _CharT>& __fc) const
2073 {
2074 std::string __dynbuf;
2075 char __buf[128];
2076 to_chars_result __res{};
2077
2078 size_t __prec = 6;
2079 bool __use_prec = _M_spec._M_prec_kind != _WP_none;
2080 if (__use_prec)
2081 __prec = _M_spec._M_get_precision(__fc);
2082
2083 char* __start = __buf + 1; // reserve space for sign
2084 char* __end = __buf + sizeof(__buf);
2085
2086 chars_format __fmt{};
2087 bool __upper = false;
2088 bool __trailing_zeros = false;
2089 char __expc = 'e';
2090
2091 switch (_M_spec._M_type)
2092 {
2093 case _Pres_A:
2094 __upper = true;
2095 __expc = 'P';
2096 [[fallthrough]];
2097 case _Pres_a:
2098 if (_M_spec._M_type != _Pres_A)
2099 __expc = 'p';
2100 __fmt = chars_format::hex;
2101 break;
2102 case _Pres_E:
2103 __upper = true;
2104 __expc = 'E';
2105 [[fallthrough]];
2106 case _Pres_e:
2107 __use_prec = true;
2108 __fmt = chars_format::scientific;
2109 break;
2110 case _Pres_F:
2111 __upper = true;
2112 [[fallthrough]];
2113 case _Pres_f:
2114 __use_prec = true;
2115 __fmt = chars_format::fixed;
2116 break;
2117 case _Pres_G:
2118 __upper = true;
2119 __expc = 'E';
2120 [[fallthrough]];
2121 case _Pres_g:
2122 __trailing_zeros = true;
2123 __use_prec = true;
2124 __fmt = chars_format::general;
2125 break;
2126 case _Pres_none:
2127 if (__use_prec)
2128 __fmt = chars_format::general;
2129 break;
2130 default:
2131 __builtin_unreachable();
2132 }
2133
2134 // Write value into buffer using std::to_chars.
2135 auto __to_chars = [&](char* __b, char* __e) {
2136 if (__use_prec)
2137 return __format::to_chars(__b, __e, __v, __fmt, __prec);
2138 else if (__fmt != chars_format{})
2139 return __format::to_chars(__b, __e, __v, __fmt);
2140 else
2141 return __format::to_chars(__b, __e, __v);
2142 };
2143
2144 // First try using stack buffer.
2145 __res = __to_chars(__start, __end);
2146
2147 if (__builtin_expect(__res.ec == errc::value_too_large, 0))
2148 {
2149 // If the buffer is too small it's probably because of a large
2150 // precision, or a very large value in fixed format.
2151 size_t __guess = 8 + __prec;
2152 if (__fmt == chars_format::fixed) // +ddd.prec
2153 {
2154 if constexpr (is_same_v<_Fp, float> || is_same_v<_Fp, double>
2155 || is_same_v<_Fp, long double>)
2156 {
2157 // The number of digits to the left of the decimal point
2158 // is floor(log10(max(abs(__v),1)))+1
2159 int __exp{};
2160 if constexpr (is_same_v<_Fp, float>)
2161 __builtin_frexpf(__v, &__exp);
2162 else if constexpr (is_same_v<_Fp, double>)
2163 __builtin_frexp(__v, &__exp);
2164 else if constexpr (is_same_v<_Fp, long double>)
2165 __builtin_frexpl(__v, &__exp);
2166 if (__exp > 0)
2167 __guess += 1U + __exp * 4004U / 13301U; // log10(2) approx.
2168 }
2169 else
2170 __guess += numeric_limits<_Fp>::max_exponent10;
2171 }
2172 if (__guess <= sizeof(__buf)) [[unlikely]]
2173 __guess = sizeof(__buf) * 2;
2174 __dynbuf.reserve(__guess);
2175
2176 do
2177 {
2178 // Mangling of this lambda, and thus resize_and_overwrite
2179 // instantiated with it, was fixed in ABI 18 (G++ 13). Since
2180 // <format> was new in G++ 13, and is experimental, that
2181 // isn't a problem.
2182 auto __overwrite = [&__to_chars, &__res] (char* __p, size_t __n)
2183 {
2184 __res = __to_chars(__p + 1, __p + __n - 1);
2185 return __res.ec == errc{} ? __res.ptr - __p : 0;
2186 };
2187
2188 __dynbuf.__resize_and_overwrite(__dynbuf.capacity() * 2,
2189 __overwrite);
2190 __start = __dynbuf.data() + 1; // reserve space for sign
2191 __end = __dynbuf.data() + __dynbuf.size();
2192 }
2193 while (__builtin_expect(__res.ec == errc::value_too_large, 0));
2194 }
2195
2196 // Use uppercase for 'A', 'E', and 'G' formats.
2197 if (__upper)
2198 {
2199 for (char* __p = __start; __p != __res.ptr; ++__p)
2200 *__p = std::toupper(*__p);
2201 }
2202
2203 bool __have_sign = true;
2204 // Add sign for non-negative values.
2205 if (!__builtin_signbit(__v))
2206 {
2207 if (_M_spec._M_sign == _Sign_plus)
2208 *--__start = '+';
2209 else if (_M_spec._M_sign == _Sign_space)
2210 *--__start = ' ';
2211 else
2212 __have_sign = false;
2213 }
2214
2215 string_view __narrow_str(__start, __res.ptr - __start);
2216
2217 // Use alternate form. Ensure decimal point is always present,
2218 // and add trailing zeros (up to precision) for g and G forms.
2219 if (_M_spec._M_alt && __builtin_isfinite(__v))
2220 {
2221 string_view __s = __narrow_str;
2222 size_t __sigfigs; // Number of significant figures.
2223 size_t __z = 0; // Number of trailing zeros to add.
2224 size_t __p; // Position of the exponent character (if any).
2225 size_t __d = __s.find('.'); // Position of decimal point.
2226 if (__d != __s.npos) // Found decimal point.
2227 {
2228 __p = __s.find(__expc, __d + 1);
2229 if (__p == __s.npos)
2230 __p = __s.size();
2231
2232 // If presentation type is g or G we might need to add zeros.
2233 if (__trailing_zeros)
2234 {
2235 // Find number of digits after first significant figure.
2236 if (__s[__have_sign] != '0')
2237 // A string like "D.D" or "-D.DDD"
2238 __sigfigs = __p - __have_sign - 1;
2239 else
2240 // A string like "0.D" or "-0.0DD".
2241 // Safe to assume there is a non-zero digit, because
2242 // otherwise there would be no decimal point.
2243 __sigfigs = __p - __s.find_first_not_of('0', __d + 1);
2244 }
2245 }
2246 else // No decimal point, we need to insert one.
2247 {
2248 __p = __s.find(__expc); // Find the exponent, if present.
2249 if (__p == __s.npos)
2250 __p = __s.size();
2251 __d = __p; // Position where '.' should be inserted.
2252 __sigfigs = __d - __have_sign;
2253 }
2254
2255 if (__trailing_zeros && __prec != 0)
2256 {
2257 // For g and G presentation types std::to_chars produces
2258 // no more than prec significant figures. Insert this many
2259 // zeros so the result has exactly prec significant figures.
2260 __z = __prec - __sigfigs;
2261 }
2262
2263 if (size_t __extras = int(__d == __p) + __z) // How many to add.
2264 {
2265 if (__dynbuf.empty() && __extras <= size_t(__end - __res.ptr))
2266 {
2267 // The stack buffer is large enough for the result.
2268 // Move exponent to make space for extra chars.
2269 __builtin_memmove(__start + __p + __extras,
2270 __start + __p,
2271 __s.size() - __p);
2272 if (__d == __p)
2273 __start[__p++] = '.';
2274 __builtin_memset(__start + __p, '0', __z);
2275 __narrow_str = {__s.data(), __s.size() + __extras};
2276 }
2277 else // Need to switch to the dynamic buffer.
2278 {
2279 __dynbuf.reserve(__s.size() + __extras);
2280 if (__dynbuf.empty())
2281 {
2282 __dynbuf = __s.substr(0, __p);
2283 if (__d == __p)
2284 __dynbuf += '.';
2285 if (__z)
2286 __dynbuf.append(__z, '0');
2287 __dynbuf.append(__s.substr(__p));
2288 }
2289 else
2290 {
2291 __dynbuf.insert(__p, __extras, '0');
2292 if (__d == __p)
2293 __dynbuf[__p] = '.';
2294 }
2295 __narrow_str = __dynbuf;
2296 }
2297 }
2298 }
2299
2300 basic_string<_CharT> __wstr;
2301 basic_string_view<_CharT> __str;
2302 if constexpr (is_same_v<_CharT, char>)
2303 __str = __narrow_str;
2304#ifdef _GLIBCXX_USE_WCHAR_T
2305 else
2306 {
2307 __wstr = std::__to_wstring_numeric(__narrow_str);
2308 __str = __wstr;
2309 }
2310#endif
2311
2312 if (_M_spec._M_localized && __builtin_isfinite(__v))
2313 {
2314 auto __s = _M_localize(__str, __expc, __fc.locale());
2315 if (!__s.empty())
2316 __str = __wstr = std::move(__s);
2317 }
2318
2319 size_t __width = _M_spec._M_get_width(__fc);
2320
2321 if (__width <= __str.size())
2322 return __format::__write(__fc.out(), __str);
2323
2324 char32_t __fill_char = _M_spec._M_fill;
2325 _Align __align = _M_spec._M_align;
2326
2327 size_t __nfill = __width - __str.size();
2328 auto __out = __fc.out();
2329 if (__align == _Align_default)
2330 {
2331 __align = _Align_right;
2332 if (_M_spec._M_zero_fill && __builtin_isfinite(__v))
2333 {
2334 __fill_char = _CharT('0');
2335 // Write sign before zero filling.
2336 if (!__format::__is_xdigit(__narrow_str[0]))
2337 {
2338 *__out++ = __str[0];
2339 __str.remove_prefix(1);
2340 }
2341 }
2342 else
2343 __fill_char = _CharT(' ');
2344 }
2345 return __format::__write_padded(std::move(__out), __str,
2346 __align, __nfill, __fill_char);
2347 }
2348
2349 // Locale-specific format.
2350 basic_string<_CharT>
2351 _M_localize(basic_string_view<_CharT> __str, char __expc,
2352 const locale& __loc) const
2353 {
2354 basic_string<_CharT> __lstr;
2355
2356 if (__loc == locale::classic())
2357 return __lstr; // Nothing to do.
2358
2359 const auto& __np = use_facet<numpunct<_CharT>>(__loc);
2360 const _CharT __point = __np.decimal_point();
2361 const string __grp = __np.grouping();
2362
2363 _CharT __dot, __exp;
2364 if constexpr (is_same_v<_CharT, char>)
2365 {
2366 __dot = '.';
2367 __exp = __expc;
2368 }
2369 else
2370 {
2371 __dot = L'.';
2372 switch (__expc)
2373 {
2374 case 'e':
2375 __exp = L'e';
2376 break;
2377 case 'E':
2378 __exp = L'E';
2379 break;
2380 case 'p':
2381 __exp = L'p';
2382 break;
2383 case 'P':
2384 __exp = L'P';
2385 break;
2386 default:
2387 __builtin_unreachable();
2388 }
2389 }
2390
2391 if (__grp.empty() && __point == __dot)
2392 return __lstr; // Locale uses '.' and no grouping.
2393
2394 size_t __d = __str.find(__dot); // Index of radix character (if any).
2395 size_t __e = min(__d, __str.find(__exp)); // First of radix or exponent
2396 if (__e == __str.npos)
2397 __e = __str.size();
2398 const size_t __r = __str.size() - __e; // Length of remainder.
2399 auto __overwrite = [&](_CharT* __p, size_t) {
2400 // Apply grouping to the digits before the radix or exponent.
2401 int __off = 0;
2402 if (auto __c = __str.front(); __c == '-' || __c == '+' || __c == ' ')
2403 {
2404 *__p = __c;
2405 __off = 1;
2406 }
2407 auto __end = std::__add_grouping(__p + __off, __np.thousands_sep(),
2408 __grp.data(), __grp.size(),
2409 __str.data() + __off,
2410 __str.data() + __e);
2411 if (__r) // If there's a fractional part or exponent
2412 {
2413 if (__d != __str.npos)
2414 {
2415 *__end = __point; // Add the locale's radix character.
2416 ++__end;
2417 ++__e;
2418 }
2419 const size_t __rlen = __str.size() - __e;
2420 // Append fractional digits and/or exponent:
2421 char_traits<_CharT>::copy(__end, __str.data() + __e, __rlen);
2422 __end += __rlen;
2423 }
2424 return (__end - __p);
2425 };
2426 __lstr.__resize_and_overwrite(__e * 2 + __r, __overwrite);
2427 return __lstr;
2428 }
2429
2430 _Spec<_CharT> _M_spec{};
2431 };
2432
2433 template<__format::__char _CharT>
2434 struct __formatter_ptr
2435 {
2436 constexpr
2437 __formatter_ptr() noexcept
2438 : _M_spec()
2439 {
2440 _M_spec._M_type = _Pres_p;
2441 _M_spec._M_alt = true;
2442 }
2443
2444 constexpr
2445 __formatter_ptr(_Spec<_CharT> __spec) noexcept
2446 : _M_spec(__spec)
2447 { _M_set_default(_Pres_p); }
2448
2449 constexpr typename basic_format_parse_context<_CharT>::iterator
2450 parse(basic_format_parse_context<_CharT>& __pc, _Pres_type __type = _Pres_p)
2451 {
2452 __format::_Spec<_CharT> __spec{};
2453 const auto __last = __pc.end();
2454 auto __first = __pc.begin();
2455
2456 auto __finalize = [this, &__spec, __type] {
2457 _M_spec = __spec;
2458 _M_set_default(__type);
2459 };
2460
2461 auto __finished = [&] {
2462 if (__first == __last || *__first == '}')
2463 {
2464 __finalize();
2465 return true;
2466 }
2467 return false;
2468 };
2469
2470 if (__finished())
2471 return __first;
2472
2473 __first = __spec._M_parse_fill_and_align(__first, __last);
2474 if (__finished())
2475 return __first;
2476
2477// _GLIBCXX_RESOLVE_LIB_DEFECTS
2478// P2510R3 Formatting pointers
2479#if __glibcxx_format >= 202304L
2480 __first = __spec._M_parse_zero_fill(__first, __last);
2481 if (__finished())
2482 return __first;
2483#endif
2484
2485 __first = __spec._M_parse_width(__first, __last, __pc);
2486 if (__finished())
2487 return __first;
2488
2489 if (*__first == 'p')
2490 {
2491 __spec._M_type = _Pres_p;
2492 __spec._M_alt = !__spec._M_alt;
2493 ++__first;
2494 }
2495#if __glibcxx_format >= 202304L
2496 else if (*__first == 'P')
2497 {
2498 __spec._M_type = _Pres_P;
2499 __spec._M_alt = !__spec._M_alt;
2500 ++__first;
2501 }
2502#endif
2503
2504 if (__finished())
2505 return __first;
2506
2507 __format::__failed_to_parse_format_spec();
2508 }
2509
2510 template<typename _Out>
2511 typename basic_format_context<_Out, _CharT>::iterator
2512 format(const void* __v, basic_format_context<_Out, _CharT>& __fc) const
2513 {
2514 auto __u = reinterpret_cast<__UINTPTR_TYPE__>(__v);
2515 return __formatter_int<_CharT>(_M_spec).format(__u, __fc);
2516 }
2517
2518 private:
2519 [[__gnu__::__always_inline__]]
2520 constexpr void
2521 _M_set_default(_Pres_type __type)
2522 {
2523 if (_M_spec._M_type == _Pres_none && __type != _Pres_none)
2524 {
2525 _M_spec._M_type = __type;
2526 _M_spec._M_alt = !_M_spec._M_alt;
2527 }
2528 }
2529
2530 __format::_Spec<_CharT> _M_spec;
2531 };
2532
2533} // namespace __format
2534/// @endcond
2535
2536 /// Format a character.
2537 template<__format::__char _CharT>
2538 struct formatter<_CharT, _CharT>
2539 {
2540 formatter() = default;
2541
2542 constexpr typename basic_format_parse_context<_CharT>::iterator
2543 parse(basic_format_parse_context<_CharT>& __pc)
2544 {
2545 return _M_f.template _M_parse<_CharT>(__pc);
2546 }
2547
2548 template<typename _Out>
2549 typename basic_format_context<_Out, _CharT>::iterator
2550 format(_CharT __u, basic_format_context<_Out, _CharT>& __fc) const
2551 {
2552 if (_M_f._M_spec._M_type == __format::_Pres_c)
2553 return _M_f._M_format_character(__u, __fc);
2554 else
2555 return _M_f.format(static_cast<make_unsigned_t<_CharT>>(__u), __fc);
2556 }
2557
2558#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
2559 constexpr void
2560 set_debug_format() noexcept
2561 { _M_f._M_spec._M_debug = true; }
2562#endif
2563
2564 private:
2565 __format::__formatter_int<_CharT> _M_f;
2566 };
2567
2568#if __glibcxx_print >= 202403L
2569 template<__format::__char _CharT>
2570 constexpr bool enable_nonlocking_formatter_optimization<_CharT> = true;
2571#endif
2572
2573#ifdef _GLIBCXX_USE_WCHAR_T
2574 /// Format a char value for wide character output.
2575 template<>
2576 struct formatter<char, wchar_t>
2577 {
2578 formatter() = default;
2579
2580 constexpr typename basic_format_parse_context<wchar_t>::iterator
2581 parse(basic_format_parse_context<wchar_t>& __pc)
2582 {
2583 return _M_f._M_parse<char>(__pc);
2584 }
2585
2586 template<typename _Out>
2587 typename basic_format_context<_Out, wchar_t>::iterator
2588 format(char __u, basic_format_context<_Out, wchar_t>& __fc) const
2589 {
2590 if (_M_f._M_spec._M_type == __format::_Pres_c)
2591 return _M_f._M_format_character(__u, __fc);
2592 else
2593 return _M_f.format(static_cast<unsigned char>(__u), __fc);
2594 }
2595
2596#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
2597 constexpr void
2598 set_debug_format() noexcept
2599 { _M_f._M_spec._M_debug = true; }
2600#endif
2601
2602 private:
2603 __format::__formatter_int<wchar_t> _M_f;
2604 };
2605#endif // USE_WCHAR_T
2606
2607 /** Format a string.
2608 * @{
2609 */
2610 template<__format::__char _CharT>
2611 struct formatter<_CharT*, _CharT>
2612 {
2613 formatter() = default;
2614
2615 [[__gnu__::__always_inline__]]
2616 constexpr typename basic_format_parse_context<_CharT>::iterator
2617 parse(basic_format_parse_context<_CharT>& __pc)
2618 { return _M_f.parse(__pc); }
2619
2620 template<typename _Out>
2621 [[__gnu__::__nonnull__]]
2622 typename basic_format_context<_Out, _CharT>::iterator
2623 format(_CharT* __u, basic_format_context<_Out, _CharT>& __fc) const
2624 { return _M_f.format(__u, __fc); }
2625
2626#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
2627 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2628#endif
2629
2630 private:
2631 __format::__formatter_str<_CharT> _M_f;
2632 };
2633
2634#if __glibcxx_print >= 202403L
2635 template<__format::__char _CharT>
2636 constexpr bool enable_nonlocking_formatter_optimization<_CharT*> = true;
2637#endif
2638
2639 template<__format::__char _CharT>
2640 struct formatter<const _CharT*, _CharT>
2641 {
2642 formatter() = default;
2643
2644 [[__gnu__::__always_inline__]]
2645 constexpr typename basic_format_parse_context<_CharT>::iterator
2646 parse(basic_format_parse_context<_CharT>& __pc)
2647 { return _M_f.parse(__pc); }
2648
2649 template<typename _Out>
2650 [[__gnu__::__nonnull__]]
2651 typename basic_format_context<_Out, _CharT>::iterator
2652 format(const _CharT* __u,
2653 basic_format_context<_Out, _CharT>& __fc) const
2654 { return _M_f.format(__u, __fc); }
2655
2656#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
2657 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2658#endif
2659
2660 private:
2661 __format::__formatter_str<_CharT> _M_f;
2662 };
2663
2664#if __glibcxx_print >= 202403L
2665 template<__format::__char _CharT>
2666 constexpr bool
2667 enable_nonlocking_formatter_optimization<const _CharT*> = true;
2668#endif
2669
2670 template<__format::__char _CharT, size_t _Nm>
2671 struct formatter<_CharT[_Nm], _CharT>
2672 {
2673 formatter() = default;
2674
2675 [[__gnu__::__always_inline__]]
2676 constexpr typename basic_format_parse_context<_CharT>::iterator
2677 parse(basic_format_parse_context<_CharT>& __pc)
2678 { return _M_f.parse(__pc); }
2679
2680 template<typename _Out>
2681 typename basic_format_context<_Out, _CharT>::iterator
2682 format(const _CharT (&__u)[_Nm],
2683 basic_format_context<_Out, _CharT>& __fc) const
2684 { return _M_f.format({__u, _Nm}, __fc); }
2685
2686#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
2687 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2688#endif
2689
2690 private:
2691 __format::__formatter_str<_CharT> _M_f;
2692 };
2693
2694#if __glibcxx_print >= 202403L
2695 template<__format::__char _CharT, size_t _Nm>
2696 constexpr bool enable_nonlocking_formatter_optimization<_CharT[_Nm]> = true;
2697#endif
2698
2699 template<typename _Traits, typename _Alloc>
2700 struct formatter<basic_string<char, _Traits, _Alloc>, char>
2701 {
2702 formatter() = default;
2703
2704 [[__gnu__::__always_inline__]]
2705 constexpr typename basic_format_parse_context<char>::iterator
2706 parse(basic_format_parse_context<char>& __pc)
2707 { return _M_f.parse(__pc); }
2708
2709 template<typename _Out>
2710 typename basic_format_context<_Out, char>::iterator
2711 format(const basic_string<char, _Traits, _Alloc>& __u,
2712 basic_format_context<_Out, char>& __fc) const
2713 { return _M_f.format(__u, __fc); }
2714
2715#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
2716 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2717#endif
2718
2719 private:
2720 __format::__formatter_str<char> _M_f;
2721 };
2722
2723#if __glibcxx_print >= 202403L
2724 template<typename _Tr, typename _Alloc>
2725 constexpr bool
2726 enable_nonlocking_formatter_optimization<basic_string<char, _Tr, _Alloc>>
2727 = true;
2728#endif
2729
2730#ifdef _GLIBCXX_USE_WCHAR_T
2731 template<typename _Traits, typename _Alloc>
2732 struct formatter<basic_string<wchar_t, _Traits, _Alloc>, wchar_t>
2733 {
2734 formatter() = default;
2735
2736 [[__gnu__::__always_inline__]]
2737 constexpr typename basic_format_parse_context<wchar_t>::iterator
2738 parse(basic_format_parse_context<wchar_t>& __pc)
2739 { return _M_f.parse(__pc); }
2740
2741 template<typename _Out>
2742 typename basic_format_context<_Out, wchar_t>::iterator
2743 format(const basic_string<wchar_t, _Traits, _Alloc>& __u,
2744 basic_format_context<_Out, wchar_t>& __fc) const
2745 { return _M_f.format(__u, __fc); }
2746
2747#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
2748 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2749#endif
2750
2751 private:
2752 __format::__formatter_str<wchar_t> _M_f;
2753 };
2754
2755#if __glibcxx_print >= 202403L
2756 template<typename _Tr, typename _Alloc>
2757 constexpr bool
2758 enable_nonlocking_formatter_optimization<basic_string<wchar_t, _Tr, _Alloc>>
2759 = true;
2760#endif
2761
2762#endif // USE_WCHAR_T
2763
2764 template<typename _Traits>
2765 struct formatter<basic_string_view<char, _Traits>, char>
2766 {
2767 formatter() = default;
2768
2769 [[__gnu__::__always_inline__]]
2770 constexpr typename basic_format_parse_context<char>::iterator
2771 parse(basic_format_parse_context<char>& __pc)
2772 { return _M_f.parse(__pc); }
2773
2774 template<typename _Out>
2775 typename basic_format_context<_Out, char>::iterator
2776 format(basic_string_view<char, _Traits> __u,
2777 basic_format_context<_Out, char>& __fc) const
2778 { return _M_f.format(__u, __fc); }
2779
2780#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
2781 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2782#endif
2783
2784 private:
2785 __format::__formatter_str<char> _M_f;
2786 };
2787
2788#if __glibcxx_print >= 202403L
2789 template<typename _Tr>
2790 constexpr bool
2791 enable_nonlocking_formatter_optimization<basic_string_view<char, _Tr>>
2792 = true;
2793#endif
2794
2795#ifdef _GLIBCXX_USE_WCHAR_T
2796 template<typename _Traits>
2797 struct formatter<basic_string_view<wchar_t, _Traits>, wchar_t>
2798 {
2799 formatter() = default;
2800
2801 [[__gnu__::__always_inline__]]
2802 constexpr typename basic_format_parse_context<wchar_t>::iterator
2803 parse(basic_format_parse_context<wchar_t>& __pc)
2804 { return _M_f.parse(__pc); }
2805
2806 template<typename _Out>
2807 typename basic_format_context<_Out, wchar_t>::iterator
2808 format(basic_string_view<wchar_t, _Traits> __u,
2809 basic_format_context<_Out, wchar_t>& __fc) const
2810 { return _M_f.format(__u, __fc); }
2811
2812#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
2813 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2814#endif
2815
2816 private:
2817 __format::__formatter_str<wchar_t> _M_f;
2818 };
2819
2820#if __glibcxx_print >= 202403L
2821 template<typename _Tr>
2822 constexpr bool
2823 enable_nonlocking_formatter_optimization<basic_string_view<wchar_t, _Tr>>
2824 = true;
2825#endif
2826#endif // USE_WCHAR_T
2827 /// @}
2828
2829/// @cond undocumented
2830namespace __format
2831{
2832 // each cv-unqualified arithmetic type ArithmeticT other than
2833 // char, wchar_t, char8_t, char16_t, or char32_t
2834 template<typename _Tp>
2835 constexpr bool __is_formattable_integer = __is_integer<_Tp>::__value;
2836
2837#if defined __SIZEOF_INT128__
2838 template<> inline constexpr bool __is_formattable_integer<__int128> = true;
2839 template<> inline constexpr bool __is_formattable_integer<unsigned __int128>
2840 = true;
2841#endif
2842
2843 template<> inline constexpr bool __is_formattable_integer<char> = false;
2844 template<> inline constexpr bool __is_formattable_integer<wchar_t> = false;
2845#ifdef _GLIBCXX_USE_CHAR8_T
2846 template<> inline constexpr bool __is_formattable_integer<char8_t> = false;
2847#endif
2848 template<> inline constexpr bool __is_formattable_integer<char16_t> = false;
2849 template<> inline constexpr bool __is_formattable_integer<char32_t> = false;
2850
2851 template<typename _Tp>
2852 concept __formattable_integer = __is_formattable_integer<_Tp>;
2853}
2854/// @endcond
2855
2856 /// Format an integer.
2857 template<__format::__formattable_integer _Tp, __format::__char _CharT>
2858 struct formatter<_Tp, _CharT>
2859 {
2860 formatter() = default;
2861
2862 [[__gnu__::__always_inline__]]
2863 constexpr typename basic_format_parse_context<_CharT>::iterator
2864 parse(basic_format_parse_context<_CharT>& __pc)
2865 {
2866 return _M_f.template _M_parse<_Tp>(__pc);
2867 }
2868
2869 template<typename _Out>
2870 typename basic_format_context<_Out, _CharT>::iterator
2871 format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
2872 { return _M_f.format(__u, __fc); }
2873
2874 private:
2875 __format::__formatter_int<_CharT> _M_f;
2876 };
2877
2878#if __glibcxx_print >= 202403L
2879 template<__format::__formattable_integer _Tp>
2880 constexpr bool
2881 enable_nonlocking_formatter_optimization<_Tp> = true;
2882#endif
2883
2884#if defined __glibcxx_to_chars
2885 /// Format a floating-point value.
2886 template<__format::__formattable_float _Tp, __format::__char _CharT>
2887 struct formatter<_Tp, _CharT>
2888 {
2889 formatter() = default;
2890
2891 [[__gnu__::__always_inline__]]
2892 constexpr typename basic_format_parse_context<_CharT>::iterator
2893 parse(basic_format_parse_context<_CharT>& __pc)
2894 { return _M_f.parse(__pc); }
2895
2896 template<typename _Out>
2897 typename basic_format_context<_Out, _CharT>::iterator
2898 format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
2899 { return _M_f.format(__u, __fc); }
2900
2901 private:
2902 __format::__formatter_fp<_CharT> _M_f;
2903 };
2904
2905#if __glibcxx_print >= 202403L
2906 template<__format::__formattable_float _Tp>
2907 constexpr bool
2908 enable_nonlocking_formatter_optimization<_Tp> = true;
2909#endif
2910
2911#if __LDBL_MANT_DIG__ == __DBL_MANT_DIG__
2912 // Reuse __formatter_fp<C>::format<double, Out> for long double.
2913 template<__format::__char _CharT>
2914 struct formatter<long double, _CharT>
2915 {
2916 formatter() = default;
2917
2918 [[__gnu__::__always_inline__]]
2919 constexpr typename basic_format_parse_context<_CharT>::iterator
2920 parse(basic_format_parse_context<_CharT>& __pc)
2921 { return _M_f.parse(__pc); }
2922
2923 template<typename _Out>
2924 typename basic_format_context<_Out, _CharT>::iterator
2925 format(long double __u, basic_format_context<_Out, _CharT>& __fc) const
2926 { return _M_f.format((double)__u, __fc); }
2927
2928 private:
2929 __format::__formatter_fp<_CharT> _M_f;
2930 };
2931#endif
2932
2933#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2934 // Reuse __formatter_fp<C>::format<float, Out> for _Float16.
2935 template<__format::__char _CharT>
2936 struct formatter<_Float16, _CharT>
2937 {
2938 formatter() = default;
2939
2940 [[__gnu__::__always_inline__]]
2941 constexpr typename basic_format_parse_context<_CharT>::iterator
2942 parse(basic_format_parse_context<_CharT>& __pc)
2943 { return _M_f.parse(__pc); }
2944
2945 template<typename _Out>
2946 typename basic_format_context<_Out, _CharT>::iterator
2947 format(_Float16 __u, basic_format_context<_Out, _CharT>& __fc) const
2948 { return _M_f.format((float)__u, __fc); }
2949
2950 private:
2951 __format::__formatter_fp<_CharT> _M_f;
2952 };
2953#endif
2954
2955#if defined(__FLT32_DIG__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2956 // Reuse __formatter_fp<C>::format<float, Out> for _Float32.
2957 template<__format::__char _CharT>
2958 struct formatter<_Float32, _CharT>
2959 {
2960 formatter() = default;
2961
2962 [[__gnu__::__always_inline__]]
2963 constexpr typename basic_format_parse_context<_CharT>::iterator
2964 parse(basic_format_parse_context<_CharT>& __pc)
2965 { return _M_f.parse(__pc); }
2966
2967 template<typename _Out>
2968 typename basic_format_context<_Out, _CharT>::iterator
2969 format(_Float32 __u, basic_format_context<_Out, _CharT>& __fc) const
2970 { return _M_f.format((float)__u, __fc); }
2971
2972 private:
2973 __format::__formatter_fp<_CharT> _M_f;
2974 };
2975#endif
2976
2977#if defined(__FLT64_DIG__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2978 // Reuse __formatter_fp<C>::format<double, Out> for _Float64.
2979 template<__format::__char _CharT>
2980 struct formatter<_Float64, _CharT>
2981 {
2982 formatter() = default;
2983
2984 [[__gnu__::__always_inline__]]
2985 constexpr typename basic_format_parse_context<_CharT>::iterator
2986 parse(basic_format_parse_context<_CharT>& __pc)
2987 { return _M_f.parse(__pc); }
2988
2989 template<typename _Out>
2990 typename basic_format_context<_Out, _CharT>::iterator
2991 format(_Float64 __u, basic_format_context<_Out, _CharT>& __fc) const
2992 { return _M_f.format((double)__u, __fc); }
2993
2994 private:
2995 __format::__formatter_fp<_CharT> _M_f;
2996 };
2997#endif
2998
2999#if defined(__FLT128_DIG__) && _GLIBCXX_FORMAT_F128
3000 // Use __formatter_fp<C>::format<__format::__flt128_t, Out> for _Float128.
3001 template<__format::__char _CharT>
3002 struct formatter<_Float128, _CharT>
3003 {
3004 formatter() = default;
3005
3006 [[__gnu__::__always_inline__]]
3007 constexpr typename basic_format_parse_context<_CharT>::iterator
3008 parse(basic_format_parse_context<_CharT>& __pc)
3009 { return _M_f.parse(__pc); }
3010
3011 template<typename _Out>
3012 typename basic_format_context<_Out, _CharT>::iterator
3013 format(_Float128 __u, basic_format_context<_Out, _CharT>& __fc) const
3014 { return _M_f.format((__format::__flt128_t)__u, __fc); }
3015
3016 private:
3017 __format::__formatter_fp<_CharT> _M_f;
3018 };
3019#endif
3020
3021#if defined(__SIZEOF_FLOAT128__) && _GLIBCXX_FORMAT_F128 == 2
3022 // Use __formatter_fp<C>::format<__format::__flt128_t, Out> for __float128,
3023 // when long double is not 128bit IEEE type.
3024 template<__format::__char _CharT>
3025 struct formatter<__float128, _CharT>
3026 {
3027 formatter() = default;
3028
3029 [[__gnu__::__always_inline__]]
3030 constexpr typename basic_format_parse_context<_CharT>::iterator
3031 parse(basic_format_parse_context<_CharT>& __pc)
3032 { return _M_f.parse(__pc); }
3033
3034 template<typename _Out>
3035 typename basic_format_context<_Out, _CharT>::iterator
3036 format(__float128 __u, basic_format_context<_Out, _CharT>& __fc) const
3037 { return _M_f.format((__format::__flt128_t)__u, __fc); }
3038
3039 private:
3040 __format::__formatter_fp<_CharT> _M_f;
3041 };
3042#endif
3043
3044#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3045 // Reuse __formatter_fp<C>::format<float, Out> for bfloat16_t.
3046 template<__format::__char _CharT>
3047 struct formatter<__format::__bflt16_t, _CharT>
3048 {
3049 formatter() = default;
3050
3051 [[__gnu__::__always_inline__]]
3052 constexpr typename basic_format_parse_context<_CharT>::iterator
3053 parse(basic_format_parse_context<_CharT>& __pc)
3054 { return _M_f.parse(__pc); }
3055
3056 template<typename _Out>
3057 typename basic_format_context<_Out, _CharT>::iterator
3058 format(__gnu_cxx::__bfloat16_t __u,
3059 basic_format_context<_Out, _CharT>& __fc) const
3060 { return _M_f.format((float)__u, __fc); }
3061
3062 private:
3063 __format::__formatter_fp<_CharT> _M_f;
3064 };
3065#endif
3066#endif // __cpp_lib_to_chars
3067
3068 /** Format a pointer.
3069 * @{
3070 */
3071 template<__format::__char _CharT>
3072 struct formatter<const void*, _CharT>
3073 {
3074 formatter() = default;
3075
3076 constexpr typename basic_format_parse_context<_CharT>::iterator
3077 parse(basic_format_parse_context<_CharT>& __pc)
3078 { return _M_f.parse(__pc); }
3079
3080 template<typename _Out>
3081 typename basic_format_context<_Out, _CharT>::iterator
3082 format(const void* __v, basic_format_context<_Out, _CharT>& __fc) const
3083 { return _M_f.format(__v, __fc); }
3084
3085 private:
3086 __format::__formatter_ptr<_CharT> _M_f;
3087 };
3088
3089#if __glibcxx_print >= 202403L
3090 template<>
3091 inline constexpr bool
3092 enable_nonlocking_formatter_optimization<const void*> = true;
3093#endif
3094
3095 template<__format::__char _CharT>
3096 struct formatter<void*, _CharT>
3097 {
3098 formatter() = default;
3099
3100 [[__gnu__::__always_inline__]]
3101 constexpr typename basic_format_parse_context<_CharT>::iterator
3102 parse(basic_format_parse_context<_CharT>& __pc)
3103 { return _M_f.parse(__pc); }
3104
3105 template<typename _Out>
3106 typename basic_format_context<_Out, _CharT>::iterator
3107 format(void* __v, basic_format_context<_Out, _CharT>& __fc) const
3108 { return _M_f.format(__v, __fc); }
3109
3110 private:
3111 __format::__formatter_ptr<_CharT> _M_f;
3112 };
3113
3114#if __glibcxx_print >= 202403l
3115 template<>
3116 inline constexpr bool
3117 enable_nonlocking_formatter_optimization<void*> = true;
3118#endif
3119
3120 template<__format::__char _CharT>
3121 struct formatter<nullptr_t, _CharT>
3122 {
3123 formatter() = default;
3124
3125 [[__gnu__::__always_inline__]]
3126 constexpr typename basic_format_parse_context<_CharT>::iterator
3127 parse(basic_format_parse_context<_CharT>& __pc)
3128 { return _M_f.parse(__pc); }
3129
3130 template<typename _Out>
3131 typename basic_format_context<_Out, _CharT>::iterator
3132 format(nullptr_t, basic_format_context<_Out, _CharT>& __fc) const
3133 { return _M_f.format(nullptr, __fc); }
3134
3135 private:
3136 __format::__formatter_ptr<_CharT> _M_f;
3137 };
3138 /// @}
3139
3140#if __glibcxx_print >= 202403L
3141 template<>
3142 inline constexpr bool
3143 enable_nonlocking_formatter_optimization<nullptr_t> = true;
3144#endif
3145
3146#if defined _GLIBCXX_USE_WCHAR_T && __glibcxx_format_ranges
3147 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3148 // 3944. Formatters converting sequences of char to sequences of wchar_t
3149
3150 struct __formatter_disabled
3151 {
3152 __formatter_disabled() = delete; // Cannot format char sequence to wchar_t
3153 __formatter_disabled(const __formatter_disabled&) = delete;
3154 __formatter_disabled& operator=(const __formatter_disabled&) = delete;
3155 };
3156
3157 template<>
3158 struct formatter<char*, wchar_t>
3159 : private __formatter_disabled { };
3160 template<>
3161 struct formatter<const char*, wchar_t>
3162 : private __formatter_disabled { };
3163 template<size_t _Nm>
3164 struct formatter<char[_Nm], wchar_t>
3165 : private __formatter_disabled { };
3166 template<class _Traits, class _Allocator>
3167 struct formatter<basic_string<char, _Traits, _Allocator>, wchar_t>
3168 : private __formatter_disabled { };
3169 template<class _Traits>
3170 struct formatter<basic_string_view<char, _Traits>, wchar_t>
3171 : private __formatter_disabled { };
3172#endif
3173
3174 /// An iterator after the last character written, and the number of
3175 /// characters that would have been written.
3176 template<typename _Out>
3177 struct format_to_n_result
3178 {
3179 _Out out;
3180 iter_difference_t<_Out> size;
3181 };
3182
3183_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
3184template<typename, typename> class vector;
3185_GLIBCXX_END_NAMESPACE_CONTAINER
3186
3187/// @cond undocumented
3188namespace __format
3189{
3190 template<typename _CharT>
3191 class _Drop_iter
3192 {
3193 public:
3194 using iterator_category = output_iterator_tag;
3195 using value_type = void;
3196 using difference_type = ptrdiff_t;
3197 using pointer = void;
3198 using reference = void;
3199
3200 _Drop_iter() = default;
3201 _Drop_iter(const _Drop_iter&) = default;
3202 _Drop_iter& operator=(const _Drop_iter&) = default;
3203
3204 [[__gnu__::__always_inline__]]
3205 constexpr _Drop_iter&
3206 operator=(_CharT __c)
3207 { return *this; }
3208
3209 [[__gnu__::__always_inline__]]
3210 constexpr _Drop_iter&
3211 operator=(basic_string_view<_CharT> __s)
3212 { return *this; }
3213
3214 [[__gnu__::__always_inline__]]
3215 constexpr _Drop_iter&
3216 operator*() { return *this; }
3217
3218 [[__gnu__::__always_inline__]]
3219 constexpr _Drop_iter&
3220 operator++() { return *this; }
3221
3222 [[__gnu__::__always_inline__]]
3223 constexpr _Drop_iter
3224 operator++(int) { return *this; }
3225 };
3226
3227 template<typename _CharT>
3228 class _Sink_iter
3229 {
3230 _Sink<_CharT>* _M_sink = nullptr;
3231
3232 public:
3233 using iterator_category = output_iterator_tag;
3234 using value_type = void;
3235 using difference_type = ptrdiff_t;
3236 using pointer = void;
3237 using reference = void;
3238
3239 _Sink_iter() = default;
3240 _Sink_iter(const _Sink_iter&) = default;
3241 _Sink_iter& operator=(const _Sink_iter&) = default;
3242
3243 [[__gnu__::__always_inline__]]
3244 explicit constexpr
3245 _Sink_iter(_Sink<_CharT>& __sink) : _M_sink(std::addressof(__sink)) { }
3246
3247 [[__gnu__::__always_inline__]]
3248 constexpr _Sink_iter&
3249 operator=(_CharT __c)
3250 {
3251 _M_sink->_M_write(__c);
3252 return *this;
3253 }
3254
3255 [[__gnu__::__always_inline__]]
3256 constexpr _Sink_iter&
3257 operator=(basic_string_view<_CharT> __s)
3258 {
3259 _M_sink->_M_write(__s);
3260 return *this;
3261 }
3262
3263 [[__gnu__::__always_inline__]]
3264 constexpr _Sink_iter&
3265 operator*() { return *this; }
3266
3267 [[__gnu__::__always_inline__]]
3268 constexpr _Sink_iter&
3269 operator++() { return *this; }
3270
3271 [[__gnu__::__always_inline__]]
3272 constexpr _Sink_iter
3273 operator++(int) { return *this; }
3274
3275 auto
3276 _M_reserve(size_t __n) const
3277 { return _M_sink->_M_reserve(__n); }
3278
3279 bool
3280 _M_discarding() const
3281 { return _M_sink->_M_discarding(); }
3282 };
3283
3284 // Abstract base class for type-erased character sinks.
3285 // All formatting and output is done via this type's iterator,
3286 // to reduce the number of different template instantiations.
3287 template<typename _CharT>
3288 class _Sink
3289 {
3290 friend class _Sink_iter<_CharT>;
3291
3292 span<_CharT> _M_span;
3293 typename span<_CharT>::iterator _M_next;
3294
3295 // Called when the span is full, to make more space available.
3296 // Precondition: _M_next != _M_span.begin()
3297 // Postcondition: _M_next != _M_span.end()
3298 // TODO: remove the precondition? could make overflow handle it.
3299 virtual void _M_overflow() = 0;
3300
3301 protected:
3302 // Precondition: __span.size() != 0
3303 [[__gnu__::__always_inline__]]
3304 explicit constexpr
3305 _Sink(span<_CharT> __span) noexcept
3306 : _M_span(__span), _M_next(__span.begin())
3307 { }
3308
3309 // The portion of the span that has been written to.
3310 [[__gnu__::__always_inline__]]
3311 span<_CharT>
3312 _M_used() const noexcept
3313 { return _M_span.first(_M_next - _M_span.begin()); }
3314
3315 // The portion of the span that has not been written to.
3316 [[__gnu__::__always_inline__]]
3317 constexpr span<_CharT>
3318 _M_unused() const noexcept
3319 { return _M_span.subspan(_M_next - _M_span.begin()); }
3320
3321 // Use the start of the span as the next write position.
3322 [[__gnu__::__always_inline__]]
3323 constexpr void
3324 _M_rewind() noexcept
3325 { _M_next = _M_span.begin(); }
3326
3327 // Replace the current output range.
3328 void
3329 _M_reset(span<_CharT> __s, size_t __pos = 0) noexcept
3330 {
3331 _M_span = __s;
3332 _M_next = __s.begin() + __pos;
3333 }
3334
3335 // Called by the iterator for *it++ = c
3336 constexpr void
3337 _M_write(_CharT __c)
3338 {
3339 *_M_next++ = __c;
3340 if (_M_next - _M_span.begin() == std::ssize(_M_span)) [[unlikely]]
3341 _M_overflow();
3342 }
3343
3344 constexpr void
3345 _M_write(basic_string_view<_CharT> __s)
3346 {
3347 span __to = _M_unused();
3348 while (__to.size() <= __s.size())
3349 {
3350 __s.copy(__to.data(), __to.size());
3351 _M_next += __to.size();
3352 __s.remove_prefix(__to.size());
3353 _M_overflow();
3354 __to = _M_unused();
3355 }
3356 if (__s.size())
3357 {
3358 __s.copy(__to.data(), __s.size());
3359 _M_next += __s.size();
3360 }
3361 }
3362
3363 // A successful _Reservation can be used to directly write
3364 // up to N characters to the sink to avoid unwanted buffering.
3365 struct _Reservation
3366 {
3367 // True if the reservation was successful, false otherwise.
3368 explicit operator bool() const noexcept { return _M_sink; }
3369 // A pointer to write directly to the sink.
3370 _CharT* get() const noexcept { return _M_sink->_M_next.operator->(); }
3371 // Add n to the _M_next iterator for the sink.
3372 void _M_bump(size_t __n) { _M_sink->_M_bump(__n); }
3373 _Sink* _M_sink;
3374 };
3375
3376 // Attempt to reserve space to write n characters to the sink.
3377 // If anything is written to the reservation then there must be a call
3378 // to _M_bump(N2) before any call to another member function of *this,
3379 // where N2 is the number of characters written.
3380 virtual _Reservation
3381 _M_reserve(size_t __n)
3382 {
3383 if (__n <= _M_unused().size())
3384 return { this };
3385
3386 if (__n <= _M_span.size()) // Cannot meet the request.
3387 {
3388 _M_overflow(); // Make more space available.
3389 if (__n <= _M_unused().size())
3390 return { this };
3391 }
3392 return { nullptr };
3393 }
3394
3395 // Update the next output position after writing directly to the sink.
3396 // pre: no calls to _M_write or _M_overflow since _M_reserve.
3397 virtual void
3398 _M_bump(size_t __n)
3399 { _M_next += __n; }
3400
3401 // Returns true if the _Sink is discarding incoming characters.
3402 virtual bool
3403 _M_discarding() const
3404 { return false; }
3405
3406 public:
3407 _Sink(const _Sink&) = delete;
3408 _Sink& operator=(const _Sink&) = delete;
3409
3410 [[__gnu__::__always_inline__]]
3411 constexpr _Sink_iter<_CharT>
3412 out() noexcept
3413 { return _Sink_iter<_CharT>(*this); }
3414 };
3415
3416
3417 template<typename _CharT>
3418 class _Fixedbuf_sink final : public _Sink<_CharT>
3419 {
3420 void
3421 _M_overflow() override
3422 {
3423 __glibcxx_assert(false);
3424 this->_M_rewind();
3425 }
3426
3427 public:
3428 [[__gnu__::__always_inline__]]
3429 constexpr explicit
3430 _Fixedbuf_sink(span<_CharT> __buf)
3431 : _Sink<_CharT>(__buf)
3432 { }
3433
3434 constexpr basic_string_view<_CharT>
3435 view() const
3436 {
3437 auto __s = this->_M_used();
3438 return basic_string_view<_CharT>(__s.data(), __s.size());
3439 }
3440 };
3441
3442 // A sink with an internal buffer. This is used to implement concrete sinks.
3443 template<typename _CharT>
3444 class _Buf_sink : public _Sink<_CharT>
3445 {
3446 protected:
3447 _CharT _M_buf[__stackbuf_size<_CharT>];
3448
3449 [[__gnu__::__always_inline__]]
3450 constexpr
3451 _Buf_sink() noexcept
3452 : _Sink<_CharT>(_M_buf)
3453 { }
3454 };
3455
3456 using _GLIBCXX_STD_C::vector;
3457
3458 // A sink that fills a sequence (e.g. std::string, std::vector, std::deque).
3459 // Writes to a buffer then appends that to the sequence when it fills up.
3460 template<typename _Seq>
3461 class _Seq_sink : public _Buf_sink<typename _Seq::value_type>
3462 {
3463 using _CharT = typename _Seq::value_type;
3464
3465 _Seq _M_seq;
3466 protected:
3467 // Transfer buffer contents to the sequence, so buffer can be refilled.
3468 void
3469 _M_overflow() override
3470 {
3471 auto __s = this->_M_used();
3472 if (__s.empty()) [[unlikely]]
3473 return; // Nothing in the buffer to transfer to _M_seq.
3474
3475 // If _M_reserve was called then _M_bump must have been called too.
3476 _GLIBCXX_DEBUG_ASSERT(__s.data() != _M_seq.data());
3477
3478 if constexpr (__is_specialization_of<_Seq, basic_string>)
3479 _M_seq.append(__s.data(), __s.size());
3480 else
3481 _M_seq.insert(_M_seq.end(), __s.begin(), __s.end());
3482
3483 // Make the whole of _M_buf available for the next write:
3484 this->_M_rewind();
3485 }
3486
3487 typename _Sink<_CharT>::_Reservation
3488 _M_reserve(size_t __n) override
3489 {
3490 // We might already have n characters available in this->_M_unused(),
3491 // but the whole point of this function is to be an optimization for
3492 // the std::format("{}", x) case. We want to avoid writing to _M_buf
3493 // and then copying that into a basic_string if possible, so this
3494 // function prefers to create space directly in _M_seq rather than
3495 // using _M_buf.
3496
3497 if constexpr (__is_specialization_of<_Seq, basic_string>
3498 || __is_specialization_of<_Seq, vector>)
3499 {
3500 // Flush the buffer to _M_seq first (should not be needed).
3501 if (this->_M_used().size()) [[unlikely]]
3502 _Seq_sink::_M_overflow();
3503
3504 // Expand _M_seq to make __n new characters available:
3505 const auto __sz = _M_seq.size();
3506 if constexpr (is_same_v<string, _Seq> || is_same_v<wstring, _Seq>)
3507 _M_seq.__resize_and_overwrite(__sz + __n,
3508 [](auto, auto __n2) {
3509 return __n2;
3510 });
3511 else
3512 _M_seq.resize(__sz + __n);
3513
3514 // Set _M_used() to be a span over the original part of _M_seq
3515 // and _M_unused() to be the extra capacity we just created:
3516 this->_M_reset(_M_seq, __sz);
3517 return { this };
3518 }
3519 else // Try to use the base class' buffer.
3520 return _Sink<_CharT>::_M_reserve(__n);
3521 }
3522
3523 void
3524 _M_bump(size_t __n) override
3525 {
3526 if constexpr (__is_specialization_of<_Seq, basic_string>
3527 || __is_specialization_of<_Seq, vector>)
3528 {
3529 auto __s = this->_M_used();
3530 _GLIBCXX_DEBUG_ASSERT(__s.data() == _M_seq.data());
3531 // Truncate the sequence to the part that was actually written to:
3532 _M_seq.resize(__s.size() + __n);
3533 // Switch back to using buffer:
3534 this->_M_reset(this->_M_buf);
3535 }
3536 }
3537
3538 void _M_trim(span<const _CharT> __s)
3539 requires __is_specialization_of<_Seq, basic_string>
3540 {
3541 _GLIBCXX_DEBUG_ASSERT(__s.data() == this->_M_buf
3542 || __s.data() == _M_seq.data());
3543 if (__s.data() == _M_seq.data())
3544 _M_seq.resize(__s.size());
3545 else
3546 this->_M_reset(this->_M_buf, __s.size());
3547 }
3548
3549 public:
3550 // TODO: for SSO string, use SSO buffer as initial span, then switch
3551 // to _M_buf if it overflows? Or even do that for all unused capacity?
3552
3553 [[__gnu__::__always_inline__]]
3554 _Seq_sink() noexcept(is_nothrow_default_constructible_v<_Seq>)
3555 { }
3556
3557 _Seq_sink(_Seq&& __s) noexcept(is_nothrow_move_constructible_v<_Seq>)
3558 : _M_seq(std::move(__s))
3559 { }
3560
3561 using _Sink<_CharT>::out;
3562
3563 _Seq
3564 get() &&
3565 {
3566 if (this->_M_used().size() != 0)
3567 _Seq_sink::_M_overflow();
3568 return std::move(_M_seq);
3569 }
3570
3571 // A writable span that views everything written to the sink.
3572 // Will be either a view over _M_seq or the used part of _M_buf.
3573 span<_CharT>
3574 _M_span()
3575 {
3576 auto __s = this->_M_used();
3577 if (_M_seq.size())
3578 {
3579 if (__s.size() != 0)
3580 _Seq_sink::_M_overflow();
3581 return _M_seq;
3582 }
3583 return __s;
3584 }
3585
3586 basic_string_view<_CharT>
3587 view()
3588 {
3589 auto __span = _M_span();
3590 return basic_string_view<_CharT>(__span.data(), __span.size());
3591 }
3592 };
3593
3594 template<typename _CharT, typename _Alloc = allocator<_CharT>>
3595 using _Str_sink
3596 = _Seq_sink<basic_string<_CharT, char_traits<_CharT>, _Alloc>>;
3597
3598 // template<typename _CharT, typename _Alloc = allocator<_CharT>>
3599 // using _Vec_sink = _Seq_sink<vector<_CharTthis-> sink that writes to an output iterator.
3600 // Writes to a fixed-size buffer and then flushes to the output iterator
3601 // when the buffer fills up.
3602 template<typename _CharT, typename _OutIter>
3603 class _Iter_sink : public _Buf_sink<_CharT>
3604 {
3605 _OutIter _M_out;
3606 iter_difference_t<_OutIter> _M_max;
3607
3608 protected:
3609 size_t _M_count = 0;
3610
3611 void
3612 _M_overflow() override
3613 {
3614 auto __s = this->_M_used();
3615 if (_M_max < 0) // No maximum.
3616 _M_out = ranges::copy(__s, std::move(_M_out)).out;
3617 else if (_M_count < static_cast<size_t>(_M_max))
3618 {
3619 auto __max = _M_max - _M_count;
3620 span<_CharT> __first;
3621 if (__max < __s.size())
3622 __first = __s.first(static_cast<size_t>(__max));
3623 else
3624 __first = __s;
3625 _M_out = ranges::copy(__first, std::move(_M_out)).out;
3626 }
3627 this->_M_rewind();
3628 _M_count += __s.size();
3629 }
3630
3631 bool
3632 _M_discarding() const override
3633 {
3634 // format_to_n return total number of characters, that would be written,
3635 // see C++20 [format.functions] p20
3636 return false;
3637 }
3638
3639 public:
3640 [[__gnu__::__always_inline__]]
3641 explicit
3642 _Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __max = -1)
3643 : _M_out(std::move(__out)), _M_max(__max)
3644 { }
3645
3646 using _Sink<_CharT>::out;
3647
3648 format_to_n_result<_OutIter>
3649 _M_finish() &&
3650 {
3651 if (this->_M_used().size() != 0)
3652 _Iter_sink::_M_overflow();
3653 iter_difference_t<_OutIter> __count(_M_count);
3654 return { std::move(_M_out), __count };
3655 }
3656 };
3657
3658 // Used for contiguous iterators.
3659 // No buffer is used, characters are written straight to the iterator.
3660 // We do not know the size of the output range, so the span size just grows
3661 // as needed. The end of the span might be an invalid pointer outside the
3662 // valid range, but we never actually call _M_span.end(). This class does
3663 // not introduce any invalid pointer arithmetic or overflows that would not
3664 // have happened anyway.
3665 template<typename _CharT>
3666 class _Ptr_sink : public _Sink<_CharT>
3667 {
3668 static constexpr size_t _S_no_limit = size_t(-1);
3669
3670 size_t _M_max;
3671 protected:
3672 size_t _M_count = 0;
3673 private:
3674 _CharT _M_buf[64]; // Write here after outputting _M_max characters.
3675
3676 protected:
3677 void
3678 _M_overflow() override
3679 {
3680 if (this->_M_unused().size() != 0)
3681 return; // No need to switch to internal buffer yet.
3682
3683 auto __s = this->_M_used();
3684
3685 if (_M_max != _S_no_limit)
3686 {
3687 _M_count += __s.size();
3688 // Span was already sized for the maximum character count,
3689 // if it overflows then any further output must go to the
3690 // internal buffer, to be discarded.
3691 this->_M_reset(this->_M_buf);
3692 }
3693 else
3694 {
3695 // No maximum character count. Just extend the span to allow
3696 // writing more characters to it.
3697 _M_rebuf(__s.data(), __s.size() + 1024, __s.size());
3698 }
3699 }
3700
3701 bool
3702 _M_discarding() const override
3703 {
3704 // format_to_n return total number of characters, that would be written,
3705 // see C++20 [format.functions] p20
3706 return false;
3707 }
3708
3709 typename _Sink<_CharT>::_Reservation
3710 _M_reserve(size_t __n) final
3711 {
3712 auto __avail = this->_M_unused();
3713 if (__n > __avail.size())
3714 {
3715 if (_M_max != _S_no_limit)
3716 return {}; // cannot grow
3717
3718 auto __s = this->_M_used();
3719 _M_rebuf(__s.data(), __s.size() + __n, __s.size());
3720 }
3721 return { this };
3722 }
3723
3724 private:
3725 template<typename _IterDifference>
3726 static size_t
3727 _S_trim_max(_IterDifference __max)
3728 {
3729 if (__max < 0)
3730 return _S_no_limit;
3731 if constexpr (!is_integral_v<_IterDifference> || sizeof(__max) > sizeof(size_t))
3732 // __int128 or __detail::__max_diff_type
3733 if (_IterDifference((size_t)-1) < __max)
3734 return _S_no_limit;
3735 return size_t(__max);
3736 }
3737
3738 [[__gnu__::__always_inline__]]
3739 void
3740 _M_rebuf(_CharT* __ptr, size_t __total, size_t __inuse = 0)
3741 {
3742 std::span<_CharT> __span(__ptr, __total);
3743 this->_M_reset(__span, __inuse);
3744 }
3745
3746 public:
3747 explicit
3748 _Ptr_sink(_CharT* __ptr, size_t __n = _S_no_limit) noexcept
3749 : _Sink<_CharT>(_M_buf), _M_max(__n)
3750 {
3751 if (__n == 0)
3752 return; // Only write to the internal buffer.
3753 else if (__n != _S_no_limit)
3754 _M_rebuf(__ptr, __n);
3755#if __has_builtin(__builtin_dynamic_object_size)
3756 else if (size_t __bytes = __builtin_dynamic_object_size(__ptr, 2))
3757 _M_rebuf(__ptr, __bytes / sizeof(_CharT));
3758#endif
3759 else
3760 {
3761 // Avoid forming a pointer to a different memory page.
3762 const auto __off = reinterpret_cast<__UINTPTR_TYPE__>(__ptr) % 1024;
3763 __n = (1024 - __off) / sizeof(_CharT);
3764 if (__n > 0) [[likely]]
3765 _M_rebuf(__ptr, __n);
3766 else // Misaligned/packed buffer of wchar_t?
3767 _M_rebuf(__ptr, 1);
3768 }
3769 }
3770
3771 template<contiguous_iterator _OutIter>
3772 explicit
3773 _Ptr_sink(_OutIter __out, iter_difference_t<_OutIter> __n = -1)
3774 : _Ptr_sink(std::to_address(__out), _S_trim_max(__n))
3775 { }
3776
3777 template<contiguous_iterator _OutIter>
3778 format_to_n_result<_OutIter>
3779 _M_finish(_OutIter __first) const
3780 {
3781 auto __s = this->_M_used();
3782 if (__s.data() == _M_buf)
3783 {
3784 // Switched to internal buffer, so must have written _M_max.
3785 iter_difference_t<_OutIter> __m(_M_max);
3786 iter_difference_t<_OutIter> __count(_M_count + __s.size());
3787 return { __first + __m, __count };
3788 }
3789 else // Not using internal buffer yet
3790 {
3791 iter_difference_t<_OutIter> __count(__s.size());
3792 return { __first + __count, __count };
3793 }
3794 }
3795 };
3796
3797 template<typename _CharT, typename _OutIter>
3798 concept __contiguous_char_iter
3799 = contiguous_iterator<_OutIter>
3800 && same_as<iter_value_t<_OutIter>, _CharT>;
3801
3802 // A sink for handling the padded outputs (_M_padwidth) or truncated
3803 // (_M_maxwidth). The handling is done by writting to buffer (_Str_strink)
3804 // until sufficient number of characters is written. After that if sequence
3805 // is longer than _M_padwidth it's written to _M_out, and further writes are
3806 // either:
3807 // * buffered and forwarded to _M_out, if below _M_maxwidth,
3808 // * ignored otherwise
3809 // If field width of written sequence is no greater than _M_padwidth, the
3810 // sequence is written during _M_finish call.
3811 template<typename _Out, typename _CharT>
3812 class _Padding_sink : public _Str_sink<_CharT>
3813 {
3814 size_t _M_padwidth;
3815 size_t _M_maxwidth;
3816 _Out _M_out;
3817 size_t _M_printwidth;
3818
3819 [[__gnu__::__always_inline__]]
3820 bool
3821 _M_ignoring() const
3822 { return _M_printwidth >= _M_maxwidth; }
3823
3824 [[__gnu__::__always_inline__]]
3825 bool
3826 _M_buffering() const
3827 {
3828 if (_M_printwidth < _M_padwidth)
3829 return true;
3830 if (_M_maxwidth != (size_t)-1)
3831 return _M_printwidth < _M_maxwidth;
3832 return false;
3833 }
3834
3835 void
3836 _M_sync_discarding()
3837 {
3838 if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
3839 if (_M_out._M_discarding())
3840 _M_maxwidth = _M_printwidth;
3841 }
3842
3843 void
3844 _M_flush()
3845 {
3846 span<_CharT> __new = this->_M_used();
3847 basic_string_view<_CharT> __str(__new.data(), __new.size());
3848 _M_out = __format::__write(std::move(_M_out), __str);
3849 _M_sync_discarding();
3850 this->_M_rewind();
3851 }
3852
3853 bool
3854 _M_force_update()
3855 {
3856 auto __str = this->view();
3857 // Compute actual field width, possibly truncated.
3858 _M_printwidth = __format::__truncate(__str, _M_maxwidth);
3859 if (_M_ignoring())
3860 this->_M_trim(__str);
3861 if (_M_buffering())
3862 return true;
3863
3864 // We have more characters than padidng, no padding is needed,
3865 // write direclty to _M_out.
3866 if (_M_printwidth >= _M_padwidth)
3867 {
3868 _M_out = __format::__write(std::move(_M_out), __str);
3869 _M_sync_discarding();
3870 }
3871 // We reached _M_maxwidth that is smaller than _M_padwidth.
3872 // Store the prefix sequence in _M_seq, and free _M_buf.
3873 else
3874 _Str_sink<_CharT>::_M_overflow();
3875
3876 // Use internal buffer for writes to _M_out.
3877 this->_M_reset(this->_M_buf);
3878 return false;
3879 }
3880
3881 bool
3882 _M_update(size_t __new)
3883 {
3884 _M_printwidth += __new;
3885 // Compute estimated width, to see if is not reduced.
3886 if (_M_printwidth >= _M_padwidth || _M_printwidth >= _M_maxwidth)
3887 return _M_force_update();
3888 return true;
3889 }
3890
3891 void
3892 _M_overflow() override
3893 {
3894 // Ignore characters in buffer, and override it.
3895 if (_M_ignoring())
3896 this->_M_rewind();
3897 // Write buffer to _M_out, and override it.
3898 else if (!_M_buffering())
3899 _M_flush();
3900 // Update written count, and if input still should be buffered,
3901 // flush the to _M_seq.
3902 else if (_M_update(this->_M_used().size()))
3903 _Str_sink<_CharT>::_M_overflow();
3904 }
3905
3906 bool
3907 _M_discarding() const override
3908 { return _M_ignoring(); }
3909
3910 typename _Sink<_CharT>::_Reservation
3911 _M_reserve(size_t __n) override
3912 {
3913 // Ignore characters in buffer, if any.
3914 if (_M_ignoring())
3915 this->_M_rewind();
3916 else if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
3917 if (!_M_buffering())
3918 {
3919 // Write pending characters if any
3920 if (!this->_M_used().empty())
3921 _M_flush();
3922 // Try to reserve from _M_out sink.
3923 if (auto __reserved = _M_out._M_reserve(__n))
3924 return __reserved;
3925 }
3926 return _Sink<_CharT>::_M_reserve(__n);
3927 }
3928
3929 void
3930 _M_bump(size_t __n) override
3931 {
3932 // Ignore the written characters.
3933 if (_M_ignoring())
3934 return;
3935 // If reservation was made directy sink associated _M_out,
3936 // _M_bump will be called on that sink.
3937 _Sink<_CharT>::_M_bump(__n);
3938 if (_M_buffering())
3939 _M_update(__n);
3940 }
3941
3942 public:
3943 [[__gnu__::__always_inline__]]
3944 explicit
3945 _Padding_sink(_Out __out, size_t __padwidth, size_t __maxwidth)
3946 : _M_padwidth(__padwidth), _M_maxwidth(__maxwidth),
3947 _M_out(std::move(__out)), _M_printwidth(0)
3948 { _M_sync_discarding(); }
3949
3950 [[__gnu__::__always_inline__]]
3951 explicit
3952 _Padding_sink(_Out __out, size_t __padwidth)
3953 : _Padding_sink(std::move(__out), __padwidth, (size_t)-1)
3954 { }
3955
3956 _Out
3957 _M_finish(_Align __align, char32_t __fill_char)
3958 {
3959 // Handle any characters in the buffer.
3960 if (auto __rem = this->_M_used().size())
3961 {
3962 if (_M_ignoring())
3963 this->_M_rewind();
3964 else if (!_M_buffering())
3965 _M_flush();
3966 else
3967 _M_update(__rem);
3968 }
3969
3970 if (!_M_buffering() || !_M_force_update())
3971 // Characters were already written to _M_out.
3972 if (_M_printwidth >= _M_padwidth)
3973 return std::move(_M_out);
3974
3975 const auto __str = this->view();
3976 if (_M_printwidth >= _M_padwidth)
3977 return __format::__write(std::move(_M_out), __str);
3978
3979 const size_t __nfill = _M_padwidth - _M_printwidth;
3980 return __format::__write_padded(std::move(_M_out), __str,
3981 __align, __nfill, __fill_char);
3982 }
3983 };
3984
3985 template<typename _Out, typename _CharT>
3986 class _Escaping_sink : public _Buf_sink<_CharT>
3987 {
3988 using _Esc = _Escapes<_CharT>;
3989
3990 _Out _M_out;
3991 _Term_char _M_term : 2;
3992 unsigned _M_prev_escape : 1;
3993 unsigned _M_out_discards : 1;
3994
3995 void
3996 _M_sync_discarding()
3997 {
3998 if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
3999 _M_out_discards = _M_out._M_discarding();
4000 }
4001
4002 void
4003 _M_write()
4004 {
4005 span<_CharT> __bytes = this->_M_used();
4006 basic_string_view<_CharT> __str(__bytes.data(), __bytes.size());
4007
4008 size_t __rem = 0;
4009 if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
4010 {
4011 bool __prev_escape = _M_prev_escape;
4012 _M_out = __format::__write_escaped_unicode_part(
4013 std::move(_M_out), __str, __prev_escape, _M_term);
4014 _M_prev_escape = __prev_escape;
4015
4016 __rem = __str.size();
4017 if (__rem > 0 && __str.data() != this->_M_buf) [[unlikely]]
4018 ranges::move(__str, this->_M_buf);
4019 }
4020 else
4021 _M_out = __format::__write_escaped_ascii(
4022 std::move(_M_out), __str, _M_term);
4023
4024 this->_M_reset(this->_M_buf, __rem);
4025 _M_sync_discarding();
4026 }
4027
4028 void
4029 _M_overflow() override
4030 {
4031 if (_M_out_discards)
4032 this->_M_rewind();
4033 else
4034 _M_write();
4035 }
4036
4037 bool
4038 _M_discarding() const override
4039 { return _M_out_discards; }
4040
4041 public:
4042 [[__gnu__::__always_inline__]]
4043 explicit
4044 _Escaping_sink(_Out __out, _Term_char __term)
4045 : _M_out(std::move(__out)), _M_term(__term),
4046 _M_prev_escape(true), _M_out_discards(false)
4047 {
4048 _M_out = __format::__write(std::move(_M_out), _Esc::_S_term(_M_term));
4049 _M_sync_discarding();
4050 }
4051
4052 _Out
4053 _M_finish()
4054 {
4055 if (_M_out_discards)
4056 return std::move(_M_out);
4057
4058 if (!this->_M_used().empty())
4059 {
4060 _M_write();
4061 if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
4062 if (auto __rem = this->_M_used(); !__rem.empty())
4063 {
4064 basic_string_view<_CharT> __str(__rem.data(), __rem.size());
4065 _M_out = __format::__write_escape_seqs(std::move(_M_out), __str);
4066 }
4067 }
4068 return __format::__write(std::move(_M_out), _Esc::_S_term(_M_term));
4069 }
4070 };
4071
4072 enum class _Arg_t : unsigned char {
4073 _Arg_none, _Arg_bool, _Arg_c, _Arg_i, _Arg_u, _Arg_ll, _Arg_ull,
4074 _Arg_flt, _Arg_dbl, _Arg_ldbl, _Arg_str, _Arg_sv, _Arg_ptr, _Arg_handle,
4075 _Arg_i128, _Arg_u128, _Arg_float128,
4076 _Arg_bf16, _Arg_f16, _Arg_f32, _Arg_f64,
4077 _Arg_max_,
4078
4079#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
4080 _Arg_ibm128 = _Arg_ldbl,
4081 _Arg_ieee128 = _Arg_float128,
4082#endif
4083 };
4084 using enum _Arg_t;
4085
4086 template<typename _Context>
4087 struct _Arg_value
4088 {
4089 using _CharT = typename _Context::char_type;
4090
4091 class handle
4092 {
4093 using _CharT = typename _Context::char_type;
4094 using _Func = void(*)(basic_format_parse_context<_CharT>&,
4095 _Context&, const void*);
4096
4097 // Format as const if possible, to reduce instantiations.
4098 template<typename _Tp>
4099 using __maybe_const_t
4100 = __conditional_t<__formattable_with<const _Tp, _Context>,
4101 const _Tp, _Tp>;
4102
4103 template<typename _Tq>
4104 static void
4105 _S_format(basic_format_parse_context<_CharT>& __parse_ctx,
4106 _Context& __format_ctx, const void* __ptr)
4107 {
4108 using _Td = remove_const_t<_Tq>;
4109 typename _Context::template formatter_type<_Td> __f;
4110 __parse_ctx.advance_to(__f.parse(__parse_ctx));
4111 _Tq& __val = *const_cast<_Tq*>(static_cast<const _Td*>(__ptr));
4112 __format_ctx.advance_to(__f.format(__val, __format_ctx));
4113 }
4114
4115 template<typename _Tp>
4116 requires (!is_same_v<remove_cv_t<_Tp>, handle>)
4117 explicit
4118 handle(_Tp& __val) noexcept
4119 : _M_ptr(__builtin_addressof(__val))
4120 , _M_func(&_S_format<__maybe_const_t<_Tp>>)
4121 { }
4122
4123 friend class basic_format_arg<_Context>;
4124
4125 public:
4126 handle(const handle&) = default;
4127 handle& operator=(const handle&) = default;
4128
4129 [[__gnu__::__always_inline__]]
4130 void
4131 format(basic_format_parse_context<_CharT>& __pc, _Context& __fc) const
4132 { _M_func(__pc, __fc, this->_M_ptr); }
4133
4134 private:
4135 const void* _M_ptr;
4136 _Func _M_func;
4137 };
4138
4139 union
4140 {
4141 monostate _M_none;
4142 bool _M_bool;
4143 _CharT _M_c;
4144 int _M_i;
4145 unsigned _M_u;
4146 long long _M_ll;
4147 unsigned long long _M_ull;
4148 float _M_flt;
4149 double _M_dbl;
4150#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT // No long double if it's ambiguous.
4151 long double _M_ldbl;
4152#else
4153 __ibm128 _M_ibm128;
4154 __ieee128 _M_ieee128;
4155#endif
4156#ifdef __SIZEOF_FLOAT128__
4157 __float128 _M_float128;
4158#endif
4159 const _CharT* _M_str;
4160 basic_string_view<_CharT> _M_sv;
4161 const void* _M_ptr;
4162 handle _M_handle;
4163#ifdef __SIZEOF_INT128__
4164 __int128 _M_i128;
4165 unsigned __int128 _M_u128;
4166#endif
4167#ifdef __BFLT16_DIG__
4168 __bflt16_t _M_bf16;
4169#endif
4170#ifdef __FLT16_DIG__
4171 _Float16 _M_f16;
4172#endif
4173#ifdef __FLT32_DIG__
4174 _Float32 _M_f32;
4175#endif
4176#ifdef __FLT64_DIG__
4177 _Float64 _M_f64;
4178#endif
4179 };
4180
4181 [[__gnu__::__always_inline__]]
4182 _Arg_value() : _M_none() { }
4183
4184#if 0
4185 template<typename _Tp>
4186 _Arg_value(in_place_type_t<_Tp>, _Tp __val)
4187 { _S_get<_Tp>() = __val; }
4188#endif
4189
4190 // Returns reference to the _Arg_value member with the type _Tp.
4191 // Value of second argument (if provided), is assigned to that member.
4192 template<typename _Tp, typename _Self, typename... _Value>
4193 [[__gnu__::__always_inline__]]
4194 static auto&
4195 _S_access(_Self& __u, _Value... __value) noexcept
4196 {
4197 static_assert(sizeof...(_Value) <= 1);
4198 if constexpr (is_same_v<_Tp, bool>)
4199 return (__u._M_bool = ... = __value);
4200 else if constexpr (is_same_v<_Tp, _CharT>)
4201 return (__u._M_c = ... = __value);
4202 else if constexpr (is_same_v<_Tp, int>)
4203 return (__u._M_i = ... = __value);
4204 else if constexpr (is_same_v<_Tp, unsigned>)
4205 return (__u._M_u = ... = __value);
4206 else if constexpr (is_same_v<_Tp, long long>)
4207 return (__u._M_ll = ... = __value);
4208 else if constexpr (is_same_v<_Tp, unsigned long long>)
4209 return (__u._M_ull = ... = __value);
4210 else if constexpr (is_same_v<_Tp, float>)
4211 return (__u._M_flt = ... = __value);
4212 else if constexpr (is_same_v<_Tp, double>)
4213 return (__u._M_dbl = ... = __value);
4214#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
4215 else if constexpr (is_same_v<_Tp, long double>)
4216 return (__u._M_ldbl = ... = __value);
4217#else
4218 else if constexpr (is_same_v<_Tp, __ibm128>)
4219 return (__u._M_ibm128 = ... = __value);
4220 else if constexpr (is_same_v<_Tp, __ieee128>)
4221 return (__u._M_ieee128 = ... = __value);
4222#endif
4223#ifdef __SIZEOF_FLOAT128__
4224 else if constexpr (is_same_v<_Tp, __float128>)
4225 return (__u._M_float128 = ... = __value);
4226#endif
4227 else if constexpr (is_same_v<_Tp, const _CharT*>)
4228 return (__u._M_str = ... = __value);
4229 else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
4230 return (__u._M_sv = ... = __value);
4231 else if constexpr (is_same_v<_Tp, const void*>)
4232 return (__u._M_ptr = ... = __value);
4233#ifdef __SIZEOF_INT128__
4234 else if constexpr (is_same_v<_Tp, __int128>)
4235 return (__u._M_i128 = ... = __value);
4236 else if constexpr (is_same_v<_Tp, unsigned __int128>)
4237 return (__u._M_u128 = ... = __value);
4238#endif
4239#ifdef __BFLT16_DIG__
4240 else if constexpr (is_same_v<_Tp, __bflt16_t>)
4241 return (__u._M_bf16 = ... = __value);
4242#endif
4243#ifdef __FLT16_DIG__
4244 else if constexpr (is_same_v<_Tp, _Float16>)
4245 return (__u._M_f16 = ... = __value);
4246#endif
4247#ifdef __FLT32_DIG__
4248 else if constexpr (is_same_v<_Tp, _Float32>)
4249 return (__u._M_f32 = ... = __value);
4250#endif
4251#ifdef __FLT64_DIG__
4252 else if constexpr (is_same_v<_Tp, _Float64>)
4253 return (__u._M_f64 = ... = __value);
4254#endif
4255 else if constexpr (is_same_v<_Tp, handle>)
4256 return __u._M_handle;
4257 // Otherwise, ill-formed.
4258 }
4259
4260 template<typename _Tp>
4261 [[__gnu__::__always_inline__]]
4262 auto&
4263 _M_get() noexcept
4264 { return _S_access<_Tp>(*this); }
4265
4266 template<typename _Tp>
4267 [[__gnu__::__always_inline__]]
4268 const auto&
4269 _M_get() const noexcept
4270 { return _S_access<_Tp>(*this); }
4271
4272 template<typename _Tp>
4273 [[__gnu__::__always_inline__]]
4274 void
4275 _M_set(_Tp __v) noexcept
4276 {
4277 // Explicitly construct types without trivial default constructor.
4278 if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
4279 std::construct_at(&_M_sv, __v);
4280 else if constexpr (is_same_v<_Tp, handle>)
4281 std::construct_at(&_M_handle, __v);
4282 else
4283 // Builtin types are trivially default constructible, and assignment
4284 // changes active member per N5032 [class.union.general] p5.
4285 _S_access<_Tp>(*this, __v);
4286 }
4287 };
4288
4289 // [format.arg.store], class template format-arg-store
4290 template<typename _Context, typename... _Args>
4291 class _Arg_store;
4292
4293 template<typename _Visitor, typename _Ctx>
4294 decltype(auto) __visit_format_arg(_Visitor&&, basic_format_arg<_Ctx>);
4295
4296 template<typename _Ch, typename _Tp>
4297 consteval _Arg_t
4298 __to_arg_t_enum() noexcept;
4299} // namespace __format
4300/// @endcond
4301
4302 template<typename _Context>
4303 class basic_format_arg
4304 {
4305 using _CharT = typename _Context::char_type;
4306
4307 public:
4308 using handle = __format::_Arg_value<_Context>::handle;
4309
4310 [[__gnu__::__always_inline__]]
4311 basic_format_arg() noexcept : _M_type(__format::_Arg_none) { }
4312
4313 [[nodiscard,__gnu__::__always_inline__]]
4314 explicit operator bool() const noexcept
4315 { return _M_type != __format::_Arg_none; }
4316
4317#if __cpp_lib_format >= 202306L // >= C++26
4318 template<typename _Visitor>
4319 decltype(auto)
4320 visit(this basic_format_arg __arg, _Visitor&& __vis)
4321 { return __arg._M_visit_user(std::forward<_Visitor>(__vis), __arg._M_type); }
4322
4323 template<typename _Res, typename _Visitor>
4324 _Res
4325 visit(this basic_format_arg __arg, _Visitor&& __vis)
4326 { return __arg._M_visit_user(std::forward<_Visitor>(__vis), __arg._M_type); }
4327#endif
4328
4329 private:
4330 template<typename _Ctx>
4331 friend class basic_format_args;
4332
4333 template<typename _Ctx, typename... _Args>
4334 friend class __format::_Arg_store;
4335
4336 static_assert(is_trivially_copyable_v<__format::_Arg_value<_Context>>);
4337
4338 __format::_Arg_value<_Context> _M_val;
4339 __format::_Arg_t _M_type;
4340
4341 // Transform incoming argument type to the type stored in _Arg_value.
4342 // e.g. short -> int, std::string -> std::string_view,
4343 // char[3] -> const char*.
4344 template<typename _Tp>
4345 static consteval auto
4346 _S_to_arg_type()
4347 {
4348 using _Td = remove_const_t<_Tp>;
4349 if constexpr (is_same_v<_Td, bool>)
4350 return type_identity<bool>();
4351 else if constexpr (is_same_v<_Td, _CharT>)
4352 return type_identity<_CharT>();
4353 else if constexpr (is_same_v<_Td, char> && is_same_v<_CharT, wchar_t>)
4354 return type_identity<_CharT>();
4355#ifdef __SIZEOF_INT128__ // Check before signed/unsigned integer
4356 else if constexpr (is_same_v<_Td, __int128>)
4357 return type_identity<__int128>();
4358 else if constexpr (is_same_v<_Td, unsigned __int128>)
4359 return type_identity<unsigned __int128>();
4360#endif
4361 else if constexpr (__is_signed_integer<_Td>::value)
4362 {
4363 if constexpr (sizeof(_Td) <= sizeof(int))
4364 return type_identity<int>();
4365 else if constexpr (sizeof(_Td) <= sizeof(long long))
4366 return type_identity<long long>();
4367 }
4368 else if constexpr (__is_unsigned_integer<_Td>::value)
4369 {
4370 if constexpr (sizeof(_Td) <= sizeof(unsigned))
4371 return type_identity<unsigned>();
4372 else if constexpr (sizeof(_Td) <= sizeof(unsigned long long))
4373 return type_identity<unsigned long long>();
4374 }
4375 else if constexpr (is_same_v<_Td, float>)
4376 return type_identity<float>();
4377 else if constexpr (is_same_v<_Td, double>)
4378 return type_identity<double>();
4379#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
4380 else if constexpr (is_same_v<_Td, long double>)
4381 return type_identity<long double>();
4382#else
4383 else if constexpr (is_same_v<_Td, __ibm128>)
4384 return type_identity<__ibm128>();
4385 else if constexpr (is_same_v<_Td, __ieee128>)
4386 return type_identity<__ieee128>();
4387#endif
4388#if defined(__SIZEOF_FLOAT128__) && _GLIBCXX_FORMAT_F128
4389 else if constexpr (is_same_v<_Td, __float128>)
4390 return type_identity<__float128>();
4391#endif
4392#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
4393 else if constexpr (is_same_v<_Td, __format::__bflt16_t>)
4394 return type_identity<__format::__bflt16_t>();
4395#endif
4396#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
4397 else if constexpr (is_same_v<_Td, _Float16>)
4398 return type_identity<_Float16>();
4399#endif
4400#if defined(__FLT32_DIG__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
4401 else if constexpr (is_same_v<_Td, _Float32>)
4402 return type_identity<_Float32>();
4403#endif
4404#if defined(__FLT64_DIG__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
4405 else if constexpr (is_same_v<_Td, _Float64>)
4406 return type_identity<_Float64>();
4407#endif
4408 else if constexpr (__is_specialization_of<_Td, basic_string_view>
4409 || __is_specialization_of<_Td, basic_string>)
4410 {
4411 if constexpr (is_same_v<typename _Td::value_type, _CharT>)
4412 return type_identity<basic_string_view<_CharT>>();
4413 else
4414 return type_identity<handle>();
4415 }
4416 else if constexpr (is_same_v<decay_t<_Td>, const _CharT*>)
4417 return type_identity<const _CharT*>();
4418 else if constexpr (is_same_v<decay_t<_Td>, _CharT*>)
4419 return type_identity<const _CharT*>();
4420 else if constexpr (is_void_v<remove_pointer_t<_Td>>)
4421 return type_identity<const void*>();
4422 else if constexpr (is_same_v<_Td, nullptr_t>)
4423 return type_identity<const void*>();
4424 else
4425 return type_identity<handle>();
4426 }
4427
4428 // Transform a formattable type to the appropriate storage type.
4429 template<typename _Tp>
4430 using _Normalize = typename decltype(_S_to_arg_type<_Tp>())::type;
4431
4432 // Get the _Arg_t value corresponding to a normalized type.
4433 template<typename _Tp>
4434 static consteval __format::_Arg_t
4435 _S_to_enum()
4436 {
4437 using namespace __format;
4438 if constexpr (is_same_v<_Tp, bool>)
4439 return _Arg_bool;
4440 else if constexpr (is_same_v<_Tp, _CharT>)
4441 return _Arg_c;
4442 else if constexpr (is_same_v<_Tp, int>)
4443 return _Arg_i;
4444 else if constexpr (is_same_v<_Tp, unsigned>)
4445 return _Arg_u;
4446 else if constexpr (is_same_v<_Tp, long long>)
4447 return _Arg_ll;
4448 else if constexpr (is_same_v<_Tp, unsigned long long>)
4449 return _Arg_ull;
4450 else if constexpr (is_same_v<_Tp, float>)
4451 return _Arg_flt;
4452 else if constexpr (is_same_v<_Tp, double>)
4453 return _Arg_dbl;
4454#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
4455 else if constexpr (is_same_v<_Tp, long double>)
4456 return _Arg_ldbl;
4457#else
4458 // Don't use _Arg_ldbl for this target, it's ambiguous.
4459 else if constexpr (is_same_v<_Tp, __ibm128>)
4460 return _Arg_ibm128;
4461 else if constexpr (is_same_v<_Tp, __ieee128>)
4462 return _Arg_ieee128;
4463#endif
4464#if defined(__SIZEOF_FLOAT128__) && _GLIBCXX_FORMAT_F128
4465 else if constexpr (is_same_v<_Tp, __float128>)
4466 return _Arg_float128;
4467#endif
4468#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
4469 else if constexpr (is_same_v<_Tp, __format::__bflt16_t>)
4470 return _Arg_bf16;
4471#endif
4472#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
4473 else if constexpr (is_same_v<_Tp, _Float16>)
4474 return _Arg_f16;
4475#endif
4476#if defined(__FLT32_DIG__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
4477 else if constexpr (is_same_v<_Tp, _Float32>)
4478 return _Arg_f32;
4479#endif
4480#if defined(__FLT64_DIG__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
4481 else if constexpr (is_same_v<_Tp, _Float64>)
4482 return _Arg_f64;
4483#endif
4484 else if constexpr (is_same_v<_Tp, const _CharT*>)
4485 return _Arg_str;
4486 else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
4487 return _Arg_sv;
4488 else if constexpr (is_same_v<_Tp, const void*>)
4489 return _Arg_ptr;
4490#ifdef __SIZEOF_INT128__
4491 else if constexpr (is_same_v<_Tp, __int128>)
4492 return _Arg_i128;
4493 else if constexpr (is_same_v<_Tp, unsigned __int128>)
4494 return _Arg_u128;
4495#endif
4496 else if constexpr (is_same_v<_Tp, handle>)
4497 return _Arg_handle;
4498 }
4499
4500 template<typename _Tp>
4501 void
4502 _M_set(_Tp __v) noexcept
4503 {
4504 _M_type = _S_to_enum<_Tp>();
4505 _M_val._M_set(__v);
4506 }
4507
4508 template<typename _Tp>
4509 requires __format::__formattable_with<_Tp, _Context>
4510 explicit
4511 basic_format_arg(_Tp& __v) noexcept
4512 {
4513 using _Td = _Normalize<_Tp>;
4514 if constexpr (is_same_v<_Td, basic_string_view<_CharT>>)
4515 _M_set(_Td{__v.data(), __v.size()});
4516 else if constexpr (is_same_v<remove_const_t<_Tp>, char>
4517 && is_same_v<_CharT, wchar_t>)
4518 _M_set(static_cast<_Td>(static_cast<unsigned char>(__v)));
4519 else
4520 _M_set(static_cast<_Td>(__v));
4521 }
4522
4523 template<typename _Ctx, typename... _Argz>
4524 friend auto
4525 make_format_args(_Argz&...) noexcept;
4526
4527 template<typename _Visitor, typename _Ctx>
4528 friend decltype(auto)
4529 visit_format_arg(_Visitor&& __vis, basic_format_arg<_Ctx>);
4530
4531 template<typename _Visitor, typename _Ctx>
4532 friend decltype(auto)
4533 __format::__visit_format_arg(_Visitor&&, basic_format_arg<_Ctx>);
4534
4535 template<typename _Ch, typename _Tp>
4536 friend consteval __format::_Arg_t
4537 __format::__to_arg_t_enum() noexcept;
4538
4539 template<typename _Visitor>
4540 decltype(auto)
4541 _M_visit(_Visitor&& __vis, __format::_Arg_t __type)
4542 {
4543 using namespace __format;
4544 switch (__type)
4545 {
4546 case _Arg_none:
4547 return std::forward<_Visitor>(__vis)(_M_val._M_none);
4548 case _Arg_bool:
4549 return std::forward<_Visitor>(__vis)(_M_val._M_bool);
4550 case _Arg_c:
4551 return std::forward<_Visitor>(__vis)(_M_val._M_c);
4552 case _Arg_i:
4553 return std::forward<_Visitor>(__vis)(_M_val._M_i);
4554 case _Arg_u:
4555 return std::forward<_Visitor>(__vis)(_M_val._M_u);
4556 case _Arg_ll:
4557 return std::forward<_Visitor>(__vis)(_M_val._M_ll);
4558 case _Arg_ull:
4559 return std::forward<_Visitor>(__vis)(_M_val._M_ull);
4560#if __glibcxx_to_chars // FIXME: need to be able to format these types!
4561 case _Arg_flt:
4562 return std::forward<_Visitor>(__vis)(_M_val._M_flt);
4563 case _Arg_dbl:
4564 return std::forward<_Visitor>(__vis)(_M_val._M_dbl);
4565#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
4566 case _Arg_ldbl:
4567 return std::forward<_Visitor>(__vis)(_M_val._M_ldbl);
4568#if defined(__SIZEOF_FLOAT128__) && _GLIBCXX_FORMAT_F128
4569 case _Arg_float128:
4570 return std::forward<_Visitor>(__vis)(_M_val._M_float128);
4571#endif
4572#else
4573 case _Arg_ibm128:
4574 return std::forward<_Visitor>(__vis)(_M_val._M_ibm128);
4575 case _Arg_ieee128:
4576 return std::forward<_Visitor>(__vis)(_M_val._M_ieee128);
4577#endif
4578#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
4579 case _Arg_bf16:
4580 return std::forward<_Visitor>(__vis)(_M_val._M_bf16);
4581#endif
4582#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
4583 case _Arg_f16:
4584 return std::forward<_Visitor>(__vis)(_M_val._M_f16);
4585#endif
4586#if defined(__FLT32_DIG__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
4587 case _Arg_f32:
4588 return std::forward<_Visitor>(__vis)(_M_val._M_f32);
4589#endif
4590#if defined(__FLT64_DIG__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
4591 case _Arg_f64:
4592 return std::forward<_Visitor>(__vis)(_M_val._M_f64);
4593#endif
4594#endif // __glibcxx_to_chars
4595 case _Arg_str:
4596 return std::forward<_Visitor>(__vis)(_M_val._M_str);
4597 case _Arg_sv:
4598 return std::forward<_Visitor>(__vis)(_M_val._M_sv);
4599 case _Arg_ptr:
4600 return std::forward<_Visitor>(__vis)(_M_val._M_ptr);
4601 case _Arg_handle:
4602 return std::forward<_Visitor>(__vis)(_M_val._M_handle);
4603#ifdef __SIZEOF_INT128__
4604 case _Arg_i128:
4605 return std::forward<_Visitor>(__vis)(_M_val._M_i128);
4606 case _Arg_u128:
4607 return std::forward<_Visitor>(__vis)(_M_val._M_u128);
4608#endif
4609 default:
4610 __builtin_unreachable();
4611 }
4612 }
4613
4614 template<typename _Visitor>
4615 decltype(auto)
4616 _M_visit_user(_Visitor&& __vis, __format::_Arg_t __type)
4617 {
4618 return _M_visit([&__vis]<typename _Tp>(_Tp& __val) -> decltype(auto)
4619 {
4620 constexpr bool __user_facing = __is_one_of<_Tp,
4621 monostate, bool, _CharT,
4622 int, unsigned int, long long int, unsigned long long int,
4623 float, double, long double,
4624 const _CharT*, basic_string_view<_CharT>,
4625 const void*, handle>::value;
4626 if constexpr (__user_facing)
4627 return std::forward<_Visitor>(__vis)(__val);
4628 else
4629 {
4630 handle __h(__val);
4631 return std::forward<_Visitor>(__vis)(__h);
4632 }
4633 }, __type);
4634 }
4635 };
4636
4637 template<typename _Visitor, typename _Context>
4638 _GLIBCXX26_DEPRECATED_SUGGEST("std::basic_format_arg::visit")
4639 inline decltype(auto)
4640 visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg)
4641 {
4642 return __arg._M_visit_user(std::forward<_Visitor>(__vis), __arg._M_type);
4643 }
4644
4645/// @cond undocumented
4646namespace __format
4647{
4648 template<typename _Visitor, typename _Ctx>
4649 inline decltype(auto)
4650 __visit_format_arg(_Visitor&& __vis, basic_format_arg<_Ctx> __arg)
4651 {
4652 return __arg._M_visit(std::forward<_Visitor>(__vis), __arg._M_type);
4653 }
4654
4655 struct _WidthPrecVisitor
4656 {
4657 template<typename _Tp>
4658 size_t
4659 operator()(_Tp& __arg) const
4660 {
4661 if constexpr (is_same_v<_Tp, monostate>)
4662 __format::__invalid_arg_id_in_format_string();
4663 // _GLIBCXX_RESOLVE_LIB_DEFECTS
4664 // 3720. Restrict the valid types of arg-id for width and precision
4665 // 3721. Allow an arg-id with a value of zero for width
4666 else if constexpr (sizeof(_Tp) <= sizeof(long long))
4667 {
4668 // _GLIBCXX_RESOLVE_LIB_DEFECTS
4669 // 3720. Restrict the valid types of arg-id for width and precision
4670 if constexpr (__is_unsigned_integer<_Tp>::value)
4671 return __arg;
4672 else if constexpr (__is_signed_integer<_Tp>::value)
4673 if (__arg >= 0)
4674 return __arg;
4675 }
4676 __throw_format_error("format error: argument used for width or "
4677 "precision must be a non-negative integer");
4678 }
4679 };
4680
4681#pragma GCC diagnostic push
4682#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
4683 template<typename _Context>
4684 inline size_t
4685 __int_from_arg(const basic_format_arg<_Context>& __arg)
4686 { return __format::__visit_format_arg(_WidthPrecVisitor(), __arg); }
4687
4688 // Pack _Arg_t enum values into a single 60-bit integer.
4689 template<int _Bits, size_t _Nm>
4690 constexpr auto
4691 __pack_arg_types(const array<_Arg_t, _Nm>& __types)
4692 {
4693 __UINT64_TYPE__ __packed_types = 0;
4694 for (auto __i = __types.rbegin(); __i != __types.rend(); ++__i)
4695 __packed_types = (__packed_types << _Bits) | (unsigned)*__i;
4696 return __packed_types;
4697 }
4698} // namespace __format
4699/// @endcond
4700
4701 template<typename _Context>
4702 class basic_format_args
4703 {
4704 static constexpr int _S_packed_type_bits = 5; // _Arg_t values [0,20]
4705 static constexpr int _S_packed_type_mask = 0b11111;
4706 static constexpr int _S_max_packed_args = 12;
4707
4708 static_assert( (unsigned)__format::_Arg_max_ <= (1u << _S_packed_type_bits) );
4709
4710 template<typename... _Args>
4711 using _Store = __format::_Arg_store<_Context, _Args...>;
4712
4713 template<typename _Ctx, typename... _Args>
4714 friend class __format::_Arg_store;
4715
4716 using uint64_t = __UINT64_TYPE__;
4717 using _Format_arg = basic_format_arg<_Context>;
4718 using _Format_arg_val = __format::_Arg_value<_Context>;
4719
4720 // If args are packed then the number of args is in _M_packed_size and
4721 // the packed types are in _M_unpacked_size, accessed via _M_type(i).
4722 // If args are not packed then the number of args is in _M_unpacked_size
4723 // and _M_packed_size is zero.
4724 uint64_t _M_packed_size : 4;
4725 uint64_t _M_unpacked_size : 60;
4726
4727 union {
4728 const _Format_arg_val* _M_values; // Active when _M_packed_size != 0
4729 const _Format_arg* _M_args; // Active when _M_packed_size == 0
4730 };
4731
4732 size_t
4733 _M_size() const noexcept
4734 { return _M_packed_size ? _M_packed_size : _M_unpacked_size; }
4735
4736 typename __format::_Arg_t
4737 _M_type(size_t __i) const noexcept
4738 {
4739 uint64_t __t = _M_unpacked_size >> (__i * _S_packed_type_bits);
4740 return static_cast<__format::_Arg_t>(__t & _S_packed_type_mask);
4741 }
4742
4743 template<typename _Ctx, typename... _Args>
4744 friend auto
4745 make_format_args(_Args&...) noexcept;
4746
4747 // An array of _Arg_t enums corresponding to _Args...
4748 template<typename... _Args>
4749 static consteval array<__format::_Arg_t, sizeof...(_Args)>
4750 _S_types_to_pack()
4751 { return {_Format_arg::template _S_to_enum<_Args>()...}; }
4752
4753 public:
4754 template<typename... _Args>
4755 basic_format_args(const _Store<_Args...>& __store) noexcept;
4756
4757 [[nodiscard,__gnu__::__always_inline__]]
4758 basic_format_arg<_Context>
4759 get(size_t __i) const noexcept
4760 {
4761 basic_format_arg<_Context> __arg;
4762 if (__i < _M_packed_size)
4763 {
4764 __arg._M_type = _M_type(__i);
4765 __arg._M_val = _M_values[__i];
4766 }
4767 else if (_M_packed_size == 0 && __i < _M_unpacked_size)
4768 __arg = _M_args[__i];
4769 return __arg;
4770 }
4771 };
4772
4773 // _GLIBCXX_RESOLVE_LIB_DEFECTS
4774 // 3810. CTAD for std::basic_format_args
4775 template<typename _Context, typename... _Args>
4776 basic_format_args(__format::_Arg_store<_Context, _Args...>)
4777 -> basic_format_args<_Context>;
4778
4779 template<typename _Context, typename... _Args>
4780 auto
4781 make_format_args(_Args&... __fmt_args) noexcept;
4782
4783 // An array of type-erased formatting arguments.
4784 template<typename _Context, typename... _Args>
4785 class __format::_Arg_store
4786 {
4787 friend std::basic_format_args<_Context>;
4788
4789 template<typename _Ctx, typename... _Argz>
4790 friend auto std::
4791#if _GLIBCXX_INLINE_VERSION
4792 __8:: // Needed for PR c++/59256
4793#endif
4794 make_format_args(_Argz&...) noexcept;
4795
4796 // For a sufficiently small number of arguments we only store values.
4797 // basic_format_args can get the types from the _Args pack.
4798 static constexpr bool _S_values_only
4799 = sizeof...(_Args) <= basic_format_args<_Context>::_S_max_packed_args;
4800
4801 using _Element_t
4802 = __conditional_t<_S_values_only,
4803 __format::_Arg_value<_Context>,
4804 basic_format_arg<_Context>>;
4805
4806 _Element_t _M_args[sizeof...(_Args)];
4807
4808 template<typename _Tp>
4809 static _Element_t
4810 _S_make_elt(_Tp& __v)
4811 {
4812 using _Tq = remove_const_t<_Tp>;
4813 using _CharT = typename _Context::char_type;
4814 static_assert(is_default_constructible_v<formatter<_Tq, _CharT>>,
4815 "std::formatter must be specialized for the type "
4816 "of each format arg");
4817 using __format::__formattable_with;
4818 if constexpr (is_const_v<_Tp>)
4819 if constexpr (!__formattable_with<_Tp, _Context>)
4820 if constexpr (__formattable_with<_Tq, _Context>)
4821 static_assert(__formattable_with<_Tp, _Context>,
4822 "format arg must be non-const because its "
4823 "std::formatter specialization has a "
4824 "non-const reference parameter");
4825 basic_format_arg<_Context> __arg(__v);
4826 if constexpr (_S_values_only)
4827 return __arg._M_val;
4828 else
4829 return __arg;
4830 }
4831
4832 template<typename... _Tp>
4833 requires (sizeof...(_Tp) == sizeof...(_Args))
4834 [[__gnu__::__always_inline__]]
4835 _Arg_store(_Tp&... __a) noexcept
4836 : _M_args{_S_make_elt(__a)...}
4837 { }
4838 };
4839
4840 template<typename _Context>
4841 class __format::_Arg_store<_Context>
4842 { };
4843
4844 template<typename _Context>
4845 template<typename... _Args>
4846 inline
4847 basic_format_args<_Context>::
4848 basic_format_args(const _Store<_Args...>& __store) noexcept
4849 {
4850 if constexpr (sizeof...(_Args) == 0)
4851 {
4852 _M_packed_size = 0;
4853 _M_unpacked_size = 0;
4854 _M_args = nullptr;
4855 }
4856 else if constexpr (sizeof...(_Args) <= _S_max_packed_args)
4857 {
4858 // The number of packed arguments:
4859 _M_packed_size = sizeof...(_Args);
4860 // The packed type enums:
4861 _M_unpacked_size
4862 = __format::__pack_arg_types<_S_packed_type_bits>(_S_types_to_pack<_Args...>());
4863 // The _Arg_value objects.
4864 _M_values = __store._M_args;
4865 }
4866 else
4867 {
4868 // No packed arguments:
4869 _M_packed_size = 0;
4870 // The number of unpacked arguments:
4871 _M_unpacked_size = sizeof...(_Args);
4872 // The basic_format_arg objects:
4873 _M_args = __store._M_args;
4874 }
4875 }
4876
4877 /// Capture formatting arguments for use by `std::vformat`.
4878 template<typename _Context = format_context, typename... _Args>
4879 [[nodiscard,__gnu__::__always_inline__]]
4880 inline auto
4881 make_format_args(_Args&... __fmt_args) noexcept
4882 {
4883 using _Fmt_arg = basic_format_arg<_Context>;
4884 using _Store = __format::_Arg_store<_Context, typename _Fmt_arg::template
4885 _Normalize<_Args>...>;
4886 return _Store(__fmt_args...);
4887 }
4888
4889#ifdef _GLIBCXX_USE_WCHAR_T
4890 /// Capture formatting arguments for use by `std::vformat` (for wide output).
4891 template<typename... _Args>
4892 [[nodiscard,__gnu__::__always_inline__]]
4893 inline auto
4894 make_wformat_args(_Args&... __args) noexcept
4895 { return std::make_format_args<wformat_context>(__args...); }
4896#endif
4897
4898/// @cond undocumented
4899namespace __format
4900{
4901 template<typename _Out, typename _CharT, typename _Context>
4902 _Out
4903 __do_vformat_to(_Out, basic_string_view<_CharT>,
4904 const basic_format_args<_Context>&,
4905 const locale* = nullptr);
4906
4907 template<typename _CharT> struct __formatter_chrono;
4908
4909} // namespace __format
4910/// @endcond
4911
4912 /** Context for std::format and similar functions.
4913 *
4914 * A formatting context contains an output iterator and locale to use
4915 * for the formatting operations. Most programs will never need to use
4916 * this class template explicitly. For typical uses of `std::format` the
4917 * library will use the specializations `std::format_context` (for `char`)
4918 * and `std::wformat_context` (for `wchar_t`).
4919 *
4920 * You are not allowed to define partial or explicit specializations of
4921 * this class template.
4922 *
4923 * @since C++20
4924 */
4925 template<typename _Out, typename _CharT>
4926 class basic_format_context
4927 {
4928 static_assert( output_iterator<_Out, const _CharT&> );
4929
4930 basic_format_args<basic_format_context> _M_args;
4931 _Out _M_out;
4932 __format::_Optional_locale _M_loc;
4933
4934 basic_format_context(basic_format_args<basic_format_context> __args,
4935 _Out __out)
4936 : _M_args(__args), _M_out(std::move(__out))
4937 { }
4938
4939 basic_format_context(basic_format_args<basic_format_context> __args,
4940 _Out __out, const std::locale& __loc)
4941 : _M_args(__args), _M_out(std::move(__out)), _M_loc(__loc)
4942 { }
4943
4944 // _GLIBCXX_RESOLVE_LIB_DEFECTS
4945 // 4061. Should std::basic_format_context be
4946 // default-constructible/copyable/movable?
4947 basic_format_context(const basic_format_context&) = delete;
4948 basic_format_context& operator=(const basic_format_context&) = delete;
4949
4950 template<typename _Out2, typename _CharT2, typename _Context2>
4951 friend _Out2
4952 __format::__do_vformat_to(_Out2, basic_string_view<_CharT2>,
4953 const basic_format_args<_Context2>&,
4954 const locale*);
4955
4956 friend __format::__formatter_chrono<_CharT>;
4957
4958 public:
4959 ~basic_format_context() = default;
4960
4961 using iterator = _Out;
4962 using char_type = _CharT;
4963 template<typename _Tp>
4964 using formatter_type = formatter<_Tp, _CharT>;
4965
4966 [[nodiscard]]
4967 basic_format_arg<basic_format_context>
4968 arg(size_t __id) const noexcept
4969 { return _M_args.get(__id); }
4970
4971 [[nodiscard]]
4972 std::locale locale() { return _M_loc.value(); }
4973
4974 [[nodiscard]]
4975 iterator out() { return std::move(_M_out); }
4976
4977 void advance_to(iterator __it) { _M_out = std::move(__it); }
4978 };
4979
4980
4981/// @cond undocumented
4982namespace __format
4983{
4984 // Abstract base class defining an interface for scanning format strings.
4985 // Scan the characters in a format string, dividing it up into strings of
4986 // ordinary characters, escape sequences, and replacement fields.
4987 // Call virtual functions for derived classes to parse format-specifiers
4988 // or write formatted output.
4989 template<typename _CharT>
4990 struct _Scanner
4991 {
4992 using iterator = typename basic_format_parse_context<_CharT>::iterator;
4993
4994 struct _Parse_context : basic_format_parse_context<_CharT>
4995 {
4996 using basic_format_parse_context<_CharT>::basic_format_parse_context;
4997 const _Arg_t* _M_types = nullptr;
4998 } _M_pc;
4999
5000 constexpr explicit
5001 _Scanner(basic_string_view<_CharT> __str, size_t __nargs = (size_t)-1)
5002 : _M_pc(__str, __nargs)
5003 { }
5004
5005 constexpr iterator begin() const noexcept { return _M_pc.begin(); }
5006 constexpr iterator end() const noexcept { return _M_pc.end(); }
5007
5008 constexpr void
5009 _M_scan()
5010 {
5011 basic_string_view<_CharT> __fmt = _M_fmt_str();
5012
5013 if (__fmt.size() == 2 && __fmt[0] == '{' && __fmt[1] == '}')
5014 {
5015 _M_pc.advance_to(begin() + 1);
5016 _M_format_arg(_M_pc.next_arg_id());
5017 return;
5018 }
5019
5020 size_t __lbr = __fmt.find('{');
5021 size_t __rbr = __fmt.find('}');
5022
5023 while (__fmt.size())
5024 {
5025 auto __cmp = __lbr <=> __rbr;
5026 if (__cmp == 0)
5027 {
5028 _M_on_chars(end());
5029 _M_pc.advance_to(end());
5030 return;
5031 }
5032 else if (__cmp < 0)
5033 {
5034 if (__lbr + 1 == __fmt.size()
5035 || (__rbr == __fmt.npos && __fmt[__lbr + 1] != '{'))
5036 __format::__unmatched_left_brace_in_format_string();
5037 const bool __is_escape = __fmt[__lbr + 1] == '{';
5038 iterator __last = begin() + __lbr + int(__is_escape);
5039 _M_on_chars(__last);
5040 _M_pc.advance_to(__last + 1);
5041 __fmt = _M_fmt_str();
5042 if (__is_escape)
5043 {
5044 if (__rbr != __fmt.npos)
5045 __rbr -= __lbr + 2;
5046 __lbr = __fmt.find('{');
5047 }
5048 else
5049 {
5050 _M_on_replacement_field();
5051 __fmt = _M_fmt_str();
5052 __lbr = __fmt.find('{');
5053 __rbr = __fmt.find('}');
5054 }
5055 }
5056 else
5057 {
5058 if (++__rbr == __fmt.size() || __fmt[__rbr] != '}')
5059 __format::__unmatched_right_brace_in_format_string();
5060 iterator __last = begin() + __rbr;
5061 _M_on_chars(__last);
5062 _M_pc.advance_to(__last + 1);
5063 __fmt = _M_fmt_str();
5064 if (__lbr != __fmt.npos)
5065 __lbr -= __rbr + 1;
5066 __rbr = __fmt.find('}');
5067 }
5068 }
5069 }
5070
5071 constexpr basic_string_view<_CharT>
5072 _M_fmt_str() const noexcept
5073 { return {begin(), end()}; }
5074
5075 constexpr virtual void _M_on_chars(iterator) { }
5076
5077 constexpr void _M_on_replacement_field()
5078 {
5079 auto __next = begin();
5080
5081 size_t __id;
5082 if (*__next == '}')
5083 __id = _M_pc.next_arg_id();
5084 else if (*__next == ':')
5085 {
5086 __id = _M_pc.next_arg_id();
5087 _M_pc.advance_to(++__next);
5088 }
5089 else
5090 {
5091 auto [__i, __ptr] = __format::__parse_arg_id(begin(), end());
5092 if (!__ptr || !(*__ptr == '}' || *__ptr == ':'))
5093 __format::__invalid_arg_id_in_format_string();
5094 _M_pc.check_arg_id(__id = __i);
5095 if (*__ptr == ':')
5096 {
5097 _M_pc.advance_to(++__ptr);
5098 }
5099 else
5100 _M_pc.advance_to(__ptr);
5101 }
5102 _M_format_arg(__id);
5103 if (begin() == end() || *begin() != '}')
5104 __format::__unmatched_left_brace_in_format_string();
5105 _M_pc.advance_to(begin() + 1); // Move past '}'
5106 }
5107
5108 constexpr virtual void _M_format_arg(size_t __id) = 0;
5109 };
5110
5111 // Process a format string and format the arguments in the context.
5112 template<typename _Out, typename _CharT>
5113 class _Formatting_scanner : public _Scanner<_CharT>
5114 {
5115 public:
5116 _Formatting_scanner(basic_format_context<_Out, _CharT>& __fc,
5117 basic_string_view<_CharT> __str)
5118 : _Scanner<_CharT>(__str), _M_fc(__fc)
5119 { }
5120
5121 private:
5122 basic_format_context<_Out, _CharT>& _M_fc;
5123
5124 using iterator = typename _Scanner<_CharT>::iterator;
5125
5126 constexpr void
5127 _M_on_chars(iterator __last) override
5128 {
5129 basic_string_view<_CharT> __str(this->begin(), __last);
5130 _M_fc.advance_to(__format::__write(_M_fc.out(), __str));
5131 }
5132
5133 constexpr void
5134 _M_format_arg(size_t __id) override
5135 {
5136 using _Context = basic_format_context<_Out, _CharT>;
5137 using handle = typename basic_format_arg<_Context>::handle;
5138
5139 __format::__visit_format_arg([this](auto& __arg) {
5140 using _Type = remove_reference_t<decltype(__arg)>;
5141 using _Formatter = typename _Context::template formatter_type<_Type>;
5142 if constexpr (is_same_v<_Type, monostate>)
5143 __format::__invalid_arg_id_in_format_string();
5144 else if constexpr (is_same_v<_Type, handle>)
5145 __arg.format(this->_M_pc, this->_M_fc);
5146 else if constexpr (is_default_constructible_v<_Formatter>)
5147 {
5148 _Formatter __f;
5149 this->_M_pc.advance_to(__f.parse(this->_M_pc));
5150 this->_M_fc.advance_to(__f.format(__arg, this->_M_fc));
5151 }
5152 else
5153 static_assert(__format::__formattable_with<_Type, _Context>);
5154 }, _M_fc.arg(__id));
5155 }
5156 };
5157
5158 template<typename _CharT, typename _Tp>
5159 consteval _Arg_t
5160 __to_arg_t_enum() noexcept
5161 {
5162 using _Context = __format::__format_context<_CharT>;
5163 using _Fmt_arg = basic_format_arg<_Context>;
5164 using _NormalizedTp = typename _Fmt_arg::template _Normalize<_Tp>;
5165 return _Fmt_arg::template _S_to_enum<_NormalizedTp>();
5166 }
5167
5168 // Validate a format string for Args.
5169 template<typename _CharT, typename... _Args>
5170 class _Checking_scanner : public _Scanner<_CharT>
5171 {
5172 static_assert(
5173 (is_default_constructible_v<formatter<_Args, _CharT>> && ...),
5174 "std::formatter must be specialized for each type being formatted");
5175
5176 public:
5177 consteval
5178 _Checking_scanner(basic_string_view<_CharT> __str)
5179 : _Scanner<_CharT>(__str, sizeof...(_Args))
5180 {
5181#if __cpp_lib_format >= 202305L
5182 this->_M_pc._M_types = _M_types.data();
5183#endif
5184 }
5185
5186 private:
5187 constexpr void
5188 _M_format_arg(size_t __id) override
5189 {
5190 if constexpr (sizeof...(_Args) != 0)
5191 {
5192 if (__id < sizeof...(_Args))
5193 {
5194 _M_parse_format_spec<_Args...>(__id);
5195 return;
5196 }
5197 }
5198 __builtin_unreachable();
5199 }
5200
5201 template<typename _Tp, typename... _OtherArgs>
5202 constexpr void
5203 _M_parse_format_spec(size_t __id)
5204 {
5205 if (__id == 0)
5206 {
5207 formatter<_Tp, _CharT> __f;
5208 this->_M_pc.advance_to(__f.parse(this->_M_pc));
5209 }
5210 else if constexpr (sizeof...(_OtherArgs) != 0)
5211 _M_parse_format_spec<_OtherArgs...>(__id - 1);
5212 else
5213 __builtin_unreachable();
5214 }
5215
5216#if __cpp_lib_format >= 202305L
5217 array<_Arg_t, sizeof...(_Args)>
5218 _M_types{ { __format::__to_arg_t_enum<_CharT, _Args>()... } };
5219#endif
5220 };
5221
5222 template<typename _CharT, unsigned = __unicode::__literal_encoding_is_unicode<_CharT>()>
5223 _Sink_iter<_CharT>
5224 __do_vformat_to(_Sink_iter<_CharT> __out, basic_string_view<_CharT> __fmt,
5225 __format_context<_CharT>& __ctx)
5226 {
5227 if constexpr (is_same_v<_CharT, char>)
5228 // Fast path for "{}" format strings and simple format arg types.
5229 if (__fmt.size() == 2 && __fmt[0] == '{' && __fmt[1] == '}')
5230 {
5231 bool __done = false;
5232 __format::__visit_format_arg([&](auto& __arg) {
5233 using _Tp = remove_cvref_t<decltype(__arg)>;
5234 if constexpr (is_same_v<_Tp, bool>)
5235 {
5236 size_t __len = 4 + !__arg;
5237 const char* __chars[] = { "false", "true" };
5238 if (auto __res = __out._M_reserve(__len))
5239 {
5240 __builtin_memcpy(__res.get(), __chars[__arg], __len);
5241 __res._M_bump(__len);
5242 __done = true;
5243 }
5244 }
5245 else if constexpr (is_same_v<_Tp, char>)
5246 {
5247 if (auto __res = __out._M_reserve(1))
5248 {
5249 *__res.get() = __arg;
5250 __res._M_bump(1);
5251 __done = true;
5252 }
5253 }
5254 else if constexpr (is_integral_v<_Tp>)
5255 {
5256 make_unsigned_t<_Tp> __uval;
5257 const bool __neg = __arg < 0;
5258 if (__neg)
5259 __uval = make_unsigned_t<_Tp>(~__arg) + 1u;
5260 else
5261 __uval = __arg;
5262 const auto __n = __detail::__to_chars_len(__uval);
5263 if (auto __res = __out._M_reserve(__n + __neg))
5264 {
5265 auto __ptr = __res.get();
5266 *__ptr = '-';
5267 __detail::__to_chars_10_impl(__ptr + (int)__neg, __n,
5268 __uval);
5269 __res._M_bump(__n + __neg);
5270 __done = true;
5271 }
5272 }
5273 else if constexpr (is_convertible_v<_Tp, string_view>)
5274 {
5275 string_view __sv = __arg;
5276 if (auto __res = __out._M_reserve(__sv.size()))
5277 {
5278 __builtin_memcpy(__res.get(), __sv.data(), __sv.size());
5279 __res._M_bump(__sv.size());
5280 __done = true;
5281 }
5282 }
5283 }, __ctx.arg(0));
5284
5285 if (__done)
5286 return __out;
5287 }
5288
5289 _Formatting_scanner<_Sink_iter<_CharT>, _CharT> __scanner(__ctx, __fmt);
5290 __scanner._M_scan();
5291 return __out;
5292 }
5293
5294// The behavior of the formatters (interpretation of fill character) depends
5295// on the literal encoding. As explicit instantiation of __do_vformat_to
5296// instantiates formatters for types stored in basic_format_arg, we can
5297// support only single encoding, in this case unicode. This should cover
5298// most common use cases.
5299#if __cplusplus <= 202002L && _GLIBCXX_EXTERN_TEMPLATE > 0
5300 extern template _Sink_iter<char>
5301 __do_vformat_to<char, 1>(_Sink_iter<char>, string_view,
5302 format_context&);
5303# ifdef _GLIBCXX_USE_WCHAR_T
5304 extern template _Sink_iter<wchar_t>
5305 __do_vformat_to<wchar_t, 1>(_Sink_iter<wchar_t>, wstring_view,
5306 wformat_context&);
5307# endif
5308#endif
5309
5310 template<typename _Out, typename _CharT, typename _Context>
5311 inline _Out
5312 __do_vformat_to(_Out __out, basic_string_view<_CharT> __fmt,
5313 const basic_format_args<_Context>& __args,
5314 const locale* __loc)
5315 {
5316 if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
5317 {
5318 auto __ctx = __loc == nullptr
5319 ? _Context(__args, __out)
5320 : _Context(__args, __out, *__loc);
5321 return __format::__do_vformat_to(__out, __fmt, __ctx);
5322 }
5323 else if constexpr (__contiguous_char_iter<_CharT, _Out>)
5324 {
5325 _Ptr_sink<_CharT> __sink(__out);
5326 __format::__do_vformat_to(__sink.out(), __fmt, __args, __loc);
5327 return std::move(__sink)._M_finish(__out).out;
5328 }
5329 else
5330 {
5331 _Iter_sink<_CharT, _Out> __sink(std::move(__out));
5332 __format::__do_vformat_to(__sink.out(), __fmt, __args, __loc);
5333 return std::move(__sink)._M_finish().out;
5334 }
5335 }
5336
5337 template<typename _Out, typename _CharT>
5338 inline format_to_n_result<_Out>
5339 __do_vformat_to_n(_Out __out, iter_difference_t<_Out> __n,
5340 basic_string_view<_CharT> __fmt,
5341 const type_identity_t<
5342 basic_format_args<__format_context<_CharT>>>& __args,
5343 const locale* __loc = nullptr)
5344 {
5345 if constexpr (__contiguous_char_iter<_CharT, _Out>)
5346 {
5347 _Ptr_sink<_CharT> __sink(__out, __n);
5348 __format::__do_vformat_to(__sink.out(), __fmt, __args, __loc);
5349 return std::move(__sink)._M_finish(__out);
5350 }
5351 else
5352 {
5353 _Iter_sink<_CharT, _Out> __sink(std::move(__out), __n);
5354 __format::__do_vformat_to(__sink.out(), __fmt, __args, __loc);
5355 return std::move(__sink)._M_finish();
5356 }
5357 }
5358
5359#pragma GCC diagnostic pop
5360
5361} // namespace __format
5362/// @endcond
5363
5364#if __cpp_lib_format >= 202305L // >= C++26
5365 /// @cond undocumented
5366 // Common implementation of check_dynamic_spec{,_string,_integral}
5367 template<typename _CharT>
5368 template<typename... _Ts>
5369 consteval void
5370 basic_format_parse_context<_CharT>::
5371 __check_dynamic_spec(size_t __id) noexcept
5372 {
5373 if (__id >= _M_num_args)
5374 __format::__invalid_arg_id_in_format_string();
5375 if constexpr (sizeof...(_Ts) != 0)
5376 {
5377 using _Parse_ctx = __format::_Scanner<_CharT>::_Parse_context;
5378 auto __arg = static_cast<_Parse_ctx*>(this)->_M_types[__id];
5379 __format::_Arg_t __types[] = {
5380 __format::__to_arg_t_enum<_CharT, _Ts>()...
5381 };
5382 for (auto __t : __types)
5383 if (__arg == __t)
5384 return;
5385 }
5386 __invalid_dynamic_spec("arg(id) type does not match");
5387 }
5388 /// @endcond
5389#endif
5390
5391 template<typename _CharT, typename... _Args>
5392 template<typename _Tp>
5393 requires convertible_to<const _Tp&, basic_string_view<_CharT>>
5394 consteval
5395 basic_format_string<_CharT, _Args...>::
5396 basic_format_string(const _Tp& __s)
5397 : _M_str(__s)
5398 {
5399 __format::_Checking_scanner<_CharT, remove_cvref_t<_Args>...>
5400 __scanner(_M_str);
5401 __scanner._M_scan();
5402 }
5403
5404 // [format.functions], formatting functions
5405
5406 template<typename _Out> requires output_iterator<_Out, const char&>
5407 [[__gnu__::__always_inline__]]
5408 inline _Out
5409 vformat_to(_Out __out, string_view __fmt, format_args __args)
5410 { return __format::__do_vformat_to(std::move(__out), __fmt, __args); }
5411
5412#ifdef _GLIBCXX_USE_WCHAR_T
5413 template<typename _Out> requires output_iterator<_Out, const wchar_t&>
5414 [[__gnu__::__always_inline__]]
5415 inline _Out
5416 vformat_to(_Out __out, wstring_view __fmt, wformat_args __args)
5417 { return __format::__do_vformat_to(std::move(__out), __fmt, __args); }
5418#endif
5419
5420 template<typename _Out> requires output_iterator<_Out, const char&>
5421 [[__gnu__::__always_inline__]]
5422 inline _Out
5423 vformat_to(_Out __out, const locale& __loc, string_view __fmt,
5424 format_args __args)
5425 {
5426 return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc);
5427 }
5428
5429#ifdef _GLIBCXX_USE_WCHAR_T
5430 template<typename _Out> requires output_iterator<_Out, const wchar_t&>
5431 [[__gnu__::__always_inline__]]
5432 inline _Out
5433 vformat_to(_Out __out, const locale& __loc, wstring_view __fmt,
5434 wformat_args __args)
5435 {
5436 return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc);
5437 }
5438#endif
5439
5440 [[nodiscard]]
5441 inline string
5442 vformat(string_view __fmt, format_args __args)
5443 {
5444 __format::_Str_sink<char> __buf;
5445 std::vformat_to(__buf.out(), __fmt, __args);
5446 return std::move(__buf).get();
5447 }
5448
5449#ifdef _GLIBCXX_USE_WCHAR_T
5450 [[nodiscard]]
5451 inline wstring
5452 vformat(wstring_view __fmt, wformat_args __args)
5453 {
5454 __format::_Str_sink<wchar_t> __buf;
5455 std::vformat_to(__buf.out(), __fmt, __args);
5456 return std::move(__buf).get();
5457 }
5458#endif
5459
5460 [[nodiscard]]
5461 inline string
5462 vformat(const locale& __loc, string_view __fmt, format_args __args)
5463 {
5464 __format::_Str_sink<char> __buf;
5465 std::vformat_to(__buf.out(), __loc, __fmt, __args);
5466 return std::move(__buf).get();
5467 }
5468
5469#ifdef _GLIBCXX_USE_WCHAR_T
5470 [[nodiscard]]
5471 inline wstring
5472 vformat(const locale& __loc, wstring_view __fmt, wformat_args __args)
5473 {
5474 __format::_Str_sink<wchar_t> __buf;
5475 std::vformat_to(__buf.out(), __loc, __fmt, __args);
5476 return std::move(__buf).get();
5477 }
5478#endif
5479
5480 template<typename... _Args>
5481 [[nodiscard]]
5482 inline string
5483 format(format_string<_Args...> __fmt, _Args&&... __args)
5484 { return std::vformat(__fmt.get(), std::make_format_args(__args...)); }
5485
5486#ifdef _GLIBCXX_USE_WCHAR_T
5487 template<typename... _Args>
5488 [[nodiscard]]
5489 inline wstring
5490 format(wformat_string<_Args...> __fmt, _Args&&... __args)
5491 { return std::vformat(__fmt.get(), std::make_wformat_args(__args...)); }
5492#endif
5493
5494 template<typename... _Args>
5495 [[nodiscard]]
5496 inline string
5497 format(const locale& __loc, format_string<_Args...> __fmt,
5498 _Args&&... __args)
5499 {
5500 return std::vformat(__loc, __fmt.get(),
5501 std::make_format_args(__args...));
5502 }
5503
5504#ifdef _GLIBCXX_USE_WCHAR_T
5505 template<typename... _Args>
5506 [[nodiscard]]
5507 inline wstring
5508 format(const locale& __loc, wformat_string<_Args...> __fmt,
5509 _Args&&... __args)
5510 {
5511 return std::vformat(__loc, __fmt.get(),
5512 std::make_wformat_args(__args...));
5513 }
5514#endif
5515
5516 template<typename _Out, typename... _Args>
5517 requires output_iterator<_Out, const char&>
5518 inline _Out
5519 format_to(_Out __out, format_string<_Args...> __fmt, _Args&&... __args)
5520 {
5521 return std::vformat_to(std::move(__out), __fmt.get(),
5522 std::make_format_args(__args...));
5523 }
5524
5525#ifdef _GLIBCXX_USE_WCHAR_T
5526 template<typename _Out, typename... _Args>
5527 requires output_iterator<_Out, const wchar_t&>
5528 inline _Out
5529 format_to(_Out __out, wformat_string<_Args...> __fmt, _Args&&... __args)
5530 {
5531 return std::vformat_to(std::move(__out), __fmt.get(),
5532 std::make_wformat_args(__args...));
5533 }
5534#endif
5535
5536 template<typename _Out, typename... _Args>
5537 requires output_iterator<_Out, const char&>
5538 inline _Out
5539 format_to(_Out __out, const locale& __loc, format_string<_Args...> __fmt,
5540 _Args&&... __args)
5541 {
5542 return std::vformat_to(std::move(__out), __loc, __fmt.get(),
5543 std::make_format_args(__args...));
5544 }
5545
5546#ifdef _GLIBCXX_USE_WCHAR_T
5547 template<typename _Out, typename... _Args>
5548 requires output_iterator<_Out, const wchar_t&>
5549 inline _Out
5550 format_to(_Out __out, const locale& __loc, wformat_string<_Args...> __fmt,
5551 _Args&&... __args)
5552 {
5553 return std::vformat_to(std::move(__out), __loc, __fmt.get(),
5554 std::make_wformat_args(__args...));
5555 }
5556#endif
5557
5558 template<typename _Out, typename... _Args>
5559 requires output_iterator<_Out, const char&>
5560 inline format_to_n_result<_Out>
5561 format_to_n(_Out __out, iter_difference_t<_Out> __n,
5562 format_string<_Args...> __fmt, _Args&&... __args)
5563 {
5564 return __format::__do_vformat_to_n(
5565 std::move(__out), __n, __fmt.get(),
5566 std::make_format_args(__args...));
5567 }
5568
5569#ifdef _GLIBCXX_USE_WCHAR_T
5570 template<typename _Out, typename... _Args>
5571 requires output_iterator<_Out, const wchar_t&>
5572 inline format_to_n_result<_Out>
5573 format_to_n(_Out __out, iter_difference_t<_Out> __n,
5574 wformat_string<_Args...> __fmt, _Args&&... __args)
5575 {
5576 return __format::__do_vformat_to_n(
5577 std::move(__out), __n, __fmt.get(),
5578 std::make_wformat_args(__args...));
5579 }
5580#endif
5581
5582 template<typename _Out, typename... _Args>
5583 requires output_iterator<_Out, const char&>
5584 inline format_to_n_result<_Out>
5585 format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
5586 format_string<_Args...> __fmt, _Args&&... __args)
5587 {
5588 return __format::__do_vformat_to_n(
5589 std::move(__out), __n, __fmt.get(),
5590 std::make_format_args(__args...), &__loc);
5591 }
5592
5593#ifdef _GLIBCXX_USE_WCHAR_T
5594 template<typename _Out, typename... _Args>
5595 requires output_iterator<_Out, const wchar_t&>
5596 inline format_to_n_result<_Out>
5597 format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
5598 wformat_string<_Args...> __fmt, _Args&&... __args)
5599 {
5600 return __format::__do_vformat_to_n(
5601 std::move(__out), __n, __fmt.get(),
5602 std::make_wformat_args(__args...), &__loc);
5603 }
5604#endif
5605
5606/// @cond undocumented
5607namespace __format
5608{
5609#if 1
5610 template<typename _CharT>
5611 class _Counting_sink final : public _Ptr_sink<_CharT>
5612 {
5613 public:
5614 _Counting_sink() : _Ptr_sink<_CharT>(nullptr, 0) { }
5615
5616 [[__gnu__::__always_inline__]]
5617 size_t
5618 count() const
5619 { return this->_M_count + this->_M_used().size(); }
5620 };
5621#else
5622 template<typename _CharT>
5623 class _Counting_sink : public _Buf_sink<_CharT>
5624 {
5625 size_t _M_count = 0;
5626
5627 void
5628 _M_overflow() override
5629 {
5630 if (!std::is_constant_evaluated())
5631 _M_count += this->_M_used().size();
5632 this->_M_rewind();
5633 }
5634
5635 public:
5636 _Counting_sink() = default;
5637
5638 [[__gnu__::__always_inline__]]
5639 size_t
5640 count() noexcept
5641 {
5642 _Counting_sink::_M_overflow();
5643 return _M_count;
5644 }
5645 };
5646#endif
5647} // namespace __format
5648/// @endcond
5649
5650 template<typename... _Args>
5651 [[nodiscard]]
5652 inline size_t
5653 formatted_size(format_string<_Args...> __fmt, _Args&&... __args)
5654 {
5655 __format::_Counting_sink<char> __buf;
5656 std::vformat_to(__buf.out(), __fmt.get(),
5657 std::make_format_args(__args...));
5658 return __buf.count();
5659 }
5660
5661#ifdef _GLIBCXX_USE_WCHAR_T
5662 template<typename... _Args>
5663 [[nodiscard]]
5664 inline size_t
5665 formatted_size(wformat_string<_Args...> __fmt, _Args&&... __args)
5666 {
5667 __format::_Counting_sink<wchar_t> __buf;
5668 std::vformat_to(__buf.out(), __fmt.get(),
5669 std::make_wformat_args(__args...));
5670 return __buf.count();
5671 }
5672#endif
5673
5674 template<typename... _Args>
5675 [[nodiscard]]
5676 inline size_t
5677 formatted_size(const locale& __loc, format_string<_Args...> __fmt,
5678 _Args&&... __args)
5679 {
5680 __format::_Counting_sink<char> __buf;
5681 std::vformat_to(__buf.out(), __loc, __fmt.get(),
5682 std::make_format_args(__args...));
5683 return __buf.count();
5684 }
5685
5686#ifdef _GLIBCXX_USE_WCHAR_T
5687 template<typename... _Args>
5688 [[nodiscard]]
5689 inline size_t
5690 formatted_size(const locale& __loc, wformat_string<_Args...> __fmt,
5691 _Args&&... __args)
5692 {
5693 __format::_Counting_sink<wchar_t> __buf;
5694 std::vformat_to(__buf.out(), __loc, __fmt.get(),
5695 std::make_wformat_args(__args...));
5696 return __buf.count();
5697 }
5698#endif
5699
5700#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
5701 /// @cond undocumented
5702 template<typename _Tp>
5703 consteval range_format
5704 __fmt_kind()
5705 {
5706 using _Ref = ranges::range_reference_t<_Tp>;
5707 if constexpr (is_same_v<remove_cvref_t<_Ref>, _Tp>)
5708 return range_format::disabled;
5709 else if constexpr (requires { typename _Tp::key_type; })
5710 {
5711 if constexpr (requires { typename _Tp::mapped_type; })
5712 {
5713 using _Up = remove_cvref_t<_Ref>;
5714 if constexpr (__is_pair<_Up>)
5715 return range_format::map;
5716 else if constexpr (__is_specialization_of<_Up, tuple>)
5717 if constexpr (tuple_size_v<_Up> == 2)
5718 return range_format::map;
5719 }
5720 return range_format::set;
5721 }
5722 else
5723 return range_format::sequence;
5724 }
5725 /// @endcond
5726
5727 /// A constant determining how a range should be formatted.
5728 template<ranges::input_range _Rg> requires same_as<_Rg, remove_cvref_t<_Rg>>
5729 constexpr range_format format_kind<_Rg> = __fmt_kind<_Rg>();
5730
5731/// @cond undocumented
5732namespace __format
5733{
5734 template<typename _CharT, typename _Out, typename _Callback>
5735 typename basic_format_context<_Out, _CharT>::iterator
5736 __format_padded(basic_format_context<_Out, _CharT>& __fc,
5737 const _Spec<_CharT>& __spec,
5738 _Callback&& __call)
5739 {
5740 if constexpr (is_same_v<_Out, _Drop_iter<_CharT>>)
5741 return __fc.out();
5742 else
5743 {
5744 // This is required to implement formatting with padding,
5745 // as we need to format to temporary buffer, using the same iterator.
5746 static_assert(is_same_v<_Out, _Sink_iter<_CharT>>);
5747
5748 const size_t __padwidth = __spec._M_get_width(__fc);
5749 if (__padwidth == 0)
5750 return __call(__fc);
5751
5752 struct _Restore_out
5753 {
5754 _Restore_out(basic_format_context<_Sink_iter<_CharT>, _CharT>& __fc)
5755 : _M_ctx(std::addressof(__fc)), _M_out(__fc.out())
5756 { }
5757
5758 void
5759 _M_disarm()
5760 { _M_ctx = nullptr; }
5761
5762 ~_Restore_out()
5763 {
5764 if (_M_ctx)
5765 _M_ctx->advance_to(_M_out);
5766 }
5767
5768 private:
5769 basic_format_context<_Sink_iter<_CharT>, _CharT>* _M_ctx;
5770 _Sink_iter<_CharT> _M_out;
5771 };
5772
5773 _Restore_out __restore(__fc);
5774 _Padding_sink<_Sink_iter<_CharT>, _CharT> __sink(__fc.out(), __padwidth);
5775 __fc.advance_to(__sink.out());
5776 __call(__fc);
5777 __fc.advance_to(__sink._M_finish(__spec._M_align, __spec._M_fill));
5778 __restore._M_disarm();
5779 return __fc.out();
5780 }
5781 }
5782
5783 template<size_t _Pos, typename _Tp, typename _CharT>
5784 struct __indexed_formatter_storage
5785 {
5786 constexpr void
5787 _M_parse()
5788 {
5789 basic_format_parse_context<_CharT> __pc({});
5790 if (_M_formatter.parse(__pc) != __pc.end())
5791 __format::__failed_to_parse_format_spec();
5792 }
5793
5794 template<typename _Out>
5795 void
5796 _M_format(__maybe_const<_Tp, _CharT>& __elem,
5797 basic_format_context<_Out, _CharT>& __fc,
5798 basic_string_view<_CharT> __sep) const
5799 {
5800 if constexpr (_Pos != 0)
5801 __fc.advance_to(__format::__write(__fc.out(), __sep));
5802 __fc.advance_to(_M_formatter.format(__elem, __fc));
5803 }
5804
5805 [[__gnu__::__always_inline__]]
5806 constexpr void
5807 set_debug_format()
5808 {
5809 if constexpr (__has_debug_format<formatter<_Tp, _CharT>>)
5810 _M_formatter.set_debug_format();
5811 }
5812
5813 private:
5814 formatter<_Tp, _CharT> _M_formatter;
5815 };
5816
5817 template<typename _CharT, typename... _Tps>
5818 class __tuple_formatter
5819 {
5820 using _String_view = basic_string_view<_CharT>;
5821 using _Seps = __format::_Separators<_CharT>;
5822
5823 public:
5824 constexpr void
5825 set_separator(basic_string_view<_CharT> __sep) noexcept
5826 { _M_sep = __sep; }
5827
5828 constexpr void
5829 set_brackets(basic_string_view<_CharT> __open,
5830 basic_string_view<_CharT> __close) noexcept
5831 {
5832 _M_open = __open;
5833 _M_close = __close;
5834 }
5835
5836 // We deviate from standard, that declares this as template accepting
5837 // unconstrained ParseContext type, which seems unimplementable.
5838 constexpr typename basic_format_parse_context<_CharT>::iterator
5839 parse(basic_format_parse_context<_CharT>& __pc)
5840 {
5841 auto __first = __pc.begin();
5842 const auto __last = __pc.end();
5843 __format::_Spec<_CharT> __spec{};
5844
5845 auto __finished = [&]
5846 {
5847 if (__first != __last && *__first != '}')
5848 return false;
5849
5850 _M_spec = __spec;
5851 _M_felems._M_parse();
5852 _M_felems.set_debug_format();
5853 return true;
5854 };
5855
5856 if (__finished())
5857 return __first;
5858
5859 __first = __spec._M_parse_fill_and_align(__first, __last, "{:");
5860 if (__finished())
5861 return __first;
5862
5863 __first = __spec._M_parse_width(__first, __last, __pc);
5864 if (__finished())
5865 return __first;
5866
5867 if (*__first == 'n')
5868 {
5869 ++__first;
5870 _M_open = _M_close = _String_view();
5871 }
5872 else if (*__first == 'm')
5873 {
5874 ++__first;
5875 if constexpr (sizeof...(_Tps) == 2)
5876 {
5877 _M_sep = _Seps::_S_colon();
5878 _M_open = _M_close = _String_view();
5879 }
5880 else
5881 __throw_format_error("format error: 'm' specifier requires range"
5882 " of pair or tuple of two elements");
5883 }
5884
5885 if (__finished())
5886 return __first;
5887
5888 __format::__failed_to_parse_format_spec();
5889 }
5890
5891 protected:
5892 template<typename _Tuple, typename _Out, size_t... _Ids>
5893 typename basic_format_context<_Out, _CharT>::iterator
5894 _M_format(_Tuple& __tuple, index_sequence<_Ids...>,
5895 basic_format_context<_Out, _CharT>& __fc) const
5896 { return _M_format_elems(std::get<_Ids>(__tuple)..., __fc); }
5897
5898 template<typename _Out>
5899 typename basic_format_context<_Out, _CharT>::iterator
5900 _M_format_elems(__maybe_const<_Tps, _CharT>&... __elems,
5901 basic_format_context<_Out, _CharT>& __fc) const
5902 {
5903 return __format::__format_padded(
5904 __fc, _M_spec,
5905 [this, &__elems...](basic_format_context<_Out, _CharT>& __nfc)
5906 {
5907 __nfc.advance_to(__format::__write(__nfc.out(), _M_open));
5908 _M_felems._M_format(__elems..., __nfc, _M_sep);
5909 return __format::__write(__nfc.out(), _M_close);
5910 });
5911 }
5912
5913 private:
5914 template<size_t... _Ids>
5915 struct __formatters_storage
5916 : __indexed_formatter_storage<_Ids, _Tps, _CharT>...
5917 {
5918 template<size_t _Id, typename _Up>
5919 using _Base = __indexed_formatter_storage<_Id, _Up, _CharT>;
5920
5921 constexpr void
5922 _M_parse()
5923 {
5924 (_Base<_Ids, _Tps>::_M_parse(), ...);
5925 }
5926
5927 template<typename _Out>
5928 void
5929 _M_format(__maybe_const<_Tps, _CharT>&... __elems,
5930 basic_format_context<_Out, _CharT>& __fc,
5931 _String_view __sep) const
5932 {
5933 (_Base<_Ids, _Tps>::_M_format(__elems, __fc, __sep), ...);
5934 }
5935
5936 constexpr void
5937 set_debug_format()
5938 {
5939 (_Base<_Ids, _Tps>::set_debug_format(), ...);
5940 }
5941 };
5942
5943 template<size_t... _Ids>
5944 static auto
5945 _S_create_storage(index_sequence<_Ids...>)
5946 -> __formatters_storage<_Ids...>;
5947 using _Formatters
5948 = decltype(_S_create_storage(index_sequence_for<_Tps...>()));
5949
5950 _Spec<_CharT> _M_spec{};
5951 _String_view _M_open = _Seps::_S_parens().substr(0, 1);
5952 _String_view _M_close = _Seps::_S_parens().substr(1, 1);
5953 _String_view _M_sep = _Seps::_S_comma();
5954 _Formatters _M_felems;
5955 };
5956
5957 template<typename _Tp>
5958 concept __is_map_formattable
5959 = __is_pair<_Tp> || (__is_tuple_v<_Tp> && tuple_size_v<_Tp> == 2);
5960
5961} // namespace __format
5962/// @endcond
5963
5964 // [format.tuple] Tuple formatter
5965 template<__format::__char _CharT, formattable<_CharT> _Fp,
5966 formattable<_CharT> _Sp>
5967 struct formatter<pair<_Fp, _Sp>, _CharT>
5968 : __format::__tuple_formatter<_CharT, remove_cvref_t<_Fp>,
5969 remove_cvref_t<_Sp>>
5970 {
5971 private:
5972 using __maybe_const_pair
5973 = __conditional_t<formattable<const _Fp, _CharT>
5974 && formattable<const _Sp, _CharT>,
5975 const pair<_Fp, _Sp>, pair<_Fp, _Sp>>;
5976 public:
5977 // We deviate from standard, that declares this as template accepting
5978 // unconstrained FormatContext type, which seems unimplementable.
5979 template<typename _Out>
5980 typename basic_format_context<_Out, _CharT>::iterator
5981 format(__maybe_const_pair& __p,
5982 basic_format_context<_Out, _CharT>& __fc) const
5983 { return this->_M_format_elems(__p.first, __p.second, __fc); }
5984 };
5985
5986#if __glibcxx_print >= 202406L
5987 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5988 // 4399. enable_nonlocking_formatter_optimization for pair and tuple needs remove_cvref_t
5989 template<typename _Fp, typename _Sp>
5990 constexpr bool enable_nonlocking_formatter_optimization<pair<_Fp, _Sp>>
5991 = enable_nonlocking_formatter_optimization<remove_cvref_t<_Fp>>
5992 && enable_nonlocking_formatter_optimization<remove_cvref_t<_Sp>>;
5993#endif
5994
5995 template<__format::__char _CharT, formattable<_CharT>... _Tps>
5996 struct formatter<tuple<_Tps...>, _CharT>
5997 : __format::__tuple_formatter<_CharT, remove_cvref_t<_Tps>...>
5998 {
5999 private:
6000 using __maybe_const_tuple
6001 = __conditional_t<(formattable<const _Tps, _CharT> && ...),
6002 const tuple<_Tps...>, tuple<_Tps...>>;
6003 public:
6004 // We deviate from standard, that declares this as template accepting
6005 // unconstrained FormatContext type, which seems unimplementable.
6006 template<typename _Out>
6007 typename basic_format_context<_Out, _CharT>::iterator
6008 format(__maybe_const_tuple& __t,
6009 basic_format_context<_Out, _CharT>& __fc) const
6010 { return this->_M_format(__t, index_sequence_for<_Tps...>(), __fc); }
6011 };
6012
6013#if __glibcxx_print >= 202406L
6014 // _GLIBCXX_RESOLVE_LIB_DEFECTS
6015 // 4399. enable_nonlocking_formatter_optimization for pair and tuple needs remove_cvref_t
6016 template<typename... _Tps>
6017 constexpr bool enable_nonlocking_formatter_optimization<tuple<_Tps...>>
6018 = (enable_nonlocking_formatter_optimization<remove_cvref_t<_Tps>> && ...);
6019#endif
6020
6021 // [format.range.formatter], class template range_formatter
6022 template<typename _Tp, __format::__char _CharT>
6023 requires same_as<remove_cvref_t<_Tp>, _Tp> && formattable<_Tp, _CharT>
6024 class range_formatter
6025 {
6026 using _String_view = basic_string_view<_CharT>;
6027 using _Seps = __format::_Separators<_CharT>;
6028
6029 public:
6030 constexpr void
6031 set_separator(basic_string_view<_CharT> __sep) noexcept
6032 { _M_sep = __sep; }
6033
6034 constexpr void
6035 set_brackets(basic_string_view<_CharT> __open,
6036 basic_string_view<_CharT> __close) noexcept
6037 {
6038 _M_open = __open;
6039 _M_close = __close;
6040 }
6041
6042 constexpr formatter<_Tp, _CharT>&
6043 underlying() noexcept
6044 { return _M_fval; }
6045
6046 constexpr const formatter<_Tp, _CharT>&
6047 underlying() const noexcept
6048 { return _M_fval; }
6049
6050 // We deviate from standard, that declares this as template accepting
6051 // unconstrained ParseContext type, which seems unimplementable.
6052 constexpr typename basic_format_parse_context<_CharT>::iterator
6053 parse(basic_format_parse_context<_CharT>& __pc)
6054 {
6055 auto __first = __pc.begin();
6056 const auto __last = __pc.end();
6057 __format::_Spec<_CharT> __spec{};
6058 bool __no_brace = false;
6059
6060 auto __finished = [&]
6061 { return __first == __last || *__first == '}'; };
6062
6063 auto __finalize = [&]
6064 {
6065 _M_spec = __spec;
6066 return __first;
6067 };
6068
6069 auto __parse_val = [&](_String_view __nfs = _String_view())
6070 {
6071 basic_format_parse_context<_CharT> __npc(__nfs);
6072 if (_M_fval.parse(__npc) != __npc.end())
6073 __format::__failed_to_parse_format_spec();
6074 if constexpr (__format::__has_debug_format<formatter<_Tp, _CharT>>)
6075 _M_fval.set_debug_format();
6076 return __finalize();
6077 };
6078
6079 if (__finished())
6080 return __parse_val();
6081
6082 __first = __spec._M_parse_fill_and_align(__first, __last, "{:");
6083 if (__finished())
6084 return __parse_val();
6085
6086 __first = __spec._M_parse_width(__first, __last, __pc);
6087 if (__finished())
6088 return __parse_val();
6089
6090 if (*__first == '?')
6091 {
6092 ++__first;
6093 __spec._M_debug = true;
6094 if (__finished() || *__first != 's')
6095 __throw_format_error("format error: '?' is allowed only in"
6096 " combination with 's'");
6097 }
6098
6099 if (*__first == 's')
6100 {
6101 ++__first;
6102 if constexpr (same_as<_Tp, _CharT>)
6103 {
6104 __spec._M_type = __format::_Pres_s;
6105 if (__finished())
6106 return __finalize();
6107 __throw_format_error("format error: element format specifier"
6108 " cannot be provided when 's' specifier is used");
6109 }
6110 else
6111 __throw_format_error("format error: 's' specifier requires"
6112 " range of character types");
6113 }
6114
6115 if (__finished())
6116 return __parse_val();
6117
6118 if (*__first == 'n')
6119 {
6120 ++__first;
6121 _M_open = _M_close = _String_view();
6122 __no_brace = true;
6123 }
6124
6125 if (__finished())
6126 return __parse_val();
6127
6128 if (*__first == 'm')
6129 {
6130 _String_view __m(__first, 1);
6131 ++__first;
6132 if constexpr (__format::__is_map_formattable<_Tp>)
6133 {
6134 _M_sep = _Seps::_S_comma();
6135 if (!__no_brace)
6136 {
6137 _M_open = _Seps::_S_braces().substr(0, 1);
6138 _M_close = _Seps::_S_braces().substr(1, 1);
6139 }
6140 if (__finished())
6141 return __parse_val(__m);
6142 __throw_format_error("format error: element format specifier"
6143 " cannot be provided when 'm' specifier is used");
6144 }
6145 else
6146 __throw_format_error("format error: 'm' specifier requires"
6147 " range of pairs or tuples of two elements");
6148 }
6149
6150 if (__finished())
6151 return __parse_val();
6152
6153 if (*__first == ':')
6154 {
6155 __pc.advance_to(++__first);
6156 __first = _M_fval.parse(__pc);
6157 }
6158
6159 if (__finished())
6160 return __finalize();
6161
6162 __format::__failed_to_parse_format_spec();
6163 }
6164
6165 // We deviate from standard, that declares this as template accepting
6166 // unconstrained FormatContext type, which seems unimplementable.
6167 template<ranges::input_range _Rg, typename _Out>
6168 requires formattable<ranges::range_reference_t<_Rg>, _CharT> &&
6169 same_as<remove_cvref_t<ranges::range_reference_t<_Rg>>, _Tp>
6170 typename basic_format_context<_Out, _CharT>::iterator
6171 format(_Rg&& __rg, basic_format_context<_Out, _CharT>& __fc) const
6172 {
6173 using _Range = remove_reference_t<_Rg>;
6174 if constexpr (__format::__simply_formattable_range<_Range, _CharT>)
6175 return _M_format<const _Range>(__rg, __fc);
6176 else
6177 return _M_format(__rg, __fc);
6178 }
6179
6180 private:
6181 template<ranges::input_range _Rg, typename _Out>
6182 typename basic_format_context<_Out, _CharT>::iterator
6183 _M_format(_Rg& __rg, basic_format_context<_Out, _CharT>& __fc) const
6184 {
6185 if constexpr (same_as<_Tp, _CharT>)
6186 if (_M_spec._M_type == __format::_Pres_s)
6187 {
6188 __format::__formatter_str __fstr(_M_spec);
6189 return __fstr._M_format_range(__rg, __fc);
6190 }
6191 return __format::__format_padded(
6192 __fc, _M_spec,
6193 [this, &__rg](basic_format_context<_Out, _CharT>& __nfc)
6194 { return _M_format_elems(__rg, __nfc); });
6195 }
6196
6197
6198 template<ranges::input_range _Rg, typename _Out>
6199 typename basic_format_context<_Out, _CharT>::iterator
6200 _M_format_elems(_Rg& __rg,
6201 basic_format_context<_Out, _CharT>& __fc) const
6202 {
6203 auto __out = __format::__write(__fc.out(), _M_open);
6204
6205 auto __first = ranges::begin(__rg);
6206 auto const __last = ranges::end(__rg);
6207 if (__first == __last)
6208 return __format::__write(__out, _M_close);
6209
6210 __fc.advance_to(__out);
6211 __out = _M_fval.format(*__first, __fc);
6212 for (++__first; __first != __last; ++__first)
6213 {
6214 __out = __format::__write(__out, _M_sep);
6215 __fc.advance_to(__out);
6216 __out = _M_fval.format(*__first, __fc);
6217 }
6218
6219 return __format::__write(__out, _M_close);
6220 }
6221
6222 __format::_Spec<_CharT> _M_spec{};
6223 _String_view _M_open = _Seps::_S_squares().substr(0, 1);
6224 _String_view _M_close = _Seps::_S_squares().substr(1, 1);
6225 _String_view _M_sep = _Seps::_S_comma();
6226 formatter<_Tp, _CharT> _M_fval;
6227 };
6228
6229 // In standard this is shown as inheriting from specialization of
6230 // exposition only specialization for range-default-formatter for
6231 // each range_format. We opt for simpler implementation.
6232 // [format.range.fmtmap], [format.range.fmtset], [format.range.fmtstr],
6233 // specializations for maps, sets, and strings
6234 template<ranges::input_range _Rg, __format::__char _CharT>
6235 requires (format_kind<_Rg> != range_format::disabled)
6236 && formattable<ranges::range_reference_t<_Rg>, _CharT>
6237 struct formatter<_Rg, _CharT>
6238 {
6239 private:
6240 static const bool _S_range_format_is_string =
6241 (format_kind<_Rg> == range_format::string)
6242 || (format_kind<_Rg> == range_format::debug_string);
6243 using _Vt = remove_cvref_t<
6244 ranges::range_reference_t<
6245 __format::__maybe_const_range<_Rg, _CharT>>>;
6246
6247 static consteval bool _S_is_correct()
6248 {
6249 if constexpr (_S_range_format_is_string)
6250 static_assert(same_as<_Vt, _CharT>);
6251 return true;
6252 }
6253
6254 static_assert(_S_is_correct());
6255
6256 public:
6257 constexpr formatter() noexcept
6258 {
6259 using _Seps = __format::_Separators<_CharT>;
6260 if constexpr (format_kind<_Rg> == range_format::map)
6261 {
6262 static_assert(__format::__is_map_formattable<_Vt>);
6263 _M_under.set_brackets(_Seps::_S_braces().substr(0, 1),
6264 _Seps::_S_braces().substr(1, 1));
6265 _M_under.underlying().set_brackets({}, {});
6266 _M_under.underlying().set_separator(_Seps::_S_colon());
6267 }
6268 else if constexpr (format_kind<_Rg> == range_format::set)
6269 _M_under.set_brackets(_Seps::_S_braces().substr(0, 1),
6270 _Seps::_S_braces().substr(1, 1));
6271 }
6272
6273 constexpr void
6274 set_separator(basic_string_view<_CharT> __sep) noexcept
6275 requires (format_kind<_Rg> == range_format::sequence)
6276 { _M_under.set_separator(__sep); }
6277
6278 constexpr void
6279 set_brackets(basic_string_view<_CharT> __open,
6280 basic_string_view<_CharT> __close) noexcept
6281 requires (format_kind<_Rg> == range_format::sequence)
6282 { _M_under.set_brackets(__open, __close); }
6283
6284 // We deviate from standard, that declares this as template accepting
6285 // unconstrained ParseContext type, which seems unimplementable.
6286 constexpr typename basic_format_parse_context<_CharT>::iterator
6287 parse(basic_format_parse_context<_CharT>& __pc)
6288 {
6289 auto __res = _M_under.parse(__pc);
6290 if constexpr (format_kind<_Rg> == range_format::debug_string)
6291 _M_under.set_debug_format();
6292 return __res;
6293 }
6294
6295 // We deviate from standard, that declares this as template accepting
6296 // unconstrained FormatContext type, which seems unimplementable.
6297 template<typename _Out>
6298 typename basic_format_context<_Out, _CharT>::iterator
6299 format(__format::__maybe_const_range<_Rg, _CharT>& __rg,
6300 basic_format_context<_Out, _CharT>& __fc) const
6301 {
6302 if constexpr (_S_range_format_is_string)
6303 return _M_under._M_format_range(__rg, __fc);
6304 else
6305 return _M_under.format(__rg, __fc);
6306 }
6307
6308 private:
6309 using _Formatter_under
6310 = __conditional_t<_S_range_format_is_string,
6311 __format::__formatter_str<_CharT>,
6312 range_formatter<_Vt, _CharT>>;
6313 _Formatter_under _M_under;
6314 };
6315
6316#if __glibcxx_print >= 202406L
6317 template<ranges::input_range _Rg>
6318 requires (format_kind<_Rg> != range_format::disabled)
6319 constexpr bool enable_nonlocking_formatter_optimization<_Rg> = false;
6320#endif
6321
6322#endif // C++23 formatting ranges
6323#undef _GLIBCXX_WIDEN
6324
6325_GLIBCXX_END_NAMESPACE_VERSION
6326} // namespace std
6327#endif // __cpp_lib_format
6328#pragma GCC diagnostic pop
6329#endif // _GLIBCXX_FORMAT
array
charconv
concepts
limits
locale
optional
span
string
string_view
cctype
monostate.h
ranges_algobase.h
ranges_base.h
ranges_util.h
stl_pair.h
version.h
unicode.h
utility.h
formatfwd.h
requires_hosted.h
std::operator*
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
Definition complex:434
std::arg
_Tp arg(const complex< _Tp > &)
Return phase angle of z.
Definition complex:995
std::to_address
constexpr _Tp * to_address(_Tp *__ptr) noexcept
Obtain address referenced by a pointer to an object.
Definition ptr_traits.h:232
std::remove_reference_t
typename remove_reference< _Tp >::type remove_reference_t
Alias template for remove_reference.
Definition type_traits:1886
std::pair::pair
pair(_T1, _T2) -> pair< _T1, _T2 >
Two pairs are equal iff their members are equal.
std::addressof
constexpr _Tp * addressof(_Tp &__r) noexcept
Returns the actual address of the object or function referenced by r, even in the presence of an over...
Definition move.h:176
std::move
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition move.h:138
std::forward
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
Definition move.h:72
std::use_facet
const _Facet & use_facet(const locale &__loc)
Return a facet.
Definition locale_classes.tcc:220
std::string
basic_string< char > string
A string of char.
Definition stringfwd.h:79
std
ISO C++ entities toplevel namespace is std.
std::chars_format
chars_format
floating-point format for primitive numerical conversion
Definition charconv:631
std::toupper
_CharT toupper(_CharT __c, const locale &__loc)
Convenience interface to ctype.toupper(__c).
Definition locale_facets.h:2689
__gnu_cxx::__int_traits
__numeric_traits_integer< _Tp > __int_traits
Convenience alias for __numeric_traits<integer-type>.
Definition ext/numeric_traits.h:134
std::basic_string_view
A non-owning reference to a string.
Definition string_view:113
std::basic_string
Managing sequences of characters and character-like objects.
Definition basic_string.h:94
std::basic_string::size
constexpr size_type size() const noexcept
Returns the number of characters in the string, not including any null-termination.
Definition basic_string.h:1187
std::basic_string::reserve
constexpr void reserve(size_type __res_arg)
Attempt to preallocate enough memory for specified number of characters.
Definition cow_string.h:3669
std::basic_string::data
constexpr const _CharT * data() const noexcept
Return const pointer to contents.
Definition basic_string.h:2910
std::basic_string::substr
constexpr basic_string substr(size_type __pos=0, size_type __n=npos) const
Get a substring.
Definition basic_string.h:3465
std::basic_string::__resize_and_overwrite
constexpr void __resize_and_overwrite(size_type __n, _Operation __op)
Non-standard version of resize_and_overwrite for C++11 and above.
std::basic_string::append
constexpr basic_string & append(const basic_string &__str)
Append a string to this string.
Definition basic_string.h:1559
std::basic_string::insert
constexpr iterator insert(const_iterator __p, size_type __n, _CharT __c)
Insert multiple characters.
Definition basic_string.h:2033
std::basic_string::capacity
constexpr size_type capacity() const noexcept
Definition basic_string.h:1301
std::basic_string::empty
constexpr bool empty() const noexcept
Definition basic_string.h:1355
std::runtime_error
One of two subclasses of exception.
Definition stdexcept_except.h:454
std::vector
A standard container which offers fixed time access to individual elements in any order.
Definition stl_vector.h:461
stl_iterator.h
numeric_traits.h