chrono_io.h source code [include/c++/14/bits/chrono_io.h]

1	// <chrono> 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/bits/chrono_io.h*
26	* This is an internal header file, included by other library headers.
27	* Do not attempt to use it directly. @headername{chrono}
28	*/
29
30	#ifndef _GLIBCXX_CHRONO_IO_H
31	#define _GLIBCXX_CHRONO_IO_H 1
32
33	#pragma GCC system_header
34
35	#if __cplusplus >= 202002L
36
37	#include <sstream> // ostringstream
38	#include <iomanip> // setw, setfill
39	#include <format>
40	#include <charconv> // from_chars
41
42	#include <bits/streambuf_iterator.h>
43
44	namespace std _GLIBCXX_VISIBILITY(default)
45	{
46	_GLIBCXX_BEGIN_NAMESPACE_VERSION
47
48	namespace chrono
49	{
50	/// @addtogroup chrono
51	/// @{
52
53	/// @cond undocumented
54	namespace __detail
55	{
56	// STATICALLY-WIDEN, see C++20 [time.general]
57	// It doesn't matter for format strings (which can only be char or wchar_t)
58	// but this returns the narrow string for anything that isn't wchar_t. This
59	// is done because const char can be inserted into any ostream type, and*
60	// will be widened at runtime if necessary.
61	template<typename _CharT>
62	consteval auto
63	_Widen(const char* __narrow, const wchar_t* __wide)
64	{
65	if constexpr (is_same_v<_CharT, wchar_t>)
66	return __wide;
67	else
68	return __narrow;
69	}
70	#define _GLIBCXX_WIDEN_(C, S) ::std::chrono::__detail::_Widen<C>(S, L##S)
71	#define _GLIBCXX_WIDEN(S) _GLIBCXX_WIDEN_(_CharT, S)
72
73	template<typename _Period, typename _CharT>
74	constexpr basic_string_view<_CharT>
75	__units_suffix() noexcept
76	{
77	// The standard say these are all narrow strings, which would need to
78	// be widened at run-time when inserted into a wide stream. We use
79	// STATICALLY-WIDEN to widen at compile-time.
80	#define _GLIBCXX_UNITS_SUFFIX(period, suffix) \
81	if constexpr (is_same_v<_Period, period>) \
82	return _GLIBCXX_WIDEN(suffix); \
83	else
84
85	_GLIBCXX_UNITS_SUFFIX(atto, "as")
86	_GLIBCXX_UNITS_SUFFIX(femto, "fs")
87	_GLIBCXX_UNITS_SUFFIX(pico, "ps")
88	_GLIBCXX_UNITS_SUFFIX(nano, "ns")
89	_GLIBCXX_UNITS_SUFFIX(milli, "ms")
90	#if _GLIBCXX_USE_ALT_MICROSECONDS_SUFFIX
91	// Deciding this at compile-time is wrong, maybe use nl_langinfo(CODESET)
92	// to check runtime environment and return u8"\u00b5s", "\xb5s", or "us".
93	_GLIBCXX_UNITS_SUFFIX(micro, "\u00b5s")
94	#else
95	_GLIBCXX_UNITS_SUFFIX(micro, "us")
96	#endif
97	_GLIBCXX_UNITS_SUFFIX(centi, "cs")
98	_GLIBCXX_UNITS_SUFFIX(deci, "ds")
99	_GLIBCXX_UNITS_SUFFIX(ratio<`1`>, "s")
100	_GLIBCXX_UNITS_SUFFIX(deca, "das")
101	_GLIBCXX_UNITS_SUFFIX(hecto, "hs")
102	_GLIBCXX_UNITS_SUFFIX(kilo, "ks")
103	_GLIBCXX_UNITS_SUFFIX(mega, "Ms")
104	_GLIBCXX_UNITS_SUFFIX(giga, "Gs")
105	_GLIBCXX_UNITS_SUFFIX(tera, "Ts")
106	_GLIBCXX_UNITS_SUFFIX(tera, "Ts")
107	_GLIBCXX_UNITS_SUFFIX(peta, "Ps")
108	_GLIBCXX_UNITS_SUFFIX(exa, "Es")
109	_GLIBCXX_UNITS_SUFFIX(ratio<`60`>, "min")
110	_GLIBCXX_UNITS_SUFFIX(ratio<`3600`>, "h")
111	_GLIBCXX_UNITS_SUFFIX(ratio<`86400`>, "d")
112	#undef _GLIBCXX_UNITS_SUFFIX
113	return {};
114	}
115
116	template<typename _Period, typename _CharT, typename _Out>
117	inline _Out
118	__fmt_units_suffix(_Out __out) noexcept
119	{
120	if (auto __s = __detail::__units_suffix<_Period, _CharT>(); __s.size())
121	return __format::__write(std::move(__out), __s);
122	else if constexpr (_Period::den == `1`)
123	return std::format_to(std::move(__out), _GLIBCXX_WIDEN("[{}]s"),
124	(uintmax_t)_Period::num);
125	else
126	return std::format_to(std::move(__out), _GLIBCXX_WIDEN("[{}/{}]s"),
127	(uintmax_t)_Period::num,
128	(uintmax_t)_Period::den);
129	}
130	} // namespace __detail
131	/// @endcond
132
133	/* Write a `chrono::duration` to an ostream.*
134	*
135	* @since C++20
136	*/
137	template<typename _CharT, typename _Traits,
138	typename _Rep, typename _Period>
139	inline basic_ostream<_CharT, _Traits>&
140	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
141	const duration<_Rep, _Period>& __d)
142	{
143	using _Out = ostreambuf_iterator<_CharT, _Traits>;
144	using period = typename _Period::type;
145	std::basic_ostringstream<_CharT, _Traits> __s;
146	__s.flags(__os.flags());
147	__s.imbue(__os.getloc());
148	__s.precision(__os.precision());
149	__s << __d.count();
150	__detail::__fmt_units_suffix<period, _CharT>(_Out(__s));
151	__os << std::move(__s).str();
152	return __os;
153	}
154
155	/// @cond undocumented
156	namespace __detail
157	{
158	// An unspecified type returned by `chrono::local_time_format`.
159	template<typename _Duration>
160	struct __local_time_fmt
161	{
162	local_time<_Duration> _M_time;
163	const string* _M_abbrev;
164	const seconds* _M_offset_sec;
165	};
166
167	struct __local_fmt_t;
168	}
169	/// @endcond
170
171	/* Return an object that asssociates timezone info with a local time.*
172	*
173	* A `chrono::local_time` object has no timezone associated with it. This
174	* function creates an object that allows formatting a `local_time` as
175	* though it refers to a timezone with the given abbreviated name and
176	* offset from UTC.
177	*
178	* @since C++20
179	*/
180	template<typename _Duration>
181	inline __detail::__local_time_fmt<_Duration>
182	local_time_format(local_time<_Duration> __time,
183	const string* __abbrev = nullptr,
184	const seconds* __offset_sec = nullptr)
185	{ return {__time, __abbrev, __offset_sec}; }
186
187	/// @}
188	} // namespace chrono
189
190	/// @cond undocumented
191	namespace __format
192	{
193	[[noreturn,__gnu__::__always_inline__]]
194	inline void
195	__no_timezone_available()
196	{ __throw_format_error(what: "format error: no timezone available for %Z or %z"); }
197
198	[[noreturn,__gnu__::__always_inline__]]
199	inline void
200	__not_valid_for_duration()
201	{ __throw_format_error(what: "format error: chrono-format-spec not valid for "
202	"chrono::duration"); }
203
204	[[noreturn,__gnu__::__always_inline__]]
205	inline void
206	__invalid_chrono_spec()
207	{ __throw_format_error(what: "format error: chrono-format-spec not valid for "
208	"argument type"); }
209
210	template<typename _CharT>
211	struct _ChronoSpec : _Spec<_CharT>
212	{
213	basic_string_view<_CharT> _M_chrono_specs;
214	};
215
216	// Represents the information provided by a chrono type.
217	// e.g. month_weekday has month and weekday but no year or time of day,
218	// hh_mm_ss has time of day but no date, sys_time is time_point+timezone.
219	enum _ChronoParts {
220	_Year = `1`, _Month = `2`, _Day = `4`, _Weekday = `8`, _TimeOfDay = `16`,
221	_TimeZone = `32`,
222	_Date = _Year \| _Month \| _Day \| _Weekday,
223	_DateTime = _Date \| _TimeOfDay,
224	_ZonedDateTime = _DateTime \| _TimeZone,
225	_Duration = `128` // special case
226	};
227
228	constexpr _ChronoParts
229	operator\|(_ChronoParts __x, _ChronoParts __y) noexcept
230	{ return static_cast<_ChronoParts>((int)__x \| (int)__y); }
231
232	constexpr _ChronoParts&
233	operator\|=(_ChronoParts& __x, _ChronoParts __y) noexcept
234	{ return __x = __x \| __y; }
235
236	// TODO rename this to chrono::__formatter? or chrono::__detail::__formatter?
237	template<typename _CharT>
238	struct __formatter_chrono
239	{
240	using __string_view = basic_string_view<_CharT>;
241	using __string = basic_string<_CharT>;
242
243	template<typename _ParseContext>
244	constexpr typename _ParseContext::iterator
245	_M_parse(_ParseContext& __pc, _ChronoParts __parts)
246	{
247	auto __first = __pc.begin();
248	auto __last = __pc.end();
249
250	_ChronoSpec<_CharT> __spec{};
251
252	auto __finalize = [this, &__spec] {
253	_M_spec = __spec;
254	};
255
256	auto __finished = [&] {
257	if (__first == __last \|\| *__first == `'}'`)
258	{
259	__finalize();
260	return true;
261	}
262	return false;
263	};
264
265	if (__finished())
266	return __first;
267
268	__first = __spec._M_parse_fill_and_align(__first, __last);
269	if (__finished())
270	return __first;
271
272	__first = __spec._M_parse_width(__first, __last, __pc);
273	if (__finished())
274	return __first;
275
276	if (__parts & _ChronoParts::_Duration)
277	{
278	__first = __spec._M_parse_precision(__first, __last, __pc);
279	if (__finished())
280	return __first;
281	}
282
283	__first = __spec._M_parse_locale(__first, __last);
284	if (__finished())
285	return __first;
286
287	// Everything up to the end of the string or the first '}' is a
288	// chrono-specs string. Check it is valid.
289	{
290	__string_view __str(__first, __last - __first);
291	auto __end = __str.find(`'}'`);
292	if (__end != __str.npos)
293	{
294	__str.remove_suffix(__str.length() - __end);
295	__last = __first + __end;
296	}
297	if (__str.find(`'{'`) != __str.npos)
298	__throw_format_error(what: "chrono format error: '{' in chrono-specs");
299	}
300
301	// Parse chrono-specs in [first,last), checking each conversion-spec
302	// against __parts (so fail for %Y if no year in parts).
303	// Save range in __spec._M_chrono_specs.
304
305	const auto __chrono_specs = __first++; // Skip leading '%'
306	if (*__chrono_specs != `'%'`)
307	__throw_format_error(what: "chrono format error: no '%' at start of "
308	"chrono-specs");
309
310	_CharT __mod{};
311	bool __conv = true;
312	int __needed = `0`;
313
314	while (__first != __last)
315	{
316	enum _Mods { _Mod_none, _Mod_E, _Mod_O, _Mod_E_O };
317	_Mods __allowed_mods = _Mod_none;
318
319	_CharT __c = *__first++;
320	switch (__c)
321	{
322	case `'a'`:
323	case `'A'`:
324	__needed = _Weekday;
325	break;
326	case `'b'`:
327	case `'h'`:
328	case `'B'`:
329	__needed = _Month;
330	break;
331	case `'c'`:
332	__needed = _DateTime;
333	__allowed_mods = _Mod_E;
334	break;
335	case `'C'`:
336	__needed = _Year;
337	__allowed_mods = _Mod_E;
338	break;
339	case `'d'`:
340	case `'e'`:
341	__needed = _Day;
342	__allowed_mods = _Mod_O;
343	break;
344	case `'D'`:
345	case `'F'`:
346	__needed = _Date;
347	break;
348	case `'g'`:
349	case `'G'`:
350	__needed = _Date;
351	break;
352	case `'H'`:
353	case `'I'`:
354	__needed = _TimeOfDay;
355	__allowed_mods = _Mod_O;
356	break;
357	case `'j'`:
358	if (!(__parts & _Duration))
359	__needed = _Date;
360	break;
361	case `'m'`:
362	__needed = _Month;
363	__allowed_mods = _Mod_O;
364	break;
365	case `'M'`:
366	__needed = _TimeOfDay;
367	__allowed_mods = _Mod_O;
368	break;
369	case `'p'`:
370	case `'r'`:
371	case `'R'`:
372	case `'T'`:
373	__needed = _TimeOfDay;
374	break;
375	case `'q'`:
376	case `'Q'`:
377	__needed = _Duration;
378	break;
379	case `'S'`:
380	__needed = _TimeOfDay;
381	__allowed_mods = _Mod_O;
382	break;
383	case `'u'`:
384	case `'w'`:
385	__needed = _Weekday;
386	__allowed_mods = _Mod_O;
387	break;
388	case `'U'`:
389	case `'V'`:
390	case `'W'`:
391	__needed = _Date;
392	__allowed_mods = _Mod_O;
393	break;
394	case `'x'`:
395	__needed = _Date;
396	__allowed_mods = _Mod_E;
397	break;
398	case `'X'`:
399	__needed = _TimeOfDay;
400	__allowed_mods = _Mod_E;
401	break;
402	case `'y'`:
403	__needed = _Year;
404	__allowed_mods = _Mod_E_O;
405	break;
406	case `'Y'`:
407	__needed = _Year;
408	__allowed_mods = _Mod_E;
409	break;
410	case `'z'`:
411	__needed = _TimeZone;
412	__allowed_mods = _Mod_E_O;
413	break;
414	case `'Z'`:
415	__needed = _TimeZone;
416	break;
417	case `'n'`:
418	case `'t'`:
419	case `'%'`:
420	break;
421	case `'O'`:
422	case `'E'`:
423	if (__mod) [[unlikely]]
424	{
425	__allowed_mods = _Mod_none;
426	break;
427	}
428	__mod = __c;
429	continue;
430	default:
431	__throw_format_error(what: "chrono format error: invalid "
432	" specifier in chrono-specs");
433	}
434
435	if ((__mod == `'E'` && !(__allowed_mods & _Mod_E))
436	\|\| (__mod == `'O'` && !(__allowed_mods & _Mod_O)))
437	__throw_format_error(what: "chrono format error: invalid "
438	" modifier in chrono-specs");
439	__mod = _CharT();
440
441	if ((__parts & __needed) != __needed)
442	__throw_format_error(what: "chrono format error: format argument "
443	"does not contain the information "
444	"required by the chrono-specs");
445
446	// Scan for next '%', ignoring literal-chars before it.
447	size_t __pos = __string_view(__first, __last - __first).find(`'%'`);
448	if (__pos == `0`)
449	++__first;
450	else
451	{
452	if (__pos == __string_view::npos)
453	{
454	__first = __last;
455	__conv = false;
456	}
457	else
458	__first += __pos + `1`;
459	}
460	}
461
462	// Check for a '%' conversion-spec without a type.
463	if (__conv \|\| __mod != _CharT())
464	__throw_format_error(what: "chrono format error: unescaped '%' in "
465	"chrono-specs");
466
467	_M_spec = __spec;
468	_M_spec._M_chrono_specs
469	= __string_view(__chrono_specs, __first - __chrono_specs);
470
471	return __first;
472	}
473
474	// TODO this function template is instantiated for every different _Tp.
475	// Consider creating a polymorphic interface for calendar types so
476	// that we instantiate fewer different specializations. Similar to
477	// _Sink_iter for std::format. Replace each _S_year, _S_day etc. with
478	// member functions of that type.
479	template<typename _Tp, typename _FormatContext>
480	typename _FormatContext::iterator
481	_M_format(const _Tp& __t, _FormatContext& __fc,
482	bool __is_neg = false) const
483	{
484	auto __first = _M_spec._M_chrono_specs.begin();
485	const auto __last = _M_spec._M_chrono_specs.end();
486	if (__first == __last)
487	return _M_format_to_ostream(__t, __fc, __is_neg);
488
489	_Sink_iter<_CharT> __out;
490	__format::_Str_sink<_CharT> __sink;
491	bool __write_direct = false;
492	if constexpr (is_same_v<typename _FormatContext::iterator,
493	_Sink_iter<_CharT>>)
494	{
495	if (_M_spec._M_width_kind == __format::_WP_none)
496	{
497	__out = __fc.out();
498	__write_direct = true;
499	}
500	else
501	__out = __sink.out();
502	}
503	else
504	__out = __sink.out();
505
506	// formatter<duration> passes the correct value of __is_neg
507	// for durations but for hh_mm_ss we decide it here.
508	if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
509	__is_neg = __t.is_negative();
510
511	auto __print_sign = [&__is_neg, &__out] {
512	if constexpr (chrono::__is_duration_v<_Tp>
513	\|\| __is_specialization_of<_Tp, chrono::hh_mm_ss>)
514	if (__is_neg)
515	{
516	*__out++ = _S_plus_minus[`1`];
517	__is_neg = false;
518	}
519	return std::move(__out);
520	};
521
522	// Characters to output for "%n", "%t" and "%%" specifiers.
523	constexpr const _CharT* __literals = _GLIBCXX_WIDEN("\n\t%");
524
525	++__first; // Skip leading '%' at start of chrono-specs.
526
527	_CharT __mod{};
528	do
529	{
530	_CharT __c = *__first++;
531	switch (__c)
532	{
533	case `'a'`:
534	case `'A'`:
535	__out = _M_a_A(__t, std::move(__out), __fc, __c == `'A'`);
536	break;
537	case `'b'`:
538	case `'h'`:
539	case `'B'`:
540	__out = _M_b_B(__t, std::move(__out), __fc, __c == `'B'`);
541	break;
542	case `'c'`:
543	__out = _M_c(__t, std::move(__out), __fc, __mod == `'E'`);
544	break;
545	case `'C'`:
546	case `'y'`:
547	case `'Y'`:
548	__out = _M_C_y_Y(__t, std::move(__out), __fc, __c, __mod);
549	break;
550	case `'d'`:
551	case `'e'`:
552	__out = _M_d_e(__t, std::move(__out), __fc, __c, __mod == `'O'`);
553	break;
554	case `'D'`:
555	__out = _M_D(__t, std::move(__out), __fc);
556	break;
557	case `'F'`:
558	__out = _M_F(__t, std::move(__out), __fc);
559	break;
560	case `'g'`:
561	case `'G'`:
562	__out = _M_g_G(__t, std::move(__out), __fc, __c == `'G'`);
563	break;
564	case `'H'`:
565	case `'I'`:
566	__out = _M_H_I(__t, __print_sign(), __fc, __c, __mod == `'O'`);
567	break;
568	case `'j'`:
569	__out = _M_j(__t, __print_sign(), __fc);
570	break;
571	case `'m'`:
572	__out = _M_m(__t, std::move(__out), __fc, __mod == `'O'`);
573	break;
574	case `'M'`:
575	__out = _M_M(__t, __print_sign(), __fc, __mod == `'O'`);
576	break;
577	case `'p'`:
578	__out = _M_p(__t, std::move(__out), __fc);
579	break;
580	case `'q'`:
581	__out = _M_q(__t, std::move(__out), __fc);
582	break;
583	case `'Q'`:
584	// %Q The duration's numeric value.
585	if constexpr (chrono::__is_duration_v<_Tp>)
586	__out = std::format_to(__print_sign(), _S_empty_spec,
587	__t.count());
588	else
589	__throw_format_error(what: "chrono format error: argument is "
590	"not a duration");
591	break;
592	case `'r'`:
593	__out = _M_r(__t, __print_sign(), __fc);
594	break;
595	case `'R'`:
596	case `'T'`:
597	__out = _M_R_T(__t, __print_sign(), __fc, __c == `'T'`);
598	break;
599	case `'S'`:
600	__out = _M_S(__t, __print_sign(), __fc, __mod == `'O'`);
601	break;
602	case `'u'`:
603	case `'w'`:
604	__out = _M_u_w(__t, std::move(__out), __fc, __c, __mod == `'O'`);
605	break;
606	case `'U'`:
607	case `'V'`:
608	case `'W'`:
609	__out = _M_U_V_W(__t, std::move(__out), __fc, __c,
610	__mod == `'O'`);
611	break;
612	case `'x'`:
613	__out = _M_x(__t, std::move(__out), __fc, __mod == `'E'`);
614	break;
615	case `'X'`:
616	__out = _M_X(__t, __print_sign(), __fc, __mod == `'E'`);
617	break;
618	case `'z'`:
619	__out = _M_z(__t, std::move(__out), __fc, (bool)__mod);
620	break;
621	case `'Z'`:
622	__out = _M_Z(__t, std::move(__out), __fc);
623	break;
624	case `'n'`:
625	*__out++ = __literals[`0`];
626	break;
627	case `'t'`:
628	*__out++ = __literals[`1`];
629	break;
630	case `'%'`:
631	*__out++ = __literals[`2`];
632	break;
633	case `'O'`:
634	case `'E'`:
635	__mod = __c;
636	continue;
637	case `'}'`:
638	__first = __last;
639	break;
640	}
641	__mod = _CharT();
642	// Scan for next '%' and write out everything before it.
643	__string_view __str(__first, __last - __first);
644	size_t __pos = __str.find(`'%'`);
645	if (__pos == `0`)
646	++__first;
647	else
648	{
649	if (__pos == __str.npos)
650	__first = __last;
651	else
652	{
653	__str.remove_suffix(__str.length() - __pos);
654	__first += __pos + `1`;
655	}
656	__out = __format::__write(std::move(__out), __str);
657	}
658	}
659	while (__first != __last);
660
661	if constexpr (is_same_v<typename _FormatContext::iterator,
662	_Sink_iter<_CharT>>)
663	if (__write_direct)
664	return __out;
665
666	auto __str = std::move(__sink).get();
667	return __format::__write_padded_as_spec(__str, __str.size(),
668	__fc, _M_spec);
669	}
670
671	_ChronoSpec<_CharT> _M_spec;
672
673	private:
674	// Return the formatting locale.
675	template<typename _FormatContext>
676	std::locale
677	_M_locale(_FormatContext& __fc) const
678	{
679	if (!_M_spec._M_localized)
680	return std::locale::classic();
681	else
682	return __fc.locale();
683	}
684
685	// Format for empty chrono-specs, e.g. "{}" (C++20 [time.format] p6).
686	// TODO: consider moving body of every operator<< into this function
687	// and use std::format("{}", t) to implement those operators. That
688	// would avoid std::format("{}", t) calling operator<< which calls
689	// std::format again.
690	template<typename _Tp, typename _FormatContext>
691	typename _FormatContext::iterator
692	_M_format_to_ostream(const _Tp& __t, _FormatContext& __fc,
693	bool __is_neg) const
694	{
695	using ::std::chrono::__detail::__utc_leap_second;
696	using ::std::chrono::__detail::__local_time_fmt;
697
698	if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
699	return _M_format_to_ostream(__t._M_time, __fc, false);
700	else
701	{
702	basic_ostringstream<_CharT> __os;
703	__os.imbue(_M_locale(__fc));
704
705	if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
706	__os << __t._M_date << `' '` << __t._M_time;
707	else if constexpr (chrono::__is_time_point_v<_Tp>)
708	{
709	// Need to be careful here because not all specializations
710	// of chrono::sys_time can be written to an ostream.
711	// For the specializations of time_point that can be
712	// formatted with an empty chrono-specs, either it's a
713	// sys_time with period greater or equal to days:
714	if constexpr (is_convertible_v<_Tp, chrono::sys_days>)
715	__os << _S_date(__t);
716	else // Or it's formatted as "{:L%F %T}":
717	{
718	auto __days = chrono::floor<chrono::days>(__t);
719	__os << chrono::year_month_day(__days) << `' '`
720	<< chrono::hh_mm_ss(__t - __days);
721	}
722	}
723	else
724	{
725	if constexpr (chrono::__is_duration_v<_Tp>)
726	if (__is_neg) [[unlikely]]
727	__os << _S_plus_minus[`1`];
728	__os << __t;
729	}
730
731	auto __str = std::move(__os).str();
732	return __format::__write_padded_as_spec(__str, __str.size(),
733	__fc, _M_spec);
734	}
735	}
736
737	static constexpr const _CharT* _S_chars
738	= _GLIBCXX_WIDEN("0123456789+-:/ {}");
739	static constexpr const _CharT* _S_plus_minus = _S_chars + `10`;
740	static constexpr _CharT _S_colon = _S_chars[`12`];
741	static constexpr _CharT _S_slash = _S_chars[`13`];
742	static constexpr _CharT _S_space = _S_chars[`14`];
743	static constexpr const _CharT* _S_empty_spec = _S_chars + `15`;
744
745	template<typename _Tp, typename _FormatContext>
746	typename _FormatContext::iterator
747	_M_a_A(const _Tp& __t, typename _FormatContext::iterator __out,
748	_FormatContext& __ctx, bool __full) const
749	{
750	// %a Locale's abbreviated weekday name.
751	// %A Locale's full weekday name.
752	chrono::weekday __wd = _S_weekday(__t);
753	if (!__wd.ok())
754	__throw_format_error(what: "format error: invalid weekday");
755
756	locale __loc = _M_locale(__ctx);
757	const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
758	const _CharT* __days[`7`];
759	if (__full)
760	__tp._M_days(__days);
761	else
762	__tp._M_days_abbreviated(__days);
763	__string_view __str(__days[__wd.c_encoding()]);
764	return __format::__write(std::move(__out), __str);
765	}
766
767	template<typename _Tp, typename _FormatContext>
768	typename _FormatContext::iterator
769	_M_b_B(const _Tp& __t, typename _FormatContext::iterator __out,
770	_FormatContext& __ctx, bool __full) const
771	{
772	// %b Locale's abbreviated month name.
773	// %B Locale's full month name.
774	chrono::month __m = _S_month(__t);
775	if (!__m.ok())
776	__throw_format_error(what: "format error: invalid month");
777	locale __loc = _M_locale(__ctx);
778	const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
779	const _CharT* __months[`12`];
780	if (__full)
781	__tp._M_months(__months);
782	else
783	__tp._M_months_abbreviated(__months);
784	__string_view __str(__months[(unsigned)__m - `1`]);
785	return __format::__write(std::move(__out), __str);
786	}
787
788	template<typename _Tp, typename _FormatContext>
789	typename _FormatContext::iterator
790	_M_c(const _Tp& __tt, typename _FormatContext::iterator __out,
791	_FormatContext& __ctx, bool __mod = false) const
792	{
793	// %c Locale's date and time representation.
794	// %Ec Locale's alternate date and time representation.
795
796	auto __t = _S_floor_seconds(__tt);
797	locale __loc = _M_locale(__ctx);
798	const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
799	const _CharT* __formats[`2`];
800	__tp._M_date_time_formats(__formats);
801	const _CharT* __rep = __formats[__mod];
802	if (!*__rep)
803	__rep = _GLIBCXX_WIDEN("%a %b %e %H:%M:%S %Y");
804	basic_string<_CharT> __fmt(_S_empty_spec);
805	__fmt.insert(`1u`, `1u`, _S_colon);
806	__fmt.insert(`2u`, __rep);
807	return std::vformat_to(std::move(__out), __loc, __fmt,
808	std::make_format_args<_FormatContext>(__t));
809	}
810
811	template<typename _Tp, typename _FormatContext>
812	typename _FormatContext::iterator
813	_M_C_y_Y(const _Tp& __t, typename _FormatContext::iterator __out,
814	_FormatContext& __ctx, _CharT __conv, _CharT __mod = `0`) const
815	{
816	// %C Year divided by 100 using floored division.
817	// %EC Locale's alternative preresentation of the century (era name).
818	// %y Last two decimal digits of the year.
819	// %Oy Locale's alternative representation.
820	// %Ey Locale's alternative representation of offset from %EC.
821	// %Y Year as a decimal number.
822	// %EY Locale's alternative full year representation.
823
824	chrono::year __y = _S_year(__t);
825
826	if (__mod) [[unlikely]]
827	{
828	struct tm __tm{};
829	__tm.tm_year = (int)__y - `1900`;
830	return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
831	__conv, __mod);
832	}
833
834	basic_string<_CharT> __s;
835	int __yi = (int)__y;
836	const bool __is_neg = __yi < `0`;
837	__yi = __builtin_abs(__yi);
838
839	if (__conv == `'Y'` \|\| __conv == `'C'`)
840	{
841	int __ci = __yi / `100`;
842	if (__is_neg) [[unlikely]]
843	{
844	__s.assign(`1`, _S_plus_minus[`1`]);
845	// For floored division -123//100 is -2 and -100//100 is -1
846	if (__conv == `'C'` && (__ci * `100`) != __yi)
847	++__ci;
848	}
849	if (__ci >= `100`) [[unlikely]]
850	{
851	__s += std::format(_S_empty_spec, __ci / `100`);
852	__ci %= `100`;
853	}
854	__s += _S_two_digits(n: __ci);
855	}
856
857	if (__conv == `'Y'` \|\| __conv == `'y'`)
858	__s += _S_two_digits(n: __yi % `100`);
859
860	return __format::__write(std::move(__out), __string_view(__s));
861	}
862
863	template<typename _Tp, typename _FormatContext>
864	typename _FormatContext::iterator
865	_M_D(const _Tp& __t, typename _FormatContext::iterator __out,
866	_FormatContext&) const
867	{
868	auto __ymd = _S_date(__t);
869	basic_string<_CharT> __s;
870	#if ! _GLIBCXX_USE_CXX11_ABI
871	__s.reserve(`8`);
872	#endif
873	__s = _S_two_digits(n: (unsigned)__ymd.month());
874	__s += _S_slash;
875	__s += _S_two_digits(n: (unsigned)__ymd.day());
876	__s += _S_slash;
877	__s += _S_two_digits(n: __builtin_abs((int)__ymd.year()) % `100`);
878	return __format::__write(std::move(__out), __string_view(__s));
879	}
880
881	template<typename _Tp, typename _FormatContext>
882	typename _FormatContext::iterator
883	_M_d_e(const _Tp& __t, typename _FormatContext::iterator __out,
884	_FormatContext& __ctx, _CharT __conv, bool __mod = false) const
885	{
886	// %d The day of month as a decimal number.
887	// %Od Locale's alternative representation.
888	// %e Day of month as decimal number, padded with space.
889	// %Oe Locale's alternative digits.
890
891	chrono::day __d = _S_day(__t);
892	unsigned __i = (unsigned)__d;
893
894	if (__mod) [[unlikely]]
895	{
896	struct tm __tm{};
897	__tm.tm_mday = __i;
898	return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
899	(char)__conv, `'O'`);
900	}
901
902	auto __sv = _S_two_digits(n: __i);
903	_CharT __buf[`2`];
904	if (__conv == _CharT(`'e'`) && __i < `10`)
905	{
906	__buf[`0`] = _S_space;
907	__buf[`1`] = __sv[`1`];
908	__sv = {__buf, `2`};
909	}
910	return __format::__write(std::move(__out), __sv);
911	}
912
913	template<typename _Tp, typename _FormatContext>
914	typename _FormatContext::iterator
915	_M_F(const _Tp& __t, typename _FormatContext::iterator __out,
916	_FormatContext&) const
917	{
918	auto __ymd = _S_date(__t);
919	auto __s = std::format(_GLIBCXX_WIDEN("{:04d}- - "),
920	(int)__ymd.year());
921	auto __sv = _S_two_digits(n: (unsigned)__ymd.month());
922	__s[__s.size() - `5`] = __sv[`0`];
923	__s[__s.size() - `4`] = __sv[`1`];
924	__sv = _S_two_digits(n: (unsigned)__ymd.day());
925	__s[__s.size() - `2`] = __sv[`0`];
926	__s[__s.size() - `1`] = __sv[`1`];
927	__sv = __s;
928	return __format::__write(std::move(__out), __sv);
929	}
930
931	template<typename _Tp, typename _FormatContext>
932	typename _FormatContext::iterator
933	_M_g_G(const _Tp& __t, typename _FormatContext::iterator __out,
934	_FormatContext& __ctx, bool __full) const
935	{
936	// %g last two decimal digits of the ISO week-based year.
937	// %G ISO week-based year.
938	using namespace chrono;
939	auto __d = _S_days(__t);
940	// Move to nearest Thursday:
941	__d -= (weekday(__d) - Monday) - days (`3`);
942	// ISO week-based year is the year that contains that Thursday:
943	year __y = year_month_day(__d).year();
944	return _M_C_y_Y(__y, std::move(__out), __ctx, "yY"[__full]);
945	}
946
947	template<typename _Tp, typename _FormatContext>
948	typename _FormatContext::iterator
949	_M_H_I(const _Tp& __t, typename _FormatContext::iterator __out,
950	_FormatContext& __ctx, _CharT __conv, bool __mod = false) const
951	{
952	// %H The hour (24-hour clock) as a decimal number.
953	// %OH Locale's alternative representation.
954	// %I The hour (12-hour clock) as a decimal number.
955	// %OI Locale's alternative representation.
956
957	const auto __hms = _S_hms(__t);
958	int __i = __hms.hours().count();
959
960	if (__mod) [[unlikely]]
961	{
962	struct tm __tm{};
963	__tm.tm_hour = __i;
964	return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
965	(char)__conv, `'O'`);
966	}
967
968	if (__conv == _CharT(`'I'`))
969	{
970	if (__i == `0`)
971	__i = `12`;
972	else if (__i > `12`)
973	__i -= `12`;
974	}
975	return __format::__write(std::move(__out), _S_two_digits(n: __i));
976	}
977
978	template<typename _Tp, typename _FormatContext>
979	typename _FormatContext::iterator
980	_M_j(const _Tp& __t, typename _FormatContext::iterator __out,
981	_FormatContext&) const
982	{
983	if constexpr (chrono::__is_duration_v<_Tp>)
984	{
985	// Decimal number of days, without padding.
986	unsigned __d = chrono::duration_cast<chrono::days>(__t).count();
987	return std::format_to(std::move(__out), _S_empty_spec, __d);
988	}
989	else
990	{
991	// Day of the year as a decimal number, padding with zero.
992	using namespace chrono;
993	auto __day = _S_days(__t);
994	auto __ymd = _S_date(__t);
995	days __d;
996	// See "Calculating Ordinal Dates" at
997	// https://github.com/HowardHinnant/date/wiki/Examples-and-Recipes
998	if constexpr (is_same_v<typename decltype(__day)::clock, local_t>)
999	__d = __day - local_days(__ymd.year()/January/`0`);
1000	else
1001	__d = __day - sys_days(__ymd.year()/January/`0`);
1002	return std::format_to(std::move(__out), _GLIBCXX_WIDEN("{:03d}"),
1003	__d.count());
1004	}
1005	}
1006
1007	template<typename _Tp, typename _FormatContext>
1008	typename _FormatContext::iterator
1009	_M_m(const _Tp& __t, typename _FormatContext::iterator __out,
1010	_FormatContext& __ctx, bool __mod) const
1011	{
1012	// %m month as a decimal number.
1013	// %Om Locale's alternative representation.
1014
1015	auto __m = _S_month(__t);
1016	auto __i = (unsigned)__m;
1017
1018	if (__mod) [[unlikely]] // %Om
1019	{
1020	struct tm __tm{};
1021	__tm.tm_mon = __i - `1`;
1022	return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
1023	`'m'`, `'O'`);
1024	}
1025
1026	return __format::__write(std::move(__out), _S_two_digits(n: __i));
1027	}
1028
1029	template<typename _Tp, typename _FormatContext>
1030	typename _FormatContext::iterator
1031	_M_M(const _Tp& __t, typename _FormatContext::iterator __out,
1032	_FormatContext& __ctx, bool __mod) const
1033	{
1034	// %M The minute as a decimal number.
1035	// %OM Locale's alternative representation.
1036
1037	auto __m = _S_hms(__t).minutes();
1038	auto __i = __m.count();
1039
1040	if (__mod) [[unlikely]] // %OM
1041	{
1042	struct tm __tm{};
1043	__tm.tm_min = __i;
1044	return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
1045	`'M'`, `'O'`);
1046	}
1047
1048	return __format::__write(std::move(__out), _S_two_digits(n: __i));
1049	}
1050
1051	template<typename _Tp, typename _FormatContext>
1052	typename _FormatContext::iterator
1053	_M_p(const _Tp& __t, typename _FormatContext::iterator __out,
1054	_FormatContext& __ctx) const
1055	{
1056	// %p The locale's equivalent of the AM/PM designations.
1057	auto __hms = _S_hms(__t);
1058	locale __loc = _M_locale(__ctx);
1059	const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1060	const _CharT* __ampm[`2`];
1061	__tp._M_am_pm(__ampm);
1062	return std::format_to(std::move(__out), _S_empty_spec,
1063	__ampm[__hms.hours().count() >= `12`]);
1064	}
1065
1066	template<typename _Tp, typename _FormatContext>
1067	typename _FormatContext::iterator
1068	_M_q(const _Tp&, typename _FormatContext::iterator __out,
1069	_FormatContext&) const
1070	{
1071	// %q The duration's unit suffix
1072	if constexpr (!chrono::__is_duration_v<_Tp>)
1073	__throw_format_error(what: "format error: argument is not a duration");
1074	else
1075	{
1076	namespace __d = chrono::__detail;
1077	using period = typename _Tp::period;
1078	return __d::__fmt_units_suffix<period, _CharT>(std::move(__out));
1079	}
1080	}
1081
1082	// %Q handled in _M_format
1083
1084	template<typename _Tp, typename _FormatContext>
1085	typename _FormatContext::iterator
1086	_M_r(const _Tp& __tt, typename _FormatContext::iterator __out,
1087	_FormatContext& __ctx) const
1088	{
1089	// %r locale's 12-hour clock time.
1090	auto __t = _S_floor_seconds(__tt);
1091	locale __loc = _M_locale(__ctx);
1092	const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1093	const _CharT* __ampm_fmt;
1094	__tp._M_am_pm_format(&__ampm_fmt);
1095	basic_string<_CharT> __fmt(_S_empty_spec);
1096	__fmt.insert(`1u`, `1u`, _S_colon);
1097	__fmt.insert(`2u`, __ampm_fmt);
1098	return std::vformat_to(std::move(__out), __fmt,
1099	std::make_format_args<_FormatContext>(__t));
1100	}
1101
1102	template<typename _Tp, typename _FormatContext>
1103	typename _FormatContext::iterator
1104	_M_R_T(const _Tp& __t, typename _FormatContext::iterator __out,
1105	_FormatContext& __ctx, bool __secs) const
1106	{
1107	// %R Equivalent to %H:%M
1108	// %T Equivalent to %H:%M:%S
1109	auto __hms = _S_hms(__t);
1110
1111	auto __s = std::format(_GLIBCXX_WIDEN("{:02d}:00"),
1112	__hms.hours().count());
1113	auto __sv = _S_two_digits(n: __hms.minutes().count());
1114	__s[__s.size() - `2`] = __sv[`0`];
1115	__s[__s.size() - `1`] = __sv[`1`];
1116	__sv = __s;
1117	__out = __format::__write(std::move(__out), __sv);
1118	if (__secs)
1119	{
1120	*__out++ = _S_colon;
1121	__out = _M_S(__hms, std::move(__out), __ctx);
1122	}
1123	return __out;
1124	}
1125
1126	template<typename _Tp, typename _FormatContext>
1127	typename _FormatContext::iterator
1128	_M_S(const _Tp& __t, typename _FormatContext::iterator __out,
1129	_FormatContext& __ctx, bool __mod = false) const
1130	{
1131	// %S Seconds as a decimal number.
1132	// %OS The locale's alternative representation.
1133	auto __hms = _S_hms(__t);
1134
1135	if (__mod) [[unlikely]] // %OS
1136	{
1137	struct tm __tm{};
1138	__tm.tm_sec = (int)__hms.seconds().count();
1139	return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
1140	`'S'`, `'O'`);
1141	}
1142
1143	if constexpr (__hms.fractional_width == `0`)
1144	__out = __format::__write(std::move(__out),
1145	_S_two_digits(n: __hms.seconds().count()));
1146	else
1147	{
1148	locale __loc = _M_locale(__ctx);
1149	auto __s = __hms.seconds();
1150	auto __ss = __hms.subseconds();
1151	using rep = typename decltype(__ss)::rep;
1152	if constexpr (is_floating_point_v<rep>)
1153	{
1154	chrono::duration<rep> __fs = __s + __ss;
1155	__out = std::format_to(std::move(__out), __loc,
1156	_GLIBCXX_WIDEN("{:#0{}.{}Lf}"),
1157	__fs.count(),
1158	`3` + __hms.fractional_width,
1159	__hms.fractional_width);
1160	}
1161	else
1162	{
1163	const auto& __np
1164	= use_facet<numpunct<_CharT>>(__loc);
1165	__out = __format::__write(std::move(__out),
1166	_S_two_digits(n: __s.count()));
1167	*__out++ = __np.decimal_point();
1168	if constexpr (is_integral_v<rep>)
1169	__out = std::format_to(std::move(__out),
1170	_GLIBCXX_WIDEN("{:0{}}"),
1171	__ss.count(),
1172	__hms.fractional_width);
1173	else
1174	{
1175	auto __str = std::format(_S_empty_spec, __ss.count());
1176	__out = std::format_to(_GLIBCXX_WIDEN("{:0>{}s}"),
1177	__str,
1178	__hms.fractional_width);
1179	}
1180	}
1181	}
1182	return __out;
1183	}
1184
1185	// %t handled in _M_format
1186
1187	template<typename _Tp, typename _FormatContext>
1188	typename _FormatContext::iterator
1189	_M_u_w(const _Tp& __t, typename _FormatContext::iterator __out,
1190	_FormatContext& __ctx, _CharT __conv, bool __mod = false) const
1191	{
1192	// %u ISO weekday as a decimal number (1-7), where Monday is 1.
1193	// %Ou Locale's alternative numeric rep.
1194	// %w Weekday as a decimal number (0-6), where Sunday is 0.
1195	// %Ow Locale's alternative numeric rep.
1196
1197	chrono::weekday __wd = _S_weekday(__t);
1198
1199	if (__mod) [[unlikely]]
1200	{
1201	struct tm __tm{};
1202	__tm.tm_wday = __wd.c_encoding();
1203	return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
1204	(char)__conv, `'O'`);
1205	}
1206
1207	unsigned __wdi = __conv == `'u'` ? __wd.iso_encoding()
1208	: __wd.c_encoding();
1209	const _CharT __d = _S_digit(n: __wdi);
1210	return __format::__write(std::move(__out), __string_view(&__d, `1`));
1211	}
1212
1213	template<typename _Tp, typename _FormatContext>
1214	typename _FormatContext::iterator
1215	_M_U_V_W(const _Tp& __t, typename _FormatContext::iterator __out,
1216	_FormatContext& __ctx, _CharT __conv, bool __mod = false) const
1217	{
1218	// %U Week number of the year as a decimal number, from first Sunday.
1219	// %OU Locale's alternative numeric rep.
1220	// %V ISO week-based week number as a decimal number.
1221	// %OV Locale's alternative numeric rep.
1222	// %W Week number of the year as a decimal number, from first Monday.
1223	// %OW Locale's alternative numeric rep.
1224	using namespace chrono;
1225	auto __d = _S_days(__t);
1226	using _TDays = decltype(__d); // Either sys_days or local_days.
1227
1228	if (__mod) [[unlikely]]
1229	{
1230	const year_month_day __ymd(__d);
1231	const year __y = __ymd.year();
1232	struct tm __tm{};
1233	__tm.tm_year = (int)__y - `1900`;
1234	__tm.tm_yday = (__d - _TDays(__y /January /`1`)).count();
1235	__tm.tm_wday = weekday(__d).c_encoding();
1236	return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
1237	(char)__conv, `'O'`);
1238	}
1239
1240	_TDays __first; // First day of week 1.
1241	if (__conv == `'V'`) // W01 begins on Monday before first Thursday.
1242	{
1243	// Move to nearest Thursday:
1244	__d -= (weekday(__d) - Monday) - days (`3`);
1245	// ISO week of __t is number of weeks since January 1 of the
1246	// same year as that nearest Thursday.
1247	__first = _TDays(year_month_day(__d).year()/January /`1`);
1248	}
1249	else
1250	{
1251	year __y;
1252	if constexpr (requires { __t.year(); })
1253	__y = __t.year();
1254	else
1255	__y = year_month_day(__d).year();
1256	const weekday __weekstart = __conv == `'U'` ? Sunday : Monday;
1257	__first = _TDays(__y /January /__weekstart [`1`]);
1258	}
1259	auto __weeks = chrono::floor<weeks>(__d - __first);
1260	__string_view __sv = _S_two_digits(n: __weeks.count() + `1`);
1261	return __format::__write(std::move(__out), __sv);
1262	}
1263
1264	template<typename _Tp, typename _FormatContext>
1265	typename _FormatContext::iterator
1266	_M_x(const _Tp& __t, typename _FormatContext::iterator __out,
1267	_FormatContext& __ctx, bool __mod = false) const
1268	{
1269	// %x Locale's date rep
1270	// %Ex Locale's alternative date representation.
1271	locale __loc = _M_locale(__ctx);
1272	const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1273	const _CharT* __date_reps[`2`];
1274	__tp._M_date_formats(__date_reps);
1275	const _CharT* __rep = __date_reps[__mod];
1276	if (!*__rep)
1277	return _M_D(__t, std::move(__out), __ctx);
1278
1279	basic_string<_CharT> __fmt(_S_empty_spec);
1280	__fmt.insert(`1u`, `1u`, _S_colon);
1281	__fmt.insert(`2u`, __rep);
1282	return std::vformat_to(std::move(__out), __fmt,
1283	std::make_format_args<_FormatContext>(__t));
1284	}
1285
1286	template<typename _Tp, typename _FormatContext>
1287	typename _FormatContext::iterator
1288	_M_X(const _Tp& __tt, typename _FormatContext::iterator __out,
1289	_FormatContext& __ctx, bool __mod = false) const
1290	{
1291	// %X Locale's time rep
1292	// %EX Locale's alternative time representation.
1293	auto __t = _S_floor_seconds(__tt);
1294	locale __loc = _M_locale(__ctx);
1295	const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1296	const _CharT* __time_reps[`2`];
1297	__tp._M_time_formats(__time_reps);
1298	const _CharT* __rep = __time_reps[__mod];
1299	if (!*__rep)
1300	return _M_R_T(__t, std::move(__out), __ctx, true);
1301
1302	basic_string<_CharT> __fmt(_S_empty_spec);
1303	__fmt.insert(`1u`, `1u`, _S_colon);
1304	__fmt.insert(`2u`, __rep);
1305	return std::vformat_to(std::move(__out), __fmt,
1306	std::make_format_args<_FormatContext>(__t));
1307	}
1308
1309	template<typename _Tp, typename _FormatContext>
1310	typename _FormatContext::iterator
1311	_M_z(const _Tp& __t, typename _FormatContext::iterator __out,
1312	_FormatContext&, bool __mod = false) const
1313	{
1314	using ::std::chrono::__detail::__utc_leap_second;
1315	using ::std::chrono::__detail::__local_time_fmt;
1316
1317	auto __utc = __mod ? __string_view(_GLIBCXX_WIDEN("+00:00"), `6`)
1318	: __string_view(_GLIBCXX_WIDEN("+0000"), `5`);
1319
1320	if constexpr (chrono::__is_time_point_v<_Tp>)
1321	{
1322	if constexpr (is_same_v<typename _Tp::clock,
1323	chrono::system_clock>)
1324	return __format::__write(std::move(__out), __utc);
1325	}
1326	else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1327	{
1328	if (__t._M_offset_sec)
1329	{
1330	auto __sv = __utc;
1331	basic_string<_CharT> __s;
1332	if (*__t._M_offset_sec != `0s`)
1333	{
1334	chrono:: hh_mm_ss __hms(*__t._M_offset_sec);
1335	__s = _S_plus_minus[__hms.is_negative()];
1336	__s += _S_two_digits(n: __hms.hours().count());
1337	if (__mod)
1338	__s += _S_colon;
1339	__s += _S_two_digits(n: __hms.minutes().count());
1340	__sv = __s;
1341	}
1342	return __format::__write(std::move(__out), __sv);
1343	}
1344	}
1345	else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1346	return __format::__write(std::move(__out), __utc);
1347
1348	__no_timezone_available();
1349	}
1350
1351	template<typename _Tp, typename _FormatContext>
1352	typename _FormatContext::iterator
1353	_M_Z(const _Tp& __t, typename _FormatContext::iterator __out,
1354	_FormatContext& __ctx) const
1355	{
1356	using ::std::chrono::__detail::__utc_leap_second;
1357	using ::std::chrono::__detail::__local_time_fmt;
1358
1359	__string_view __utc(_GLIBCXX_WIDEN("UTC"), `3`);
1360	if constexpr (chrono::__is_time_point_v<_Tp>)
1361	{
1362	if constexpr (is_same_v<typename _Tp::clock,
1363	chrono::system_clock>)
1364	return __format::__write(std::move(__out), __utc);
1365	}
1366	else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1367	{
1368	if (__t._M_abbrev)
1369	{
1370	string_view __sv = *__t._M_abbrev;
1371	if constexpr (is_same_v<_CharT, char>)
1372	return __format::__write(std::move(__out), __sv);
1373	else
1374	{
1375	// TODO use resize_and_overwrite
1376	basic_string<_CharT> __ws(__sv.size(), _CharT());
1377	auto& __ct = use_facet<ctype<_CharT>>(_M_locale(__ctx));
1378	__ct.widen(__sv.begin(), __sv.end(), __ws.data());
1379	__string_view __wsv = __ws;
1380	return __format::__write(std::move(__out), __wsv);
1381	}
1382	}
1383	}
1384	else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1385	return __format::__write(std::move(__out), __utc);
1386
1387	__no_timezone_available();
1388	}
1389
1390	// %% handled in _M_format
1391
1392	// A single digit character in the range '0'..'9'.
1393	static _CharT
1394	_S_digit(int __n) noexcept
1395	{
1396	// Extra 9s avoid past-the-end read on bad input.
1397	return _GLIBCXX_WIDEN("0123456789999999")[__n & `0xf`];
1398	}
1399
1400	// A string view of two digit characters, "00".."99".
1401	static basic_string_view<_CharT>
1402	_S_two_digits(int __n) noexcept
1403	{
1404	return {
1405	_GLIBCXX_WIDEN("0001020304050607080910111213141516171819"
1406	"2021222324252627282930313233343536373839"
1407	"4041424344454647484950515253545556575859"
1408	"6061626364656667686970717273747576777879"
1409	"8081828384858687888990919293949596979899"
1410	"9999999999999999999999999999999999999999"
1411	"9999999999999999") + `2` * (__n & `0x7f`),
1412	`2`
1413	};
1414	}
1415
1416	// Accessors for the components of chrono types:
1417
1418	// Returns a hh_mm_ss.
1419	template<typename _Tp>
1420	static decltype(auto)
1421	_S_hms(const _Tp& __t)
1422	{
1423	using ::std::chrono::__detail::__utc_leap_second;
1424	using ::std::chrono::__detail::__local_time_fmt;
1425
1426	if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1427	return __t;
1428	else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1429	return __t._M_time;
1430	else if constexpr (chrono::__is_duration_v<_Tp>)
1431	return chrono::hh_mm_ss<_Tp>(__t);
1432	else if constexpr (chrono::__is_time_point_v<_Tp>)
1433	return chrono::hh_mm_ss(__t - chrono::floor<chrono::days>(__t));
1434	else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1435	return _S_hms(__t._M_time);
1436	else
1437	{
1438	__invalid_chrono_spec();
1439	return chrono::hh_mm_ss<chrono::seconds>();
1440	}
1441	}
1442
1443	// Returns a sys_days or local_days.
1444	template<typename _Tp>
1445	static auto
1446	_S_days(const _Tp& __t)
1447	{
1448	using namespace chrono;
1449	using ::std::chrono::__detail::__utc_leap_second;
1450	using ::std::chrono::__detail::__local_time_fmt;
1451
1452	if constexpr (__is_time_point_v<_Tp>)
1453	return chrono::floor<days>(__t);
1454	else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1455	return __t._M_date;
1456	else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1457	return chrono::floor<days>(__t._M_time);
1458	else if constexpr (is_same_v<_Tp, year_month_day>
1459	\|\| is_same_v<_Tp, year_month_day_last>
1460	\|\| is_same_v<_Tp, year_month_weekday>
1461	\|\| is_same_v<_Tp, year_month_weekday_last>)
1462	return sys_days(__t);
1463	else
1464	{
1465	if constexpr (__is_duration_v<_Tp>)
1466	__not_valid_for_duration();
1467	else
1468	__invalid_chrono_spec();
1469	return chrono::sys_days ();
1470	}
1471	}
1472
1473	// Returns a year_month_day.
1474	template<typename _Tp>
1475	static chrono::year_month_day
1476	_S_date(const _Tp& __t)
1477	{
1478	if constexpr (is_same_v<_Tp, chrono::year_month_day>)
1479	return __t;
1480	else
1481	return chrono::year_month_day(_S_days(__t));
1482	}
1483
1484	template<typename _Tp>
1485	static chrono::day
1486	_S_day(const _Tp& __t)
1487	{
1488	using namespace chrono;
1489
1490	if constexpr (is_same_v<_Tp, day>)
1491	return __t;
1492	else if constexpr (requires { __t.day(); })
1493	return __t.day();
1494	else
1495	return _S_date(__t).day();
1496	}
1497
1498	template<typename _Tp>
1499	static chrono::month
1500	_S_month(const _Tp& __t)
1501	{
1502	using namespace chrono;
1503
1504	if constexpr (is_same_v<_Tp, month>)
1505	return __t;
1506	else if constexpr (requires { __t.month(); })
1507	return __t.month();
1508	else
1509	return _S_date(__t).month();
1510	}
1511
1512	template<typename _Tp>
1513	static chrono::year
1514	_S_year(const _Tp& __t)
1515	{
1516	using namespace chrono;
1517
1518	if constexpr (is_same_v<_Tp, year>)
1519	return __t;
1520	else if constexpr (requires { __t.year(); })
1521	return __t.year();
1522	else
1523	return _S_date(__t).year();
1524	}
1525
1526	template<typename _Tp>
1527	static chrono::weekday
1528	_S_weekday(const _Tp& __t)
1529	{
1530	using namespace ::std::chrono;
1531	using ::std::chrono::__detail::__local_time_fmt;
1532
1533	if constexpr (is_same_v<_Tp, weekday>)
1534	return __t;
1535	else if constexpr (requires { __t.weekday(); })
1536	return __t.weekday();
1537	else if constexpr (is_same_v<_Tp, month_weekday>)
1538	return __t.weekday_indexed().weekday();
1539	else if constexpr (is_same_v<_Tp, month_weekday_last>)
1540	return __t.weekday_last().weekday();
1541	else
1542	return weekday(_S_days(__t));
1543	}
1544
1545	// Remove subsecond precision from a time_point.
1546	template<typename _Tp>
1547	static auto
1548	_S_floor_seconds(const _Tp& __t)
1549	{
1550	using chrono::__detail::__local_time_fmt;
1551	if constexpr (chrono::__is_time_point_v<_Tp>
1552	\|\| chrono::__is_duration_v<_Tp>)
1553	{
1554	if constexpr (_Tp::period::den != `1`)
1555	return chrono::floor<chrono::seconds>(__t);
1556	else
1557	return __t;
1558	}
1559	else if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1560	{
1561	if constexpr (_Tp::fractional_width != `0`)
1562	return chrono::floor<chrono::seconds>(__t.to_duration());
1563	else
1564	return __t;
1565	}
1566	else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1567	return _S_floor_seconds(__t._M_time);
1568	else
1569	return __t;
1570	}
1571
1572	// Use the formatting locale's std::time_put facet to produce
1573	// a locale-specific representation.
1574	template<typename _Iter>
1575	_Iter
1576	_M_locale_fmt(_Iter __out, const locale& __loc, const struct tm& __tm,
1577	char __fmt, char __mod) const
1578	{
1579	basic_ostringstream<_CharT> __os;
1580	const auto& __tp = use_facet<time_put<_CharT>>(__loc);
1581	__tp.put(__os, __os, _S_space, &__tm, __fmt, __mod);
1582	if (__os)
1583	__out = __format::__write(std::move(__out), __os.view());
1584	return __out;
1585	}
1586	};
1587
1588	} // namespace __format
1589	/// @endcond
1590
1591	template<typename _Rep, typename _Period, typename _CharT>
1592	struct formatter<chrono::duration<_Rep, _Period>, _CharT>
1593	{
1594	constexpr typename basic_format_parse_context<_CharT>::iterator
1595	parse(basic_format_parse_context<_CharT>& __pc)
1596	{
1597	using namespace __format;
1598	auto __it = _M_f._M_parse(__pc, _Duration \|_TimeOfDay);
1599	if constexpr (!is_floating_point_v<_Rep>)
1600	if (_M_f._M_spec._M_prec_kind != __format::_WP_none)
1601	__throw_format_error(what: "format error: invalid precision for duration");
1602	return __it;
1603	}
1604
1605	template<typename _Out>
1606	typename basic_format_context<_Out, _CharT>::iterator
1607	format(const chrono::duration<_Rep, _Period>& __d,
1608	basic_format_context<_Out, _CharT>& __fc) const
1609	{
1610	if constexpr (numeric_limits<_Rep>::is_signed)
1611	if (__d < __d.zero())
1612	return _M_f._M_format(-__d, __fc, true);
1613	return _M_f._M_format(__d, __fc, false);
1614	}
1615
1616	private:
1617	__format::__formatter_chrono<_CharT> _M_f;
1618	};
1619
1620	template<typename _CharT>
1621	struct formatter<chrono::day, _CharT>
1622	{
1623	template<typename _ParseContext>
1624	constexpr typename _ParseContext::iterator
1625	parse(_ParseContext& __pc)
1626	{ return _M_f._M_parse(__pc, __format::_Day); }
1627
1628	template<typename _FormatContext>
1629	typename _FormatContext::iterator
1630	format(const chrono::day& __t, _FormatContext& __fc) const
1631	{ return _M_f._M_format(__t, __fc); }
1632
1633	private:
1634	__format::__formatter_chrono<_CharT> _M_f;
1635	};
1636
1637	template<typename _CharT>
1638	struct formatter<chrono::month, _CharT>
1639	{
1640	template<typename _ParseContext>
1641	constexpr typename _ParseContext::iterator
1642	parse(_ParseContext& __pc)
1643	{ return _M_f._M_parse(__pc, __format::_Month); }
1644
1645	template<typename _FormatContext>
1646	typename _FormatContext::iterator
1647	format(const chrono::month& __t, _FormatContext& __fc) const
1648	{ return _M_f._M_format(__t, __fc); }
1649
1650	private:
1651	__format::__formatter_chrono<_CharT> _M_f;
1652	};
1653
1654	template<typename _CharT>
1655	struct formatter<chrono::year, _CharT>
1656	{
1657	template<typename _ParseContext>
1658	constexpr typename _ParseContext::iterator
1659	parse(_ParseContext& __pc)
1660	{ return _M_f._M_parse(__pc, __format::_Year); }
1661
1662	template<typename _FormatContext>
1663	typename _FormatContext::iterator
1664	format(const chrono::year& __t, _FormatContext& __fc) const
1665	{ return _M_f._M_format(__t, __fc); }
1666
1667	private:
1668	__format::__formatter_chrono<_CharT> _M_f;
1669	};
1670
1671	template<typename _CharT>
1672	struct formatter<chrono::weekday, _CharT>
1673	{
1674	template<typename _ParseContext>
1675	constexpr typename _ParseContext::iterator
1676	parse(_ParseContext& __pc)
1677	{ return _M_f._M_parse(__pc, __format::_Weekday); }
1678
1679	template<typename _FormatContext>
1680	typename _FormatContext::iterator
1681	format(const chrono::weekday& __t, _FormatContext& __fc) const
1682	{ return _M_f._M_format(__t, __fc); }
1683
1684	private:
1685	__format::__formatter_chrono<_CharT> _M_f;
1686	};
1687
1688	template<typename _CharT>
1689	struct formatter<chrono::weekday_indexed, _CharT>
1690	{
1691	template<typename _ParseContext>
1692	constexpr typename _ParseContext::iterator
1693	parse(_ParseContext& __pc)
1694	{ return _M_f._M_parse(__pc, __format::_Weekday); }
1695
1696	template<typename _FormatContext>
1697	typename _FormatContext::iterator
1698	format(const chrono::weekday_indexed& __t, _FormatContext& __fc) const
1699	{ return _M_f._M_format(__t, __fc); }
1700
1701	private:
1702	__format::__formatter_chrono<_CharT> _M_f;
1703	};
1704
1705	template<typename _CharT>
1706	struct formatter<chrono::weekday_last, _CharT>
1707	{
1708	template<typename _ParseContext>
1709	constexpr typename _ParseContext::iterator
1710	parse(_ParseContext& __pc)
1711	{ return _M_f._M_parse(__pc, __format::_Weekday); }
1712
1713	template<typename _FormatContext>
1714	typename _FormatContext::iterator
1715	format(const chrono::weekday_last& __t, _FormatContext& __fc) const
1716	{ return _M_f._M_format(__t, __fc); }
1717
1718	private:
1719	__format::__formatter_chrono<_CharT> _M_f;
1720	};
1721
1722	template<typename _CharT>
1723	struct formatter<chrono::month_day, _CharT>
1724	{
1725	template<typename _ParseContext>
1726	constexpr typename _ParseContext::iterator
1727	parse(_ParseContext& __pc)
1728	{ return _M_f._M_parse(__pc, __format::_Month \|__format::_Day); }
1729
1730	template<typename _FormatContext>
1731	typename _FormatContext::iterator
1732	format(const chrono::month_day& __t, _FormatContext& __fc) const
1733	{ return _M_f._M_format(__t, __fc); }
1734
1735	private:
1736	__format::__formatter_chrono<_CharT> _M_f;
1737	};
1738
1739	template<typename _CharT>
1740	struct formatter<chrono::month_day_last, _CharT>
1741	{
1742	template<typename _ParseContext>
1743	constexpr typename _ParseContext::iterator
1744	parse(_ParseContext& __pc)
1745	{ return _M_f._M_parse(__pc, __format::_Month \|__format::_Day); }
1746
1747	template<typename _FormatContext>
1748	typename _FormatContext::iterator
1749	format(const chrono::month_day_last& __t, _FormatContext& __fc) const
1750	{ return _M_f._M_format(__t, __fc); }
1751
1752	private:
1753	__format::__formatter_chrono<_CharT> _M_f;
1754	};
1755
1756	template<typename _CharT>
1757	struct formatter<chrono::month_weekday, _CharT>
1758	{
1759	template<typename _ParseContext>
1760	constexpr typename _ParseContext::iterator
1761	parse(_ParseContext& __pc)
1762	{ return _M_f._M_parse(__pc, __format::_Month \|__format::_Weekday); }
1763
1764	template<typename _FormatContext>
1765	typename _FormatContext::iterator
1766	format(const chrono::month_weekday& __t, _FormatContext& __fc) const
1767	{ return _M_f._M_format(__t, __fc); }
1768
1769	private:
1770	__format::__formatter_chrono<_CharT> _M_f;
1771	};
1772
1773	template<typename _CharT>
1774	struct formatter<chrono::month_weekday_last, _CharT>
1775	{
1776	template<typename _ParseContext>
1777	constexpr typename _ParseContext::iterator
1778	parse(_ParseContext& __pc)
1779	{ return _M_f._M_parse(__pc, __format::_Month \|__format::_Weekday); }
1780
1781	template<typename _FormatContext>
1782	typename _FormatContext::iterator
1783	format(const chrono::month_weekday_last& __t,
1784	_FormatContext& __fc) const
1785	{ return _M_f._M_format(__t, __fc); }
1786
1787	private:
1788	__format::__formatter_chrono<_CharT> _M_f;
1789	};
1790
1791	template<typename _CharT>
1792	struct formatter<chrono::year_month, _CharT>
1793	{
1794	template<typename _ParseContext>
1795	constexpr typename _ParseContext::iterator
1796	parse(_ParseContext& __pc)
1797	{ return _M_f._M_parse(__pc, __format::_Year \|__format::_Month); }
1798
1799	template<typename _FormatContext>
1800	typename _FormatContext::iterator
1801	format(const chrono::year_month& __t, _FormatContext& __fc) const
1802	{ return _M_f._M_format(__t, __fc); }
1803
1804	private:
1805	__format::__formatter_chrono<_CharT> _M_f;
1806	};
1807
1808	template<typename _CharT>
1809	struct formatter<chrono::year_month_day, _CharT>
1810	{
1811	template<typename _ParseContext>
1812	constexpr typename _ParseContext::iterator
1813	parse(_ParseContext& __pc)
1814	{ return _M_f._M_parse(__pc, __format::_Date); }
1815
1816	template<typename _FormatContext>
1817	typename _FormatContext::iterator
1818	format(const chrono::year_month_day& __t, _FormatContext& __fc) const
1819	{ return _M_f._M_format(__t, __fc); }
1820
1821	private:
1822	__format::__formatter_chrono<_CharT> _M_f;
1823	};
1824
1825	template<typename _CharT>
1826	struct formatter<chrono::year_month_day_last, _CharT>
1827	{
1828	template<typename _ParseContext>
1829	constexpr typename _ParseContext::iterator
1830	parse(_ParseContext& __pc)
1831	{ return _M_f._M_parse(__pc, __format::_Date); }
1832
1833	template<typename _FormatContext>
1834	typename _FormatContext::iterator
1835	format(const chrono::year_month_day_last& __t,
1836	_FormatContext& __fc) const
1837	{ return _M_f._M_format(__t, __fc); }
1838
1839	private:
1840	__format::__formatter_chrono<_CharT> _M_f;
1841	};
1842
1843	template<typename _CharT>
1844	struct formatter<chrono::year_month_weekday, _CharT>
1845	{
1846	template<typename _ParseContext>
1847	constexpr typename _ParseContext::iterator
1848	parse(_ParseContext& __pc)
1849	{ return _M_f._M_parse(__pc, __format::_Date); }
1850
1851	template<typename _FormatContext>
1852	typename _FormatContext::iterator
1853	format(const chrono::year_month_weekday& __t,
1854	_FormatContext& __fc) const
1855	{ return _M_f._M_format(__t, __fc); }
1856
1857	private:
1858	__format::__formatter_chrono<_CharT> _M_f;
1859	};
1860
1861	template<typename _CharT>
1862	struct formatter<chrono::year_month_weekday_last, _CharT>
1863	{
1864	template<typename _ParseContext>
1865	constexpr typename _ParseContext::iterator
1866	parse(_ParseContext& __pc)
1867	{ return _M_f._M_parse(__pc, __format::_Date); }
1868
1869	template<typename _FormatContext>
1870	typename _FormatContext::iterator
1871	format(const chrono::year_month_weekday_last& __t,
1872	_FormatContext& __fc) const
1873	{ return _M_f._M_format(__t, __fc); }
1874
1875	private:
1876	__format::__formatter_chrono<_CharT> _M_f;
1877	};
1878
1879	template<typename _Rep, typename _Period, typename _CharT>
1880	struct formatter<chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>, _CharT>
1881	{
1882	template<typename _ParseContext>
1883	constexpr typename _ParseContext::iterator
1884	parse(_ParseContext& __pc)
1885	{ return _M_f._M_parse(__pc, __format::_TimeOfDay); }
1886
1887	template<typename _FormatContext>
1888	typename _FormatContext::iterator
1889	format(const chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>& __t,
1890	_FormatContext& __fc) const
1891	{ return _M_f._M_format(__t, __fc); }
1892
1893	private:
1894	__format::__formatter_chrono<_CharT> _M_f;
1895	};
1896
1897	#if _GLIBCXX_USE_CXX11_ABI \|\| ! _GLIBCXX_USE_DUAL_ABI
1898	template<typename _CharT>
1899	struct formatter<chrono::sys_info, _CharT>
1900	{
1901	template<typename _ParseContext>
1902	constexpr typename _ParseContext::iterator
1903	parse(_ParseContext& __pc)
1904	{ return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
1905
1906	template<typename _FormatContext>
1907	typename _FormatContext::iterator
1908	format(const chrono::sys_info& __i, _FormatContext& __fc) const
1909	{ return _M_f._M_format(__i, __fc); }
1910
1911	private:
1912	__format::__formatter_chrono<_CharT> _M_f;
1913	};
1914
1915	template<typename _CharT>
1916	struct formatter<chrono::local_info, _CharT>
1917	{
1918	template<typename _ParseContext>
1919	constexpr typename _ParseContext::iterator
1920	parse(_ParseContext& __pc)
1921	{ return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
1922
1923	template<typename _FormatContext>
1924	typename _FormatContext::iterator
1925	format(const chrono::local_info& __i, _FormatContext& __fc) const
1926	{ return _M_f._M_format(__i, __fc); }
1927
1928	private:
1929	__format::__formatter_chrono<_CharT> _M_f;
1930	};
1931	#endif
1932
1933	template<typename _Duration, typename _CharT>
1934	struct formatter<chrono::sys_time<_Duration>, _CharT>
1935	{
1936	template<typename _ParseContext>
1937	constexpr typename _ParseContext::iterator
1938	parse(_ParseContext& __pc)
1939	{
1940	auto __next = _M_f._M_parse(__pc, __format::_ZonedDateTime);
1941	if constexpr (!__stream_insertable)
1942	if (_M_f._M_spec._M_chrono_specs.empty())
1943	__format::__invalid_chrono_spec(); // chrono-specs can't be empty
1944	return __next;
1945	}
1946
1947	template<typename _FormatContext>
1948	typename _FormatContext::iterator
1949	format(const chrono::sys_time<_Duration>& __t,
1950	_FormatContext& __fc) const
1951	{ return _M_f._M_format(__t, __fc); }
1952
1953	private:
1954	static constexpr bool __stream_insertable
1955	= requires (basic_ostream<_CharT>& __os,
1956	chrono::sys_time<_Duration> __t) { __os << __t; };
1957
1958	__format::__formatter_chrono<_CharT> _M_f;
1959	};
1960
1961	template<typename _Duration, typename _CharT>
1962	struct formatter<chrono::utc_time<_Duration>, _CharT>
1963	: __format::__formatter_chrono<_CharT>
1964	{
1965	template<typename _ParseContext>
1966	constexpr typename _ParseContext::iterator
1967	parse(_ParseContext& __pc)
1968	{ return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
1969
1970	template<typename _FormatContext>
1971	typename _FormatContext::iterator
1972	format(const chrono::utc_time<_Duration>& __t,
1973	_FormatContext& __fc) const
1974	{
1975	// Adjust by removing leap seconds to get equivalent sys_time.
1976	// We can't just use clock_cast because we want to know if the time
1977	// falls within a leap second insertion, and format seconds as "60".
1978	using chrono::__detail::__utc_leap_second;
1979	using chrono::seconds;
1980	using chrono::sys_time;
1981	using _CDur = common_type_t<_Duration, seconds>;
1982	const auto __li = chrono::get_leap_second_info(__t);
1983	sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
1984	if (!__li.is_leap_second) [[likely]]
1985	return _M_f._M_format(__s, __fc);
1986	else
1987	return _M_f._M_format(__utc_leap_second(__s), __fc);
1988	}
1989
1990	private:
1991	friend formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>;
1992
1993	__format::__formatter_chrono<_CharT> _M_f;
1994	};
1995
1996	template<typename _Duration, typename _CharT>
1997	struct formatter<chrono::tai_time<_Duration>, _CharT>
1998	: __format::__formatter_chrono<_CharT>
1999	{
2000	template<typename _ParseContext>
2001	constexpr typename _ParseContext::iterator
2002	parse(_ParseContext& __pc)
2003	{ return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2004
2005	template<typename _FormatContext>
2006	typename _FormatContext::iterator
2007	format(const chrono::tai_time<_Duration>& __t,
2008	_FormatContext& __fc) const
2009	{
2010	// Convert to __local_time_fmt with abbrev "TAI" and offset 0s.
2011
2012	// Offset is 1970y/January/1 - 1958y/January/1
2013	constexpr chrono::days __tai_offset = chrono::days (`4383`);
2014	using _CDur = common_type_t<_Duration, chrono::days>;
2015	chrono::local_time<_CDur> __lt(__t.time_since_epoch() - __tai_offset);
2016	const string __abbrev("TAI", `3`);
2017	const chrono::seconds __off = `0s`;
2018	const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
2019	return _M_f._M_format(__lf, __fc);
2020	}
2021
2022	private:
2023	__format::__formatter_chrono<_CharT> _M_f;
2024	};
2025
2026	template<typename _Duration, typename _CharT>
2027	struct formatter<chrono::gps_time<_Duration>, _CharT>
2028	: __format::__formatter_chrono<_CharT>
2029	{
2030	template<typename _ParseContext>
2031	constexpr typename _ParseContext::iterator
2032	parse(_ParseContext& __pc)
2033	{ return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2034
2035	template<typename _FormatContext>
2036	typename _FormatContext::iterator
2037	format(const chrono::gps_time<_Duration>& __t,
2038	_FormatContext& __fc) const
2039	{
2040	// Convert to __local_time_fmt with abbrev "GPS" and offset 0s.
2041
2042	// Offset is 1980y/January/Sunday[1] - 1970y/January/1
2043	constexpr chrono::days __gps_offset = chrono::days (`3657`);
2044	using _CDur = common_type_t<_Duration, chrono::days>;
2045	chrono::local_time<_CDur> __lt(__t.time_since_epoch() + __gps_offset);
2046	const string __abbrev("GPS", `3`);
2047	const chrono::seconds __off = `0s`;
2048	const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
2049	return _M_f._M_format(__lf, __fc);
2050	}
2051
2052	private:
2053	__format::__formatter_chrono<_CharT> _M_f;
2054	};
2055
2056	template<typename _Duration, typename _CharT>
2057	struct formatter<chrono::file_time<_Duration>, _CharT>
2058	{
2059	template<typename _ParseContext>
2060	constexpr typename _ParseContext::iterator
2061	parse(_ParseContext& __pc)
2062	{ return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2063
2064	template<typename _FormatContext>
2065	typename _FormatContext::iterator
2066	format(const chrono::file_time<_Duration>& __t,
2067	_FormatContext& __ctx) const
2068	{
2069	using namespace chrono;
2070	return _M_f._M_format(chrono::clock_cast<system_clock>(__t), __ctx);
2071	}
2072
2073	private:
2074	__format::__formatter_chrono<_CharT> _M_f;
2075	};
2076
2077	template<typename _Duration, typename _CharT>
2078	struct formatter<chrono::local_time<_Duration>, _CharT>
2079	{
2080	template<typename _ParseContext>
2081	constexpr typename _ParseContext::iterator
2082	parse(_ParseContext& __pc)
2083	{ return _M_f._M_parse(__pc, __format::_DateTime); }
2084
2085	template<typename _FormatContext>
2086	typename _FormatContext::iterator
2087	format(const chrono::local_time<_Duration>& __t,
2088	_FormatContext& __ctx) const
2089	{ return _M_f._M_format(__t, __ctx); }
2090
2091	private:
2092	__format::__formatter_chrono<_CharT> _M_f;
2093	};
2094
2095	template<typename _Duration, typename _CharT>
2096	struct formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT>
2097	{
2098	template<typename _ParseContext>
2099	constexpr typename _ParseContext::iterator
2100	parse(_ParseContext& __pc)
2101	{ return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2102
2103	template<typename _FormatContext>
2104	typename _FormatContext::iterator
2105	format(const chrono::__detail::__local_time_fmt<_Duration>& __t,
2106	_FormatContext& __ctx) const
2107	{ return _M_f._M_format(__t, __ctx); }
2108
2109	private:
2110	__format::__formatter_chrono<_CharT> _M_f;
2111	};
2112
2113	#if _GLIBCXX_USE_CXX11_ABI \|\| ! _GLIBCXX_USE_DUAL_ABI
2114	template<typename _Duration, typename _TimeZonePtr, typename _CharT>
2115	struct formatter<chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT>
2116	: formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT>
2117	{
2118	template<typename _FormatContext>
2119	typename _FormatContext::iterator
2120	format(const chrono::zoned_time<_Duration, _TimeZonePtr>& __tp,
2121	_FormatContext& __ctx) const
2122	{
2123	using chrono::__detail::__local_time_fmt;
2124	using _Base = formatter<__local_time_fmt<_Duration>, _CharT>;
2125	const chrono::sys_info __info = __tp.get_info();
2126	const auto __lf = chrono::local_time_format(__tp.get_local_time(),
2127	&__info.abbrev,
2128	&__info.offset);
2129	return _Base::format(__lf, __ctx);
2130	}
2131	};
2132	#endif
2133
2134	// Partial specialization needed for %c formatting of __utc_leap_second.
2135	template<typename _Duration, typename _CharT>
2136	struct formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>
2137	: formatter<chrono::utc_time<_Duration>, _CharT>
2138	{
2139	template<typename _FormatContext>
2140	typename _FormatContext::iterator
2141	format(const chrono::__detail::__utc_leap_second<_Duration>& __t,
2142	_FormatContext& __fc) const
2143	{ return this->_M_f._M_format(__t, __fc); }
2144	};
2145
2146	namespace chrono
2147	{
2148	/// @addtogroup chrono
2149	/// @{
2150
2151	/// @cond undocumented
2152	namespace __detail
2153	{
2154	template<typename _Duration = seconds>
2155	struct _Parser
2156	{
2157	static_assert(is_same_v<common_type_t<_Duration, seconds>, _Duration>);
2158
2159	explicit
2160	_Parser(__format::_ChronoParts __need) : _M_need(__need) { }
2161
2162	_Parser(_Parser&&) = delete;
2163	void operator=(_Parser&&) = delete;
2164
2165	_Duration _M_time{}; // since midnight
2166	sys_days _M_sys_days{};
2167	year_month_day _M_ymd{};
2168	weekday _M_wd{};
2169	__format::_ChronoParts _M_need;
2170	unsigned _M_is_leap_second : `1` {};
2171	unsigned _M_reserved : `15` {};
2172
2173	template<typename _CharT, typename _Traits, typename _Alloc>
2174	basic_istream<_CharT, _Traits>&
2175	operator()(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2176	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2177	minutes* __offset = nullptr);
2178
2179	private:
2180	// Read an unsigned integer from the stream and return it.
2181	// Extract no more than __n digits. Set failbit if an integer isn't read.
2182	template<typename _CharT, typename _Traits>
2183	static int_least32_t
2184	_S_read_unsigned(basic_istream<_CharT, _Traits>& __is,
2185	ios_base::iostate& __err, int __n)
2186	{
2187	int_least32_t __val = _S_try_read_digit(__is, __err);
2188	if (__val == -`1`) [[unlikely]]
2189	__err \|= ios_base::failbit;
2190	else
2191	{
2192	int __n1 = (std::min)(a: __n, b: `9`);
2193	// Cannot overflow __val unless we read more than 9 digits
2194	for (int __i = `1`; __i < __n1; ++__i)
2195	if (auto __dig = _S_try_read_digit(__is, __err); __dig != -`1`)
2196	{
2197	__val *= `10`;
2198	__val += __dig;
2199	}
2200
2201	while (__n1++ < __n) [[unlikely]]
2202	if (auto __dig = _S_try_read_digit(__is, __err); __dig != -`1`)
2203	{
2204	if (__builtin_mul_overflow(__val, `10`, &__val)
2205	\|\| __builtin_add_overflow(__val, __dig, &__val))
2206	{
2207	__err \|= ios_base::failbit;
2208	return -`1`;
2209	}
2210	}
2211	}
2212	return __val;
2213	}
2214
2215	// Read an unsigned integer from the stream and return it.
2216	// Extract no more than __n digits. Set failbit if an integer isn't read.
2217	template<typename _CharT, typename _Traits>
2218	static int_least32_t
2219	_S_read_signed(basic_istream<_CharT, _Traits>& __is,
2220	ios_base::iostate& __err, int __n)
2221	{
2222	auto __sign = __is.peek();
2223	if (__sign == `'-'` \|\| __sign == `'+'`)
2224	(void) __is.get();
2225	int_least32_t __val = _S_read_unsigned(__is, __err, __n);
2226	if (__err & ios_base::failbit)
2227	{
2228	if (__sign == `'-'`) [[unlikely]]
2229	__val *= -`1`;
2230	}
2231	return __val;
2232	}
2233
2234	// Read a digit from the stream and return it, or return -1.
2235	// If no digit is read eofbit will be set (but not failbit).
2236	template<typename _CharT, typename _Traits>
2237	static int_least32_t
2238	_S_try_read_digit(basic_istream<_CharT, _Traits>& __is,
2239	ios_base::iostate& __err)
2240	{
2241	int_least32_t __val = -`1`;
2242	auto __i = __is.peek();
2243	if (!_Traits::eq_int_type(__i, _Traits::eof())) [[likely]]
2244	{
2245	_CharT __c = _Traits::to_char_type(__i);
2246	if (_CharT(`'0'`) <= __c && __c <= _CharT(`'9'`)) [[likely]]
2247	{
2248	(void) __is.get();
2249	__val = __c - _CharT(`'0'`);
2250	}
2251	}
2252	else
2253	__err \|= ios_base::eofbit;
2254	return __val;
2255	}
2256
2257	// Read the specified character and return true.
2258	// If the character is not found, set failbit and return false.
2259	template<typename _CharT, typename _Traits>
2260	static bool
2261	_S_read_chr(basic_istream<_CharT, _Traits>& __is,
2262	ios_base::iostate& __err, _CharT __c)
2263	{
2264	auto __i = __is.peek();
2265	if (_Traits::eq_int_type(__i, _Traits::eof()))
2266	__err \|= ios_base::eofbit;
2267	else if (_Traits::to_char_type(__i) == __c) [[likely]]
2268	{
2269	(void) __is.get();
2270	return true;
2271	}
2272	__err \|= ios_base::failbit;
2273	return false;
2274	}
2275	};
2276
2277	template<typename _Duration>
2278	using _Parser_t = _Parser<common_type_t<_Duration, seconds>>;
2279
2280	} // namespace __detail
2281	/// @endcond
2282
2283	template<typename _CharT, typename _Traits, typename _Rep, typename _Period,
2284	typename _Alloc = allocator<_CharT>>
2285	inline basic_istream<_CharT, _Traits>&
2286	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2287	duration<_Rep, _Period>& __d,
2288	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2289	minutes* __offset = nullptr)
2290	{
2291	auto __need = __format::_ChronoParts::_TimeOfDay;
2292	__detail::_Parser_t<duration<_Rep, _Period>> __p(__need);
2293	if (__p(__is, __fmt, __abbrev, __offset))
2294	__d = chrono::duration_cast<duration<_Rep, _Period>>(__p._M_time);
2295	return __is;
2296	}
2297
2298	template<typename _CharT, typename _Traits>
2299	inline basic_ostream<_CharT, _Traits>&
2300	operator<<(basic_ostream<_CharT, _Traits>& __os, const day& __d)
2301	{
2302	using _Ctx = __format::__format_context<_CharT>;
2303	using _Str = basic_string_view<_CharT>;
2304	_Str __s = _GLIBCXX_WIDEN("{:02d} is not a valid day");
2305	if (__d.ok())
2306	__s = __s.substr(`0`, `6`);
2307	auto __u = (unsigned)__d;
2308	__os << std::vformat(__s, make_format_args<_Ctx>(__u));
2309	return __os;
2310	}
2311
2312	template<typename _CharT, typename _Traits,
2313	typename _Alloc = allocator<_CharT>>
2314	inline basic_istream<_CharT, _Traits>&
2315	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2316	day& __d,
2317	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2318	minutes* __offset = nullptr)
2319	{
2320	__detail::_Parser<> __p(__format::_ChronoParts::_Day);
2321	if (__p(__is, __fmt, __abbrev, __offset))
2322	__d = __p._M_ymd.day();
2323	return __is;
2324	}
2325
2326	template<typename _CharT, typename _Traits>
2327	inline basic_ostream<_CharT, _Traits>&
2328	operator<<(basic_ostream<_CharT, _Traits>& __os, const month& __m)
2329	{
2330	using _Ctx = __format::__format_context<_CharT>;
2331	using _Str = basic_string_view<_CharT>;
2332	_Str __s = _GLIBCXX_WIDEN("{:L%b}{} is not a valid month");
2333	if (__m.ok())
2334	__os << std::vformat(__os.getloc(), __s.substr(`0`, `6`),
2335	make_format_args<_Ctx>(__m));
2336	else
2337	{
2338	auto __u = (unsigned)__m;
2339	__os << std::vformat(__s.substr(`6`), make_format_args<_Ctx>(__u));
2340	}
2341	return __os;
2342	}
2343
2344	template<typename _CharT, typename _Traits,
2345	typename _Alloc = allocator<_CharT>>
2346	inline basic_istream<_CharT, _Traits>&
2347	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2348	month& __m,
2349	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2350	minutes* __offset = nullptr)
2351	{
2352	__detail::_Parser<> __p(__format::_ChronoParts::_Month);
2353	if (__p(__is, __fmt, __abbrev, __offset))
2354	__m = __p._M_ymd.month();
2355	return __is;
2356	}
2357
2358	template<typename _CharT, typename _Traits>
2359	inline basic_ostream<_CharT, _Traits>&
2360	operator<<(basic_ostream<_CharT, _Traits>& __os, const year& __y)
2361	{
2362	using _Ctx = __format::__format_context<_CharT>;
2363	using _Str = basic_string_view<_CharT>;
2364	_Str __s = _GLIBCXX_WIDEN("-{:04d} is not a valid year");
2365	if (__y.ok())
2366	__s = __s.substr(`0`, `7`);
2367	int __i = (int)__y;
2368	if (__i >= `0`) [[likely]]
2369	__s.remove_prefix(`1`);
2370	else
2371	__i = -__i;
2372	__os << std::vformat(__s, make_format_args<_Ctx>(__i));
2373	return __os;
2374	}
2375
2376	template<typename _CharT, typename _Traits,
2377	typename _Alloc = allocator<_CharT>>
2378	inline basic_istream<_CharT, _Traits>&
2379	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2380	year& __y,
2381	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2382	minutes* __offset = nullptr)
2383	{
2384	__detail::_Parser<> __p(__format::_ChronoParts::_Year);
2385	if (__p(__is, __fmt, __abbrev, __offset))
2386	__y = __p._M_ymd.year();
2387	return __is;
2388	}
2389
2390	template<typename _CharT, typename _Traits>
2391	inline basic_ostream<_CharT, _Traits>&
2392	operator<<(basic_ostream<_CharT, _Traits>& __os, const weekday& __wd)
2393	{
2394	using _Ctx = __format::__format_context<_CharT>;
2395	using _Str = basic_string_view<_CharT>;
2396	_Str __s = _GLIBCXX_WIDEN("{:L%a}{} is not a valid weekday");
2397	if (__wd.ok())
2398	__os << std::vformat(__os.getloc(), __s.substr(`0`, `6`),
2399	make_format_args<_Ctx>(__wd));
2400	else
2401	{
2402	auto __c = __wd.c_encoding();
2403	__os << std::vformat(__s.substr(`6`), make_format_args<_Ctx>(__c));
2404	}
2405	return __os;
2406	}
2407
2408	template<typename _CharT, typename _Traits,
2409	typename _Alloc = allocator<_CharT>>
2410	inline basic_istream<_CharT, _Traits>&
2411	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2412	weekday& __wd,
2413	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2414	minutes* __offset = nullptr)
2415	{
2416	__detail::_Parser<> __p(__format::_ChronoParts::_Weekday);
2417	if (__p(__is, __fmt, __abbrev, __offset))
2418	__wd = __p._M_wd;
2419	return __is;
2420	}
2421
2422	template<typename _CharT, typename _Traits>
2423	inline basic_ostream<_CharT, _Traits>&
2424	operator<<(basic_ostream<_CharT, _Traits>& __os,
2425	const weekday_indexed& __wdi)
2426	{
2427	// The standard says to format wdi.weekday() and wdi.index() using
2428	// either "{:L}[{}]" or "{:L}[{} is not a valid index]". The {:L} spec
2429	// means to format the weekday using ostringstream, so just do that.
2430	basic_stringstream<_CharT> __os2;
2431	__os2.imbue(__os.getloc());
2432	__os2 << __wdi.weekday();
2433	const auto __i = __wdi.index();
2434	basic_string_view<_CharT> __s
2435	= _GLIBCXX_WIDEN("[ is not a valid index]");
2436	__os2 << __s[`0`];
2437	__os2 << std::format(_GLIBCXX_WIDEN("{}"), __i);
2438	if (__i >= `1` && __i <= `5`)
2439	__os2 << __s.back();
2440	else
2441	__os2 << __s.substr(`1`);
2442	__os << __os2.view();
2443	return __os;
2444	}
2445
2446	template<typename _CharT, typename _Traits>
2447	inline basic_ostream<_CharT, _Traits>&
2448	operator<<(basic_ostream<_CharT, _Traits>& __os,
2449	const weekday_last& __wdl)
2450	{
2451	// As above, just write straight to a stringstream, as if by "{:L}[last]"
2452	basic_stringstream<_CharT> __os2;
2453	__os2.imbue(__os.getloc());
2454	__os2 << __wdl.weekday() << _GLIBCXX_WIDEN("[last]");
2455	__os << __os2.view();
2456	return __os;
2457	}
2458
2459	template<typename _CharT, typename _Traits>
2460	inline basic_ostream<_CharT, _Traits>&
2461	operator<<(basic_ostream<_CharT, _Traits>& __os, const month_day& __md)
2462	{
2463	// As above, just write straight to a stringstream, as if by "{:L}/{}"
2464	basic_stringstream<_CharT> __os2;
2465	__os2.imbue(__os.getloc());
2466	__os2 << __md.month();
2467	if constexpr (is_same_v<_CharT, char>)
2468	__os2 << `'/'`;
2469	else
2470	__os2 << L`'/'`;
2471	__os2 << __md.day();
2472	__os << __os2.view();
2473	return __os;
2474	}
2475
2476	template<typename _CharT, typename _Traits,
2477	typename _Alloc = allocator<_CharT>>
2478	inline basic_istream<_CharT, _Traits>&
2479	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2480	month_day& __md,
2481	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2482	minutes* __offset = nullptr)
2483	{
2484	using __format::_ChronoParts;
2485	auto __need = _ChronoParts::_Month \| _ChronoParts::_Day;
2486	__detail::_Parser<> __p(__need);
2487	if (__p(__is, __fmt, __abbrev, __offset))
2488	__md = month_day (__p._M_ymd.month(), __p._M_ymd.day());
2489	return __is;
2490	}
2491
2492	template<typename _CharT, typename _Traits>
2493	inline basic_ostream<_CharT, _Traits>&
2494	operator<<(basic_ostream<_CharT, _Traits>& __os,
2495	const month_day_last& __mdl)
2496	{
2497	// As above, just write straight to a stringstream, as if by "{:L}/last"
2498	basic_stringstream<_CharT> __os2;
2499	__os2.imbue(__os.getloc());
2500	__os2 << __mdl.month() << _GLIBCXX_WIDEN("/last");
2501	__os << __os2.view();
2502	return __os;
2503	}
2504
2505	template<typename _CharT, typename _Traits>
2506	inline basic_ostream<_CharT, _Traits>&
2507	operator<<(basic_ostream<_CharT, _Traits>& __os,
2508	const month_weekday& __mwd)
2509	{
2510	// As above, just write straight to a stringstream, as if by "{:L}/{:L}"
2511	basic_stringstream<_CharT> __os2;
2512	__os2.imbue(__os.getloc());
2513	__os2 << __mwd.month();
2514	if constexpr (is_same_v<_CharT, char>)
2515	__os2 << `'/'`;
2516	else
2517	__os2 << L`'/'`;
2518	__os2 << __mwd.weekday_indexed();
2519	__os << __os2.view();
2520	return __os;
2521	}
2522
2523	template<typename _CharT, typename _Traits>
2524	inline basic_ostream<_CharT, _Traits>&
2525	operator<<(basic_ostream<_CharT, _Traits>& __os,
2526	const month_weekday_last& __mwdl)
2527	{
2528	// As above, just write straight to a stringstream, as if by "{:L}/{:L}"
2529	basic_stringstream<_CharT> __os2;
2530	__os2.imbue(__os.getloc());
2531	__os2 << __mwdl.month();
2532	if constexpr (is_same_v<_CharT, char>)
2533	__os2 << `'/'`;
2534	else
2535	__os2 << L`'/'`;
2536	__os2 << __mwdl.weekday_last();
2537	__os << __os2.view();
2538	return __os;
2539	}
2540
2541	template<typename _CharT, typename _Traits>
2542	inline basic_ostream<_CharT, _Traits>&
2543	operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month& __ym)
2544	{
2545	// As above, just write straight to a stringstream, as if by "{}/{:L}"
2546	basic_stringstream<_CharT> __os2;
2547	__os2.imbue(__os.getloc());
2548	__os2 << __ym.year();
2549	if constexpr (is_same_v<_CharT, char>)
2550	__os2 << `'/'`;
2551	else
2552	__os2 << L`'/'`;
2553	__os2 << __ym.month();
2554	__os << __os2.view();
2555	return __os;
2556	}
2557
2558	template<typename _CharT, typename _Traits,
2559	typename _Alloc = allocator<_CharT>>
2560	inline basic_istream<_CharT, _Traits>&
2561	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2562	year_month& __ym,
2563	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2564	minutes* __offset = nullptr)
2565	{
2566	using __format::_ChronoParts;
2567	auto __need = _ChronoParts::_Year \| _ChronoParts::_Month;
2568	__detail::_Parser<> __p(__need);
2569	if (__p(__is, __fmt, __abbrev, __offset))
2570	__ym = year_month (__p._M_ymd.year(), __p._M_ymd.month());
2571	return __is;
2572	}
2573
2574	template<typename _CharT, typename _Traits>
2575	inline basic_ostream<_CharT, _Traits>&
2576	operator<<(basic_ostream<_CharT, _Traits>& __os,
2577	const year_month_day& __ymd)
2578	{
2579	using _Ctx = __format::__format_context<_CharT>;
2580	using _Str = basic_string_view<_CharT>;
2581	_Str __s = _GLIBCXX_WIDEN("{:%F} is not a valid date");
2582	__os << std::vformat(__ymd.ok() ? __s.substr(`0`, `5`) : __s,
2583	make_format_args<_Ctx>(__ymd));
2584	return __os;
2585	}
2586
2587	template<typename _CharT, typename _Traits,
2588	typename _Alloc = allocator<_CharT>>
2589	inline basic_istream<_CharT, _Traits>&
2590	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2591	year_month_day& __ymd,
2592	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2593	minutes* __offset = nullptr)
2594	{
2595	using __format::_ChronoParts;
2596	auto __need = _ChronoParts::_Year \| _ChronoParts::_Month
2597	\| _ChronoParts::_Day;
2598	__detail::_Parser<> __p(__need);
2599	if (__p(__is, __fmt, __abbrev, __offset))
2600	__ymd = __p._M_ymd;
2601	return __is;
2602	}
2603
2604	template<typename _CharT, typename _Traits>
2605	inline basic_ostream<_CharT, _Traits>&
2606	operator<<(basic_ostream<_CharT, _Traits>& __os,
2607	const year_month_day_last& __ymdl)
2608	{
2609	// As above, just write straight to a stringstream, as if by "{}/{:L}"
2610	basic_stringstream<_CharT> __os2;
2611	__os2.imbue(__os.getloc());
2612	__os2 << __ymdl.year();
2613	if constexpr (is_same_v<_CharT, char>)
2614	__os2 << `'/'`;
2615	else
2616	__os2 << L`'/'`;
2617	__os2 << __ymdl.month_day_last();
2618	__os << __os2.view();
2619	return __os;
2620	}
2621
2622	template<typename _CharT, typename _Traits>
2623	inline basic_ostream<_CharT, _Traits>&
2624	operator<<(basic_ostream<_CharT, _Traits>& __os,
2625	const year_month_weekday& __ymwd)
2626	{
2627	// As above, just write straight to a stringstream, as if by
2628	// "{}/{:L}/{:L}"
2629	basic_stringstream<_CharT> __os2;
2630	__os2.imbue(__os.getloc());
2631	_CharT __slash;
2632	if constexpr (is_same_v<_CharT, char>)
2633	__slash = `'/'`;
2634	else
2635	__slash = L`'/'`;
2636	__os2 << __ymwd.year() << __slash << __ymwd.month() << __slash
2637	<< __ymwd.weekday_indexed();
2638	__os << __os2.view();
2639	return __os;
2640	}
2641
2642	template<typename _CharT, typename _Traits>
2643	inline basic_ostream<_CharT, _Traits>&
2644	operator<<(basic_ostream<_CharT, _Traits>& __os,
2645	const year_month_weekday_last& __ymwdl)
2646	{
2647	// As above, just write straight to a stringstream, as if by
2648	// "{}/{:L}/{:L}"
2649	basic_stringstream<_CharT> __os2;
2650	__os2.imbue(__os.getloc());
2651	_CharT __slash;
2652	if constexpr (is_same_v<_CharT, char>)
2653	__slash = `'/'`;
2654	else
2655	__slash = L`'/'`;
2656	__os2 << __ymwdl.year() << __slash << __ymwdl.month() << __slash
2657	<< __ymwdl.weekday_last();
2658	__os << __os2.view();
2659	return __os;
2660	}
2661
2662	template<typename _CharT, typename _Traits, typename _Duration>
2663	inline basic_ostream<_CharT, _Traits>&
2664	operator<<(basic_ostream<_CharT, _Traits>& __os,
2665	const hh_mm_ss<_Duration>& __hms)
2666	{
2667	return __os << format(__os.getloc(), _GLIBCXX_WIDEN("{:L%T}"), __hms);
2668	}
2669
2670	#if _GLIBCXX_USE_CXX11_ABI \|\| ! _GLIBCXX_USE_DUAL_ABI
2671	/// Writes a sys_info object to an ostream in an unspecified format.
2672	template<typename _CharT, typename _Traits>
2673	basic_ostream<_CharT, _Traits>&
2674	operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_info& __i)
2675	{
2676	__os << `'['` << __i.begin << `','` << __i.end
2677	<< `','` << hh_mm_ss(__i.offset) << `','` << __i.save
2678	<< `','` << __i.abbrev << `']'`;
2679	return __os;
2680	}
2681
2682	/// Writes a local_info object to an ostream in an unspecified format.
2683	template<typename _CharT, typename _Traits>
2684	basic_ostream<_CharT, _Traits>&
2685	operator<<(basic_ostream<_CharT, _Traits>& __os, const local_info& __li)
2686	{
2687	__os << `'['`;
2688	if (__li.result == local_info::unique)
2689	__os << __li.first;
2690	else
2691	{
2692	if (__li.result == local_info::nonexistent)
2693	__os << "nonexistent";
2694	else
2695	__os << "ambiguous";
2696	__os << " local time between " << __li.first;
2697	__os << " and " << __li.second;
2698	}
2699	__os << `']'`;
2700	return __os;
2701	}
2702
2703	template<typename _CharT, typename _Traits, typename _Duration,
2704	typename _TimeZonePtr>
2705	inline basic_ostream<_CharT, _Traits>&
2706	operator<<(basic_ostream<_CharT, _Traits>& __os,
2707	const zoned_time<_Duration, _TimeZonePtr>& __t)
2708	{
2709	__os << format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T %Z}"), __t);
2710	return __os;
2711	}
2712	#endif
2713
2714	template<typename _CharT, typename _Traits, typename _Duration>
2715	requires (!treat_as_floating_point_v<typename _Duration::rep>)
2716	&& ratio_less_v<typename _Duration::period, days::period>
2717	inline basic_ostream<_CharT, _Traits>&
2718	operator<<(basic_ostream<_CharT, _Traits>& __os,
2719	const sys_time<_Duration>& __tp)
2720	{
2721	__os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __tp);
2722	return __os;
2723	}
2724
2725	template<typename _CharT, typename _Traits>
2726	inline basic_ostream<_CharT, _Traits>&
2727	operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_days& __dp)
2728	{
2729	__os << year_month_day {__dp};
2730	return __os;
2731	}
2732
2733	template<typename _CharT, typename _Traits, typename _Duration,
2734	typename _Alloc = allocator<_CharT>>
2735	basic_istream<_CharT, _Traits>&
2736	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2737	sys_time<_Duration>& __tp,
2738	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2739	minutes* __offset = nullptr)
2740	{
2741	minutes __off{};
2742	if (!__offset)
2743	__offset = &__off;
2744	using __format::_ChronoParts;
2745	auto __need = _ChronoParts::_Year \| _ChronoParts::_Month
2746	\| _ChronoParts::_Day \| _ChronoParts::_TimeOfDay;
2747	__detail::_Parser_t<_Duration> __p(__need);
2748	if (__p(__is, __fmt, __abbrev, __offset))
2749	{
2750	if (__p._M_is_leap_second)
2751	__is.setstate(ios_base::failbit);
2752	else
2753	{
2754	auto __st = __p._M_sys_days + __p._M_time - *__offset;
2755	__tp = chrono::time_point_cast<_Duration>(__st);
2756	}
2757	}
2758	return __is;
2759	}
2760
2761	template<typename _CharT, typename _Traits, typename _Duration>
2762	inline basic_ostream<_CharT, _Traits>&
2763	operator<<(basic_ostream<_CharT, _Traits>& __os,
2764	const utc_time<_Duration>& __t)
2765	{
2766	__os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __t);
2767	return __os;
2768	}
2769
2770	template<typename _CharT, typename _Traits, typename _Duration,
2771	typename _Alloc = allocator<_CharT>>
2772	inline basic_istream<_CharT, _Traits>&
2773	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2774	utc_time<_Duration>& __tp,
2775	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2776	minutes* __offset = nullptr)
2777	{
2778	minutes __off{};
2779	if (!__offset)
2780	__offset = &__off;
2781	using __format::_ChronoParts;
2782	auto __need = _ChronoParts::_Year \| _ChronoParts::_Month
2783	\| _ChronoParts::_Day \| _ChronoParts::_TimeOfDay;
2784	__detail::_Parser_t<_Duration> __p(__need);
2785	if (__p(__is, __fmt, __abbrev, __offset))
2786	{
2787	// Converting to utc_time before adding _M_time is necessary for
2788	// "23:59:60" to correctly produce a time within a leap second.
2789	auto __ut = utc_clock::from_sys(__p._M_sys_days) + __p._M_time
2790	- *__offset;
2791	__tp = chrono::time_point_cast<_Duration>(__ut);
2792	}
2793	return __is;
2794	}
2795
2796	template<typename _CharT, typename _Traits, typename _Duration>
2797	inline basic_ostream<_CharT, _Traits>&
2798	operator<<(basic_ostream<_CharT, _Traits>& __os,
2799	const tai_time<_Duration>& __t)
2800	{
2801	__os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __t);
2802	return __os;
2803	}
2804
2805	template<typename _CharT, typename _Traits, typename _Duration,
2806	typename _Alloc = allocator<_CharT>>
2807	inline basic_istream<_CharT, _Traits>&
2808	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2809	tai_time<_Duration>& __tp,
2810	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2811	minutes* __offset = nullptr)
2812	{
2813	minutes __off{};
2814	if (!__offset)
2815	__offset = &__off;
2816	using __format::_ChronoParts;
2817	auto __need = _ChronoParts::_Year \| _ChronoParts::_Month
2818	\| _ChronoParts::_Day \| _ChronoParts::_TimeOfDay;
2819	__detail::_Parser_t<_Duration> __p(__need);
2820	if (__p(__is, __fmt, __abbrev, __offset))
2821	{
2822	if (__p._M_is_leap_second)
2823	__is.setstate(ios_base::failbit);
2824	else
2825	{
2826	auto __st = __p._M_sys_days + __p._M_time - *__offset;
2827	auto __tt = tai_clock::from_utc(utc_clock::from_sys(__st));
2828	__tp = chrono::time_point_cast<_Duration>(__tt);
2829	}
2830	}
2831	return __is;
2832	}
2833
2834	template<typename _CharT, typename _Traits, typename _Duration>
2835	inline basic_ostream<_CharT, _Traits>&
2836	operator<<(basic_ostream<_CharT, _Traits>& __os,
2837	const gps_time<_Duration>& __t)
2838	{
2839	__os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __t);
2840	return __os;
2841	}
2842
2843	template<typename _CharT, typename _Traits, typename _Duration,
2844	typename _Alloc = allocator<_CharT>>
2845	inline basic_istream<_CharT, _Traits>&
2846	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2847	gps_time<_Duration>& __tp,
2848	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2849	minutes* __offset = nullptr)
2850	{
2851	minutes __off{};
2852	if (!__offset)
2853	__offset = &__off;
2854	using __format::_ChronoParts;
2855	auto __need = _ChronoParts::_Year \| _ChronoParts::_Month
2856	\| _ChronoParts::_Day \| _ChronoParts::_TimeOfDay;
2857	__detail::_Parser_t<_Duration> __p(__need);
2858	if (__p(__is, __fmt, __abbrev, __offset))
2859	{
2860	if (__p._M_is_leap_second)
2861	__is.setstate(ios_base::failbit);
2862	else
2863	{
2864	auto __st = __p._M_sys_days + __p._M_time - *__offset;
2865	auto __tt = gps_clock::from_utc(utc_clock::from_sys(__st));
2866	__tp = chrono::time_point_cast<_Duration>(__tt);
2867	}
2868	}
2869	return __is;
2870	}
2871
2872	template<typename _CharT, typename _Traits, typename _Duration>
2873	inline basic_ostream<_CharT, _Traits>&
2874	operator<<(basic_ostream<_CharT, _Traits>& __os,
2875	const file_time<_Duration>& __t)
2876	{
2877	__os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __t);
2878	return __os;
2879	}
2880
2881	template<typename _CharT, typename _Traits, typename _Duration,
2882	typename _Alloc = allocator<_CharT>>
2883	inline basic_istream<_CharT, _Traits>&
2884	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2885	file_time<_Duration>& __tp,
2886	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2887	minutes* __offset = nullptr)
2888	{
2889	sys_time<_Duration> __st;
2890	if (chrono::from_stream(__is, __fmt, __st, __abbrev, __offset))
2891	__tp = chrono::time_point_cast<_Duration>(file_clock::from_sys(__st));
2892	return __is;
2893	}
2894
2895	template<typename _CharT, typename _Traits, typename _Duration>
2896	inline basic_ostream<_CharT, _Traits>&
2897	operator<<(basic_ostream<_CharT, _Traits>& __os,
2898	const local_time<_Duration>& __lt)
2899	{
2900	__os << sys_time<_Duration>{__lt.time_since_epoch()};
2901	return __os;
2902	}
2903
2904	template<typename _CharT, typename _Traits, typename _Duration,
2905	typename _Alloc = allocator<_CharT>>
2906	basic_istream<_CharT, _Traits>&
2907	from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2908	local_time<_Duration>& __tp,
2909	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2910	minutes* __offset = nullptr)
2911	{
2912	using __format::_ChronoParts;
2913	auto __need = _ChronoParts::_Year \| _ChronoParts::_Month
2914	\| _ChronoParts::_Day \| _ChronoParts::_TimeOfDay;
2915	__detail::_Parser_t<_Duration> __p(__need);
2916	if (__p(__is, __fmt, __abbrev, __offset))
2917	{
2918	days __d = __p._M_sys_days.time_since_epoch();
2919	auto __t = local_days (__d) + __p._M_time; // ignore offset
2920	__tp = chrono::time_point_cast<_Duration>(__t);
2921	}
2922	return __is;
2923	}
2924
2925	// [time.parse] parsing
2926
2927	namespace __detail
2928	{
2929	template<typename _Parsable, typename _CharT,
2930	typename _Traits = std::char_traits<_CharT>,
2931	typename... _OptArgs>
2932	concept __parsable = requires (basic_istream<_CharT, _Traits>& __is,
2933	const _CharT* __fmt, _Parsable& __tp,
2934	_OptArgs*... __args)
2935	{ from_stream(__is, __fmt, __tp, __args...); };
2936
2937	template<typename _Parsable, typename _CharT,
2938	typename _Traits = char_traits<_CharT>,
2939	typename _Alloc = allocator<_CharT>>
2940	struct _Parse
2941	{
2942	private:
2943	using __string_type = basic_string<_CharT, _Traits, _Alloc>;
2944
2945	public:
2946	_Parse(const _CharT* __fmt, _Parsable& __tp,
2947	basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2948	minutes* __offset = nullptr)
2949	: _M_fmt(__fmt), _M_tp(std::__addressof(__tp)),
2950	_M_abbrev(__abbrev), _M_offset(__offset)
2951	{ }
2952
2953	_Parse(_Parse&&) = delete;
2954	_Parse& operator=(_Parse&&) = delete;
2955
2956	private:
2957	using __stream_type = basic_istream<_CharT, _Traits>;
2958
2959	const _CharT* const _M_fmt;
2960	_Parsable* const _M_tp;
2961	__string_type* const _M_abbrev;
2962	minutes* const _M_offset;
2963
2964	friend __stream_type&
2965	operator>>(__stream_type& __is, _Parse&& __p)
2966	{
2967	if (__p._M_offset)
2968	from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev,
2969	__p._M_offset);
2970	else if (__p._M_abbrev)
2971	from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev);
2972	else
2973	from_stream(__is, __p._M_fmt, *__p._M_tp);
2974	return __is;
2975	}
2976
2977	friend void operator>>(__stream_type&, _Parse&) = delete;
2978	friend void operator>>(__stream_type&, const _Parse&) = delete;
2979	};
2980	} // namespace __detail
2981
2982	template<typename _CharT, __detail::__parsable<_CharT> _Parsable>
2983	[[nodiscard, __gnu__::__access__(__read_only__, `1`)]]
2984	inline auto
2985	parse(const _CharT* __fmt, _Parsable& __tp)
2986	{ return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp); }
2987
2988	template<typename _CharT, typename _Traits, typename _Alloc,
2989	__detail::__parsable<_CharT, _Traits> _Parsable>
2990	[[nodiscard]]
2991	inline auto
2992	parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp)
2993	{
2994	return __detail::_Parse<_Parsable, _CharT, _Traits>(__fmt.c_str(), __tp);
2995	}
2996
2997	template<typename _CharT, typename _Traits, typename _Alloc,
2998	typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
2999	__detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
3000	[[nodiscard, __gnu__::__access__(__read_only__, `1`)]]
3001	inline auto
3002	parse(const _CharT* __fmt, _Parsable& __tp,
3003	basic_string<_CharT, _Traits, _Alloc>& __abbrev)
3004	{
3005	auto __pa = std::__addressof(__abbrev);
3006	return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
3007	__pa);
3008	}
3009
3010	template<typename _CharT, typename _Traits, typename _Alloc,
3011	typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3012	__detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
3013	[[nodiscard]]
3014	inline auto
3015	parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3016	basic_string<_CharT, _Traits, _Alloc>& __abbrev)
3017	{
3018	auto __pa = std::__addressof(__abbrev);
3019	return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3020	__tp, __pa);
3021	}
3022
3023	template<typename _CharT, typename _Traits = char_traits<_CharT>,
3024	typename _StrT = basic_string<_CharT, _Traits>,
3025	__detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3026	[[nodiscard, __gnu__::__access__(__read_only__, `1`)]]
3027	inline auto
3028	parse(const _CharT* __fmt, _Parsable& __tp, minutes& __offset)
3029	{
3030	return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp, nullptr,
3031	&__offset);
3032	}
3033
3034	template<typename _CharT, typename _Traits, typename _Alloc,
3035	typename _StrT = basic_string<_CharT, _Traits>,
3036	__detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3037	[[nodiscard]]
3038	inline auto
3039	parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3040	minutes& __offset)
3041	{
3042	return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3043	__tp, nullptr,
3044	&__offset);
3045	}
3046
3047	template<typename _CharT, typename _Traits, typename _Alloc,
3048	typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3049	__detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3050	[[nodiscard, __gnu__::__access__(__read_only__, `1`)]]
3051	inline auto
3052	parse(const _CharT* __fmt, _Parsable& __tp,
3053	basic_string<_CharT, _Traits, _Alloc>& __abbrev, minutes& __offset)
3054	{
3055	auto __pa = std::__addressof(__abbrev);
3056	return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
3057	__pa,
3058	&__offset);
3059	}
3060
3061	template<typename _CharT, typename _Traits, typename _Alloc,
3062	typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3063	__detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3064	[[nodiscard]]
3065	inline auto
3066	parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3067	basic_string<_CharT, _Traits, _Alloc>& __abbrev, minutes& __offset)
3068	{
3069	auto __pa = std::__addressof(__abbrev);
3070	return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3071	__tp, __pa,
3072	&__offset);
3073	}
3074
3075	/// @cond undocumented
3076	template<typename _Duration>
3077	template<typename _CharT, typename _Traits, typename _Alloc>
3078	basic_istream<_CharT, _Traits>&
3079	__detail::_Parser<_Duration>::
3080	operator()(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
3081	basic_string<_CharT, _Traits, _Alloc>* __abbrev,
3082	minutes* __offset)
3083	{
3084	using sentry = typename basic_istream<_CharT, _Traits>::sentry;
3085	ios_base::iostate __err = ios_base::goodbit;
3086	if (sentry __cerb(__is, true); __cerb)
3087	{
3088	locale __loc = __is.getloc();
3089	auto& __tmget = std::use_facet<std::time_get<_CharT>>(__loc);
3090	auto& __tmpunct = std::use_facet<std::__timepunct<_CharT>>(__loc);
3091
3092	// RAII type to save and restore stream state.
3093	struct _Stream_state
3094	{
3095	explicit
3096	_Stream_state(basic_istream<_CharT, _Traits>& __i)
3097	: _M_is(__i),
3098	_M_flags(__i.flags(ios_base::skipws \| ios_base::dec)),
3099	_M_w(__i.width(`0`))
3100	{ }
3101
3102	~_Stream_state()
3103	{
3104	_M_is.flags(_M_flags);
3105	_M_is.width(_M_w);
3106	}
3107
3108	_Stream_state(_Stream_state&&) = delete;
3109
3110	basic_istream<_CharT, _Traits>& _M_is;
3111	ios_base::fmtflags _M_flags;
3112	streamsize _M_w;
3113	};
3114
3115	auto __is_failed = [](ios_base::iostate __e) {
3116	return static_cast<bool>(__e & ios_base::failbit);
3117	};
3118
3119	// Read an unsigned integer from the stream and return it.
3120	// Extract no more than __n digits. Set __err on error.
3121	auto __read_unsigned = [&] (int __n) {
3122	return _S_read_unsigned(__is, __err, __n);
3123	};
3124
3125	// Read a signed integer from the stream and return it.
3126	// Extract no more than __n digits. Set __err on error.
3127	auto __read_signed = [&] (int __n) {
3128	return _S_read_signed(__is, __err, __n);
3129	};
3130
3131	// Read an expected character from the stream.
3132	auto __read_chr = [&__is, &__err] (_CharT __c) {
3133	return _S_read_chr(__is, __err, __c);
3134	};
3135
3136	using __format::_ChronoParts;
3137	_ChronoParts __parts{};
3138
3139	const year __bad_y = --year::min(); // SHRT_MIN
3140	const month __bad_mon(`255`);
3141	const day __bad_day(`255`);
3142	const weekday __bad_wday(`255`);
3143	const hours __bad_h(-`1`);
3144	const minutes __bad_min(-`9999`);
3145	const seconds __bad_sec(-`1`);
3146
3147	year __y = __bad_y, __yy = __bad_y; // %Y, %yy
3148	year __iso_y = __bad_y, __iso_yy = __bad_y; // %G, %g
3149	month __m = __bad_mon; // %m
3150	day __d = __bad_day; // %d
3151	weekday __wday = __bad_wday; // %a %A %u %w
3152	hours __h = __bad_h, __h12 = __bad_h; // %H, %I
3153	minutes __min = __bad_min; // %M
3154	_Duration __s = __bad_sec; // %S
3155	int __ampm = `0`; // %p
3156	int __iso_wk = -`1`, __sunday_wk = -`1`, __monday_wk = -`1`; // %V, %U, %W
3157	int __century = -`1`; // %C
3158	int __dayofyear = -`1`; // %j (for non-duration)
3159
3160	minutes __tz_offset = __bad_min;
3161	basic_string<_CharT, _Traits> __tz_abbr;
3162
3163	if ((_M_need & _ChronoParts::_TimeOfDay)
3164	&& (_M_need & _ChronoParts::_Year))
3165	{
3166	// For time_points assume "00:00:00" is implicitly present,
3167	// so we don't fail to parse if it's not (PR libstdc++/114240).
3168	// We will still fail to parse if there's no year+month+day.
3169	__h = hours (`0`);
3170	__parts = _ChronoParts::_TimeOfDay;
3171	}
3172
3173	// bool __is_neg = false; // TODO: how is this handled for parsing?
3174
3175	_CharT __mod{}; // One of 'E' or 'O' or nul.
3176	unsigned __num = `0`; // Non-zero for N modifier.
3177	bool __is_flag = false; // True if we're processing a % flag.
3178
3179	constexpr bool __is_floating
3180	= treat_as_floating_point_v<typename _Duration::rep>;
3181
3182	// If an out-of-range value is extracted (e.g. 61min for %M),
3183	// do not set failbit immediately because we might not need it
3184	// (e.g. parsing chrono::year doesn't care about invalid %M values).
3185	// Instead set the variable back to its initial 'bad' state,
3186	// and also set related variables corresponding to the same field
3187	// (e.g. a bad %M value for __min should also reset __h and __s).
3188	// If a valid value is needed later the bad value will cause failure.
3189
3190	// For some fields we don't know the correct range when parsing and
3191	// we have to be liberal in what we accept, e.g. we allow 366 for
3192	// day-of-year because that's valid in leap years, and we allow 31
3193	// for day-of-month. If those values are needed to determine the
3194	// result then we can do a correct range check at the end when we
3195	// know the how many days the relevant year or month actually has.
3196
3197	while (*__fmt)
3198	{
3199	_CharT __c = *__fmt++;
3200	if (!__is_flag)
3201	{
3202	if (__c == `'%'`)
3203	__is_flag = true; // This is the start of a flag.
3204	else if (std::isspace(__c, __loc))
3205	std::ws(__is); // Match zero or more whitespace characters.
3206	else if (!__read_chr(__c)) [[unlikely]]
3207	break; // Failed to match the expected character.
3208
3209	continue; // Process next character in the format string.
3210	}
3211
3212	// Now processing a flag.
3213	switch (__c)
3214	{
3215	case `'a'`: // Locale's weekday name
3216	case `'A'`: // (full or abbreviated, matched case-insensitively).
3217	if (__mod \|\| __num) [[unlikely]]
3218	__err = ios_base::failbit;
3219	else
3220	{
3221	struct tm __tm{};
3222	__tmget.get(__is, {}, __is, __err, &__tm,
3223	__fmt - `2`, __fmt);
3224	if (!__is_failed(__err))
3225	__wday = weekday (__tm.tm_wday);
3226	}
3227	__parts \|= _ChronoParts::_Weekday;
3228	break;
3229
3230	case `'b'`: // Locale's month name
3231	case `'h'`: // (full or abbreviated, matched case-insensitively).
3232	case `'B'`:
3233	if (__mod \|\| __num) [[unlikely]]
3234	__err = ios_base::failbit;
3235	else
3236	{
3237	// strptime behaves differently for %b and %B,
3238	// but chrono::parse says they're equivalent.
3239	// Luckily libstdc++ std::time_get works as needed.
3240	struct tm __tm{};
3241	__tmget.get(__is, {}, __is, __err, &__tm,
3242	__fmt - `2`, __fmt);
3243	if (!__is_failed(__err))
3244	__m = month (__tm.tm_mon + `1`);
3245	}
3246	__parts \|= _ChronoParts::_Month;
3247	break;
3248
3249	case `'c'`: // Locale's date and time representation.
3250	if (__mod == `'O'` \|\| __num) [[unlikely]]
3251	__err \|= ios_base::failbit;
3252	else
3253	{
3254	struct tm __tm{};
3255	__tmget.get(__is, {}, __is, __err, &__tm,
3256	__fmt - `2` - (__mod == `'E'`), __fmt);
3257	if (!__is_failed(__err))
3258	{
3259	__y = year (__tm.tm_year + `1900`);
3260	__m = month (__tm.tm_mon + `1`);
3261	__d = day (__tm.tm_mday);
3262	__h = hours (__tm.tm_hour);
3263	__min = minutes (__tm.tm_min);
3264	__s = seconds (__tm.tm_sec);
3265	}
3266	}
3267	__parts \|= _ChronoParts::_DateTime;
3268	break;
3269
3270	case `'C'`: // Century
3271	if (!__mod) [[likely]]
3272	{
3273	auto __v = __read_signed(__num ? __num : `2`);
3274	if (!__is_failed(__err))
3275	{
3276	int __cmin = (int)year::min() / `100`;
3277	int __cmax = (int)year::max() / `100`;
3278	if (__cmin <= __v && __v <= __cmax)
3279	__century = __v * `100`;
3280	else
3281	__century = -`2`; // This prevents guessing century.
3282	}
3283	}
3284	else if (__mod == `'E'`)
3285	{
3286	struct tm __tm{};
3287	__tmget.get(__is, {}, __is, __err, &__tm,
3288	__fmt - `3`, __fmt);
3289	if (!__is_failed(__err))
3290	__century = __tm.tm_year;
3291	}
3292	else [[unlikely]]
3293	__err \|= ios_base::failbit;
3294	// N.B. don't set this here: __parts \|= _ChronoParts::_Year;
3295	break;
3296
3297	case `'d'`: // Day of month (1-31)
3298	case `'e'`:
3299	if (!__mod) [[likely]]
3300	{
3301	auto __v = __read_unsigned(__num ? __num : `2`);
3302	if (!__is_failed(__err))
3303	__d = day(__v);
3304	}
3305	else if (__mod == `'O'`)
3306	{
3307	struct tm __tm{};
3308	__tmget.get(__is, {}, __is, __err, &__tm,
3309	__fmt - `3`, __fmt);
3310	if (!__is_failed(__err))
3311	__d = day (__tm.tm_mday);
3312	}
3313	else [[unlikely]]
3314	__err \|= ios_base::failbit;
3315	__parts \|= _ChronoParts::_Day;
3316	break;
3317
3318	case `'D'`: // %m/%d/%y
3319	if (__mod \|\| __num) [[unlikely]]
3320	__err \|= ios_base::failbit;
3321	else
3322	{
3323	auto __month = __read_unsigned(`2`); // %m
3324	__read_chr(`'/'`);
3325	auto __day = __read_unsigned(`2`); // %d
3326	__read_chr(`'/'`);
3327	auto __year = __read_unsigned(`2`); // %y
3328	if (__is_failed(__err))
3329	break;
3330	__y = year(__year + `1900` + `100` * int(__year < `69`));
3331	__m = month(__month);
3332	__d = day(__day);
3333	if (!year_month_day (__y, __m, __d).ok())
3334	{
3335	__y = __yy = __iso_y = __iso_yy = __bad_y;
3336	__m = __bad_mon;
3337	__d = __bad_day;
3338	break;
3339	}
3340	}
3341	__parts \|= _ChronoParts::_Date;
3342	break;
3343
3344	case `'F'`: // %Y-%m-%d - any N modifier only applies to %Y.
3345	if (__mod) [[unlikely]]
3346	__err \|= ios_base::failbit;
3347	else
3348	{
3349	auto __year = __read_signed(__num ? __num : `4`); // %Y
3350	__read_chr(`'-'`);
3351	auto __month = __read_unsigned(`2`); // %m
3352	__read_chr(`'-'`);
3353	auto __day = __read_unsigned(`2`); // %d
3354	if (__is_failed(__err))
3355	break;
3356	__y = year(__year);
3357	__m = month(__month);
3358	__d = day(__day);
3359	if (!year_month_day (__y, __m, __d).ok())
3360	{
3361	__y = __yy = __iso_y = __iso_yy = __bad_y;
3362	__m = __bad_mon;
3363	__d = __bad_day;
3364	break;
3365	}
3366	}
3367	__parts \|= _ChronoParts::_Date;
3368	break;
3369
3370	case `'g'`: // Last two digits of ISO week-based year.
3371	if (__mod) [[unlikely]]
3372	__err \|= ios_base::failbit;
3373	else
3374	{
3375	auto __val = __read_unsigned(__num ? __num : `2`);
3376	if (__val >= `0` && __val <= `99`)
3377	{
3378	__iso_yy = year(__val);
3379	if (__century == -`1`) // No %C has been parsed yet.
3380	__century = `2000`;
3381	}
3382	else
3383	__iso_yy = __iso_y = __y = __yy = __bad_y;
3384	}
3385	__parts \|= _ChronoParts::_Year;
3386	break;
3387
3388	case `'G'`: // ISO week-based year.
3389	if (__mod) [[unlikely]]
3390	__err \|= ios_base::failbit;
3391	else
3392	__iso_y = year(__read_unsigned(__num ? __num : `4`));
3393	__parts \|= _ChronoParts::_Year;
3394	break;
3395
3396	case `'H'`: // 24-hour (00-23)
3397	case `'I'`: // 12-hour (1-12)
3398	if (__mod == `'E'`) [[unlikely]]
3399	__err \|= ios_base::failbit;
3400	else if (__mod == `'O'`)
3401	{
3402	#if 0
3403	struct tm __tm{};
3404	__tm.tm_ampm = `1`;
3405	__tmget.get(__is, {}, __is, __err, &__tm,
3406	__fmt - `3`, __fmt);
3407	if (!__is_failed(__err))
3408	{
3409	if (__c == `'I'`)
3410	{
3411	__h12 = hours(__tm.tm_hour);
3412	__h = __bad_h;
3413	}
3414	else
3415	__h = hours(__tm.tm_hour);
3416	}
3417	#else
3418	// XXX %OI seems to be unimplementable.
3419	__err \|= ios_base::failbit;
3420	#endif
3421	}
3422	else
3423	{
3424	auto __val = __read_unsigned(__num ? __num : `2`);
3425	if (__c == `'I'` && __val >= `1` && __val <= `12`)
3426	{
3427	__h12 = hours(__val);
3428	__h = __bad_h;
3429	}
3430	else if (__c == `'H'` && __val >= `0` && __val <= `23`)
3431	{
3432	__h = hours(__val);
3433	__h12 = __bad_h;
3434	}
3435	else
3436	{
3437	if (_M_need & _ChronoParts::_TimeOfDay)
3438	__err \|= ios_base::failbit;
3439	break;
3440	}
3441	}
3442	__parts \|= _ChronoParts::_TimeOfDay;
3443	break;
3444
3445	case `'j'`: // For duration, count of days, otherwise day of year
3446	if (__mod) [[unlikely]]
3447	__err \|= ios_base::failbit;
3448	else if (_M_need == _ChronoParts::_TimeOfDay) // duration
3449	{
3450	auto __val = __read_signed(__num ? __num : `3`);
3451	if (!__is_failed(__err))
3452	{
3453	__h = days(__val); // __h will get added to _M_time
3454	__parts \|= _ChronoParts::_TimeOfDay;
3455	}
3456	}
3457	else
3458	{
3459	__dayofyear = __read_unsigned(__num ? __num : `3`);
3460	// N.B. do not alter __parts here, done after loop.
3461	// No need for range checking here either.
3462	}
3463	break;
3464
3465	case `'m'`: // Month (1-12)
3466	if (__mod == `'E'`) [[unlikely]]
3467	__err \|= ios_base::failbit;
3468	else if (__mod == `'O'`)
3469	{
3470	struct tm __tm{};
3471	__tmget.get(__is, {}, __is, __err, &__tm,
3472	__fmt - `2`, __fmt);
3473	if (!__is_failed(__err))
3474	__m = month (__tm.tm_mon + `1`);
3475	}
3476	else
3477	{
3478	auto __val = __read_unsigned(__num ? __num : `2`);
3479	if (__val >= `1` && __val <= `12`)
3480	__m = month(__val);
3481	else
3482	__m = __bad_mon;
3483	}
3484	__parts \|= _ChronoParts::_Month;
3485	break;
3486
3487	case `'M'`: // Minutes
3488	if (__mod == `'E'`) [[unlikely]]
3489	__err \|= ios_base::failbit;
3490	else if (__mod == `'O'`)
3491	{
3492	struct tm __tm{};
3493	__tmget.get(__is, {}, __is, __err, &__tm,
3494	__fmt - `2`, __fmt);
3495	if (!__is_failed(__err))
3496	__min = minutes (__tm.tm_min);
3497	}
3498	else
3499	{
3500	auto __val = __read_unsigned(__num ? __num : `2`);
3501	if (`0` <= __val && __val < `60`)
3502	__min = minutes(__val);
3503	else
3504	{
3505	if (_M_need & _ChronoParts::_TimeOfDay)
3506	__err \|= ios_base::failbit;
3507	break;
3508	}
3509	}
3510	__parts \|= _ChronoParts::_TimeOfDay;
3511	break;
3512
3513	case `'p'`: // Locale's AM/PM designation for 12-hour clock.
3514	if (__mod \|\| __num)
3515	__err \|= ios_base::failbit;
3516	else
3517	{
3518	// Can't use std::time_get here as it can't parse %p
3519	// in isolation without %I. This might be faster anyway.
3520	const _CharT* __ampms[`2`];
3521	__tmpunct._M_am_pm(__ampms);
3522	int __n = `0`, __which = `3`;
3523	while (__which != `0`)
3524	{
3525	auto __i = __is.peek();
3526	if (_Traits::eq_int_type(__i, _Traits::eof()))
3527	{
3528	__err \|= ios_base::eofbit \| ios_base::failbit;
3529	break;
3530	}
3531	__i = std::toupper(_Traits::to_char_type(__i), __loc);
3532	if (__which & `1`)
3533	{
3534	if (__i != std::toupper(__ampms[`0`][__n], __loc))
3535	__which ^= `1`;
3536	else if (__ampms[`0`][__n + `1`] == _CharT())
3537	{
3538	__which = `1`;
3539	(void) __is.get();
3540	break;
3541	}
3542	}
3543	if (__which & `2`)
3544	{
3545	if (__i != std::toupper(__ampms[`1`][__n], __loc))
3546	__which ^= `2`;
3547	else if (__ampms[`1`][__n + `1`] == _CharT())
3548	{
3549	__which = `2`;
3550	(void) __is.get();
3551	break;
3552	}
3553	}
3554	if (__which)
3555	(void) __is.get();
3556	++__n;
3557	}
3558	if (__which == `0` \|\| __which == `3`)
3559	__err \|= ios_base::failbit;
3560	else
3561	__ampm = __which;
3562	}
3563	break;
3564
3565	case `'r'`: // Locale's 12-hour time.
3566	if (__mod \|\| __num)
3567	__err \|= ios_base::failbit;
3568	else
3569	{
3570	struct tm __tm{};
3571	__tmget.get(__is, {}, __is, __err, &__tm,
3572	__fmt - `2`, __fmt);
3573	if (!__is_failed(__err))
3574	{
3575	__h = hours (__tm.tm_hour);
3576	__min = minutes (__tm.tm_min);
3577	__s = seconds (__tm.tm_sec);
3578	}
3579	}
3580	__parts \|= _ChronoParts::_TimeOfDay;
3581	break;
3582
3583	case `'R'`: // %H:%M
3584	case `'T'`: // %H:%M:%S
3585	if (__mod \|\| __num) [[unlikely]]
3586	{
3587	__err \|= ios_base::failbit;
3588	break;
3589	}
3590	else
3591	{
3592	auto __val = __read_unsigned(`2`);
3593	if (__val == -`1` \|\| __val > `23`) [[unlikely]]
3594	{
3595	if (_M_need & _ChronoParts::_TimeOfDay)
3596	__err \|= ios_base::failbit;
3597	break;
3598	}
3599	if (!__read_chr(`':'`)) [[unlikely]]
3600	break;
3601	__h = hours(__val);
3602
3603	__val = __read_unsigned(`2`);
3604	if (__val == -`1` \|\| __val > `60`) [[unlikely]]
3605	{
3606	if (_M_need & _ChronoParts::_TimeOfDay)
3607	__err \|= ios_base::failbit;
3608	break;
3609	}
3610	__min = minutes(__val);
3611
3612	if (__c == `'R'`)
3613	{
3614	__parts \|= _ChronoParts::_TimeOfDay;
3615	break;
3616	}
3617	else if (!__read_chr(`':'`)) [[unlikely]]
3618	break;
3619	}
3620	[[fallthrough]];
3621
3622	case `'S'`: // Seconds
3623	if (__mod == `'E'`) [[unlikely]]
3624	__err \|= ios_base::failbit;
3625	else if (__mod == `'O'`)
3626	{
3627	struct tm __tm{};
3628	__tmget.get(__is, {}, __is, __err, &__tm,
3629	__fmt - `3`, __fmt);
3630	if (!__is_failed(__err))
3631	__s = seconds (__tm.tm_sec);
3632	}
3633	else if constexpr (_Duration::period::den == `1`
3634	&& !__is_floating)
3635	{
3636	auto __val = __read_unsigned(__num ? __num : `2`);
3637	if (`0` <= __val && __val <= `59`) [[likely]]
3638	__s = seconds(__val);
3639	else
3640	{
3641	if (_M_need & _ChronoParts::_TimeOfDay)
3642	__err \|= ios_base::failbit;
3643	break;
3644	}
3645	}
3646	else // Read fractional seconds
3647	{
3648	basic_stringstream<_CharT> __buf;
3649	auto __digit = _S_try_read_digit(__is, __err);
3650	if (__digit != -`1`)
3651	{
3652	__buf.put(_CharT(`'0'`) + __digit);
3653	__digit = _S_try_read_digit(__is, __err);
3654	if (__digit != -`1`)
3655	__buf.put(_CharT(`'0'`) + __digit);
3656	}
3657
3658	auto __i = __is.peek();
3659	if (_Traits::eq_int_type(__i, _Traits::eof()))
3660	__err \|= ios_base::eofbit;
3661	else
3662	{
3663	_CharT __dp = `'.'`;
3664	if (__loc != locale::classic())
3665	{
3666	auto& __np = use_facet<numpunct<_CharT>>(__loc);
3667	__dp = __np.decimal_point();
3668	}
3669	_CharT __c = _Traits::to_char_type(__i);
3670	if (__c == __dp)
3671	{
3672	(void) __is.get();
3673	__buf.put(`'.'`);
3674	int __prec
3675	= hh_mm_ss<_Duration>::fractional_width;
3676	do
3677	{
3678	__digit = _S_try_read_digit(__is, __err);
3679	if (__digit != -`1`)
3680	__buf.put(_CharT(`'0'`) + __digit);
3681	else
3682	break;
3683	}
3684	while (--__prec);
3685	}
3686	}
3687
3688	if (!__is_failed(__err)) [[likely]]
3689	{
3690	long double __val{};
3691	#if __cpp_lib_to_chars
3692	string __str = std::move(__buf).str();
3693	auto __first = __str.data();
3694	auto __last = __first + __str.size();
3695	using enum chars_format;
3696	auto [ptr, ec] = std::from_chars(__first, __last,
3697	value&: __val, fmt: fixed);
3698	if ((bool)ec \|\| ptr != __last) [[unlikely]]
3699	__err \|= ios_base::failbit;
3700	else
3701	#else
3702	if (__buf >> __val)
3703	#endif
3704	{
3705	duration<long double> __fs(__val);
3706	if constexpr (__is_floating)
3707	__s = __fs;
3708	else
3709	__s = chrono::round<_Duration>(__fs);
3710	}
3711	}
3712	}
3713	__parts \|= _ChronoParts::_TimeOfDay;
3714	break;
3715
3716	case `'u'`: // ISO weekday (1-7)
3717	case `'w'`: // Weekday (0-6)
3718	if (__mod == `'E'`) [[unlikely]]
3719	__err \|= ios_base::failbit;
3720	else if (__mod == `'O'`)
3721	{
3722	if (__c == `'w'`)
3723	{
3724	struct tm __tm{};
3725	__tmget.get(__is, {}, __is, __err, &__tm,
3726	__fmt - `3`, __fmt);
3727	if (!__is_failed(__err))
3728	__wday = weekday (__tm.tm_wday);
3729	}
3730	else
3731	__err \|= ios_base::failbit;
3732	}
3733	else
3734	{
3735	const int __lo = __c == `'u'` ? `1` : `0`;
3736	const int __hi = __lo + `6`;
3737	auto __val = __read_unsigned(__num ? __num : `1`);
3738	if (__lo <= __val && __val <= __hi)
3739	__wday = weekday(__val);
3740	else
3741	{
3742	__wday = __bad_wday;
3743	break;
3744	}
3745	}
3746	__parts \|= _ChronoParts::_Weekday;
3747	break;
3748
3749	case `'U'`: // Week number of the year (from first Sunday).
3750	case `'V'`: // ISO week-based week number.
3751	case `'W'`: // Week number of the year (from first Monday).
3752	if (__mod == `'E'`) [[unlikely]]
3753	__err \|= ios_base::failbit;
3754	else if (__mod == `'O'`)
3755	{
3756	if (__c == `'V'`) [[unlikely]]
3757	__err \|= ios_base::failbit;
3758	else
3759	{
3760	// TODO nl_langinfo_l(ALT_DIGITS) ?
3761	// Not implementable using std::time_get.
3762	}
3763	}
3764	else
3765	{
3766	const int __lo = __c == `'V'` ? `1` : `0`;
3767	const int __hi = `53`;
3768	auto __val = __read_unsigned(__num ? __num : `2`);
3769	if (__lo <= __val && __val <= __hi)
3770	{
3771	switch (__c)
3772	{
3773	case `'U'`:
3774	__sunday_wk = __val;
3775	break;
3776	case `'V'`:
3777	__iso_wk = __val;
3778	break;
3779	case `'W'`:
3780	__monday_wk = __val;
3781	break;
3782	}
3783	}
3784	else
3785	__iso_wk = __sunday_wk = __monday_wk = -`1`;
3786	}
3787	// N.B. do not alter __parts here, done after loop.
3788	break;
3789
3790	case `'x'`: // Locale's date representation.
3791	if (__mod == `'O'` \|\| __num) [[unlikely]]
3792	__err \|= ios_base::failbit;
3793	else
3794	{
3795	struct tm __tm{};
3796	__tmget.get(__is, {}, __is, __err, &__tm,
3797	__fmt - `2` - (__mod == `'E'`), __fmt);
3798	if (!__is_failed(__err))
3799	{
3800	__y = year (__tm.tm_year + `1900`);
3801	__m = month (__tm.tm_mon + `1`);
3802	__d = day (__tm.tm_mday);
3803	}
3804	}
3805	__parts \|= _ChronoParts::_Date;
3806	break;
3807
3808	case `'X'`: // Locale's time representation.
3809	if (__mod == `'O'` \|\| __num) [[unlikely]]
3810	__err \|= ios_base::failbit;
3811	else
3812	{
3813	struct tm __tm{};
3814	__tmget.get(__is, {}, __is, __err, &__tm,
3815	__fmt - `2` - (__mod == `'E'`), __fmt);
3816	if (!__is_failed(__err))
3817	{
3818	__h = hours (__tm.tm_hour);
3819	__min = minutes (__tm.tm_min);
3820	__s = seconds (__tm.tm_sec);
3821	}
3822	}
3823	__parts \|= _ChronoParts::_TimeOfDay;
3824	break;
3825
3826	case `'y'`: // Last two digits of year.
3827	if (__mod) [[unlikely]]
3828	{
3829	struct tm __tm{};
3830	__tmget.get(__is, {}, __is, __err, &__tm,
3831	__fmt - `3`, __fmt);
3832	if (!__is_failed(__err))
3833	{
3834	int __cent = __tm.tm_year < `2000` ? `1900` : `2000`;
3835	__yy = year (__tm.tm_year - __cent);
3836	if (__century == -`1`) // No %C has been parsed yet.
3837	__century = __cent;
3838	}
3839	}
3840	else
3841	{
3842	auto __val = __read_unsigned(__num ? __num : `2`);
3843	if (__val >= `0` && __val <= `99`)
3844	{
3845	__yy = year(__val);
3846	if (__century == -`1`) // No %C has been parsed yet.
3847	__century = __val < `69` ? `2000` : `1900`;
3848	}
3849	else
3850	__y = __yy = __iso_yy = __iso_y = __bad_y;
3851	}
3852	__parts \|= _ChronoParts::_Year;
3853	break;
3854
3855	case `'Y'`: // Year
3856	if (__mod == `'O'`) [[unlikely]]
3857	__err \|= ios_base::failbit;
3858	else if (__mod == `'E'`)
3859	{
3860	struct tm __tm{};
3861	__tmget.get(__is, {}, __is, __err, &__tm,
3862	__fmt - `3`, __fmt);
3863	if (!__is_failed(__err))
3864	__y = year (__tm.tm_year);
3865	}
3866	else
3867	{
3868	auto __val = __read_unsigned(__num ? __num : `4`);
3869	if (!__is_failed(__err))
3870	__y = year(__val);
3871	}
3872	__parts \|= _ChronoParts::_Year;
3873	break;
3874
3875	case `'z'`:
3876	if (__num) [[unlikely]]
3877	__err \|= ios_base::failbit;
3878	else
3879	{
3880	// For %Ez and %Oz read [+\|-][h]h[:mm].
3881	// For %z read [+\|-]hh[mm].
3882
3883	auto __i = __is.peek();
3884	if (_Traits::eq_int_type(__i, _Traits::eof()))
3885	{
3886	__err \|= ios_base::eofbit \| ios_base::failbit;
3887	break;
3888	}
3889	_CharT __ic = _Traits::to_char_type(__i);
3890	const bool __neg = __ic == _CharT(`'-'`);
3891	if (__ic == _CharT(`'-'`) \|\| __ic == _CharT(`'+'`))
3892	(void) __is.get();
3893
3894	int_least32_t __hh;
3895	if (__mod)
3896	{
3897	// Read h[h]
3898	__hh = __read_unsigned(`2`);
3899	}
3900	else
3901	{
3902	// Read hh
3903	__hh = `10` * _S_try_read_digit(__is, __err);
3904	__hh += _S_try_read_digit(__is, __err);
3905	}
3906
3907	if (__is_failed(__err))
3908	break;
3909
3910	__i = __is.peek();
3911	if (_Traits::eq_int_type(__i, _Traits::eof()))
3912	{
3913	__err \|= ios_base::eofbit;
3914	__tz_offset = minutes(__hh * (__neg ? -`60` : `60`));
3915	break;
3916	}
3917	__ic = _Traits::to_char_type(__i);
3918
3919	bool __read_mm = false;
3920	if (__mod)
3921	{
3922	if (__ic == _GLIBCXX_WIDEN(":")[`0`])
3923	{
3924	// Read [:mm] part.
3925	(void) __is.get();
3926	__read_mm = true;
3927	}
3928	}
3929	else if (_CharT(`'0'`) <= __ic && __ic <= _CharT(`'9'`))
3930	{
3931	// Read [mm] part.
3932	__read_mm = true;
3933	}
3934
3935	int_least32_t __mm = `0`;
3936	if (__read_mm)
3937	{
3938	__mm = `10` * _S_try_read_digit(__is, __err);
3939	__mm += _S_try_read_digit(__is, __err);
3940	}
3941
3942	if (!__is_failed(__err))
3943	{
3944	auto __z = __hh * `60` + __mm;
3945	__tz_offset = minutes(__neg ? -__z : __z);
3946	}
3947	}
3948	break;
3949
3950	case `'Z'`:
3951	if (__mod \|\| __num) [[unlikely]]
3952	__err \|= ios_base::failbit;
3953	else
3954	{
3955	basic_string_view<_CharT> __x = _GLIBCXX_WIDEN("_/-+");
3956	__tz_abbr.clear();
3957	while (true)
3958	{
3959	auto __i = __is.peek();
3960	if (!_Traits::eq_int_type(__i, _Traits::eof()))
3961	{
3962	_CharT __a = _Traits::to_char_type(__i);
3963	if (std::isalnum(__a, __loc)
3964	\|\| __x.find(__a) != __x.npos)
3965	{
3966	__tz_abbr.push_back(__a);
3967	(void) __is.get();
3968	continue;
3969	}
3970	}
3971	else
3972	__err \|= ios_base::eofbit;
3973	break;
3974	}
3975	if (__tz_abbr.empty())
3976	__err \|= ios_base::failbit;
3977	}
3978	break;
3979
3980	case `'n'`: // Exactly one whitespace character.
3981	if (__mod \|\| __num) [[unlikely]]
3982	__err \|= ios_base::failbit;
3983	else
3984	{
3985	_CharT __i = __is.peek();
3986	if (_Traits::eq_int_type(__i, _Traits::eof()))
3987	__err \|= ios_base::eofbit \| ios_base::failbit;
3988	else if (std::isspace(_Traits::to_char_type(__i), __loc))
3989	(void) __is.get();
3990	else
3991	__err \|= ios_base::failbit;
3992	}
3993	break;
3994
3995	case `'t'`: // Zero or one whitespace characters.
3996	if (__mod \|\| __num) [[unlikely]]
3997	__err \|= ios_base::failbit;
3998	else
3999	{
4000	_CharT __i = __is.peek();
4001	if (_Traits::eq_int_type(__i, _Traits::eof()))
4002	__err \|= ios_base::eofbit;
4003	else if (std::isspace(_Traits::to_char_type(__i), __loc))
4004	(void) __is.get();
4005	}
4006	break;
4007
4008	case `'%'`: // A % character.
4009	if (__mod \|\| __num) [[unlikely]]
4010	__err \|= ios_base::failbit;
4011	else
4012	__read_chr(`'%'`);
4013	break;
4014
4015	case `'O'`: // Modifiers
4016	case `'E'`:
4017	if (__mod \|\| __num) [[unlikely]]
4018	{
4019	__err \|= ios_base::failbit;
4020	break;
4021	}
4022	__mod = __c;
4023	continue;
4024
4025	default:
4026	if (_CharT(`'1'`) <= __c && __c <= _CharT(`'9'`))
4027	{
4028	if (!__mod) [[likely]]
4029	{
4030	// %Nx - extract positive decimal integer N
4031	auto __end = __fmt + _Traits::length(__fmt);
4032	auto [__v, __ptr]
4033	= __format::__parse_integer(__fmt - `1`, __end);
4034	if (__ptr) [[likely]]
4035	{
4036	__num = __v;
4037	__fmt = __ptr;
4038	continue;
4039	}
4040	}
4041	}
4042	__err \|= ios_base::failbit;
4043	}
4044
4045	if (__is_failed(__err)) [[unlikely]]
4046	break;
4047
4048	__is_flag = false;
4049	__num = `0`;
4050	__mod = _CharT();
4051	}
4052
4053	if (__century >= `0`)
4054	{
4055	if (__yy != __bad_y && __y == __bad_y)
4056	__y = years (__century) + __yy; // Use %y instead of %Y
4057	if (__iso_yy != __bad_y && __iso_y == __bad_y)
4058	__iso_y = years (__century) + __iso_yy; // Use %g instead of %G
4059	}
4060
4061	bool __can_use_doy = false;
4062	bool __can_use_iso_wk = false;
4063	bool __can_use_sun_wk = false;
4064	bool __can_use_mon_wk = false;
4065
4066	// A year + day-of-year can be converted to a full date.
4067	if (__y != __bad_y && __dayofyear >= `0`)
4068	{
4069	__can_use_doy = true;
4070	__parts \|= _ChronoParts::_Date;
4071	}
4072	else if (__y != __bad_y && __wday != __bad_wday && __sunday_wk >= `0`)
4073	{
4074	__can_use_sun_wk = true;
4075	__parts \|= _ChronoParts::_Date;
4076	}
4077	else if (__y != __bad_y && __wday != __bad_wday && __monday_wk >= `0`)
4078	{
4079	__can_use_mon_wk = true;
4080	__parts \|= _ChronoParts::_Date;
4081	}
4082	else if (__iso_y != __bad_y && __wday != __bad_wday && __iso_wk > `0`)
4083	{
4084	// An ISO week date can be converted to a full date.
4085	__can_use_iso_wk = true;
4086	__parts \|= _ChronoParts::_Date;
4087	}
4088
4089	if (__is_failed(__err)) [[unlikely]]
4090	; // Don't bother doing any more work.
4091	else if (__is_flag) [[unlikely]] // incomplete format flag
4092	__err \|= ios_base::failbit;
4093	else if ((_M_need & __parts) == _M_need) [[likely]]
4094	{
4095	// We try to avoid calculating _M_sys_days and _M_ymd unless
4096	// necessary, because converting sys_days to year_month_day
4097	// (or vice versa) requires non-trivial calculations.
4098	// If we have y/m/d values then use them to populate _M_ymd
4099	// and only convert it to _M_sys_days if the caller needs that.
4100	// But if we don't have y/m/d and need to calculate the date
4101	// from the day-of-year or a week+weekday then we set _M_sys_days
4102	// and only convert it to _M_ymd if the caller needs that.
4103
4104	// We do more error checking here, but only for the fields that
4105	// we actually need to use. For example, we will not diagnose
4106	// an invalid dayofyear==366 for non-leap years unless actually
4107	// using __dayofyear. This should mean we never produce invalid
4108	// results, but it means not all invalid inputs are diagnosed,
4109	// e.g. "2023-01-01 366" >> "%F %j" ignores the invalid 366.
4110	// We also do not diagnose inconsistent values for the same
4111	// field, e.g. "2021 2022 2023" >> "%C%y %Y %Y" just uses 2023.
4112
4113	// Whether the caller wants _M_wd.
4114	// The _Weekday bit is only set for chrono::weekday.
4115	const bool __need_wday = _M_need & _ChronoParts::_Weekday;
4116
4117	// Whether the caller wants _M_sys_days and _M_time.
4118	// Only true for durations and time_points.
4119	const bool __need_time = _M_need & _ChronoParts::_TimeOfDay;
4120
4121	if (__need_wday && __wday != __bad_wday)
4122	_M_wd = __wday; // Caller only wants a weekday and we have one.
4123	else if (_M_need & _ChronoParts::_Date) // subsumes __need_wday
4124	{
4125	// Whether the caller wants _M_ymd.
4126	// True for chrono::year etc., false for time_points.
4127	const bool __need_ymd = !__need_wday && !__need_time;
4128
4129	if ((_M_need & _ChronoParts::_Year && __y == __bad_y)
4130	\|\| (_M_need & _ChronoParts::_Month && __m == __bad_mon)
4131	\|\| (_M_need & _ChronoParts::_Day && __d == __bad_day))
4132	{
4133	// Missing at least one of y/m/d so calculate sys_days
4134	// from the other data we have available.
4135
4136	if (__can_use_doy)
4137	{
4138	if ((`0` < __dayofyear && __dayofyear <= `365`)
4139	\|\| (__dayofyear == `366` && __y.is_leap()))
4140	[[likely]]
4141	{
4142	_M_sys_days = sys_days(__y /January /`1`)
4143	+ days (__dayofyear - `1`);
4144	if (__need_ymd)
4145	_M_ymd = year_month_day(_M_sys_days);
4146	}
4147	else
4148	__err \|= ios_base::failbit;
4149	}
4150	else if (__can_use_iso_wk)
4151	{
4152	// Calculate y/m/d from ISO week date.
4153
4154	if (__iso_wk == `53`)
4155	{
4156	// A year has 53 weeks iff Jan 1st is a Thursday
4157	// or Jan 1 is a Wednesday and it's a leap year.
4158	const sys_days __jan4(__iso_y /January /`4`);
4159	weekday __wd1(__jan4 - days (`3`));
4160	if (__wd1 != Thursday)
4161	if (__wd1 != Wednesday \|\| !__iso_y.is_leap())
4162	__err \|= ios_base::failbit;
4163	}
4164
4165	if (!__is_failed(__err)) [[likely]]
4166	{
4167	// First Thursday is always in week one:
4168	sys_days __w(Thursday [`1`]/January /__iso_y);
4169	// First day of week-based year:
4170	__w -= Thursday - Monday;
4171	__w += days (weeks (__iso_wk - `1`));
4172	__w += __wday - Monday;
4173	_M_sys_days = __w;
4174
4175	if (__need_ymd)
4176	_M_ymd = year_month_day(_M_sys_days);
4177	}
4178	}
4179	else if (__can_use_sun_wk)
4180	{
4181	// Calculate y/m/d from week number + weekday.
4182	sys_days __wk1(__y /January /Sunday [`1`]);
4183	_M_sys_days = __wk1 + weeks (__sunday_wk - `1`)
4184	+ days (__wday.c_encoding());
4185	_M_ymd = year_month_day(_M_sys_days);
4186	if (_M_ymd.year() != __y) [[unlikely]]
4187	__err \|= ios_base::failbit;
4188	}
4189	else if (__can_use_mon_wk)
4190	{
4191	// Calculate y/m/d from week number + weekday.
4192	sys_days __wk1(__y /January /Monday [`1`]);
4193	_M_sys_days = __wk1 + weeks (__monday_wk - `1`)
4194	+ days (__wday.c_encoding() - `1`);
4195	_M_ymd = year_month_day(_M_sys_days);
4196	if (_M_ymd.year() != __y) [[unlikely]]
4197	__err \|= ios_base::failbit;
4198	}
4199	else // Should not be able to get here.
4200	__err \|= ios_base::failbit;
4201	}
4202	else
4203	{
4204	// We know that all fields the caller needs are present,
4205	// but check that their values are in range.
4206	// Make unwanted fields valid so that _M_ymd.ok() is true.
4207
4208	if (_M_need & _ChronoParts::_Year)
4209	{
4210	if (!__y.ok()) [[unlikely]]
4211	__err \|= ios_base::failbit;
4212	}
4213	else if (__y == __bad_y)
4214	__y = `1972y`; // Leap year so that Feb 29 is valid.
4215
4216	if (_M_need & _ChronoParts::_Month)
4217	{
4218	if (!__m.ok()) [[unlikely]]
4219	__err \|= ios_base::failbit;
4220	}
4221	else if (__m == __bad_mon)
4222	__m = January;
4223
4224	if (_M_need & _ChronoParts::_Day)
4225	{
4226	if (__d < day (`1`) \|\| __d > (__y /__m /last).day())
4227	__err \|= ios_base::failbit;
4228	}
4229	else if (__d == __bad_day)
4230	__d = `1d`;
4231
4232	if (year_month_day __ymd(__y, __m, __d); __ymd.ok())
4233	{
4234	_M_ymd = __ymd;
4235	if (__need_wday \|\| __need_time)
4236	_M_sys_days = sys_days(_M_ymd);
4237	}
4238	else [[unlikely]]
4239	__err \|= ios_base::failbit;
4240	}
4241
4242	if (__need_wday)
4243	_M_wd = weekday(_M_sys_days);
4244	}
4245
4246	// Need to set _M_time for both durations and time_points.
4247	if (__need_time)
4248	{
4249	if (__h == __bad_h && __h12 != __bad_h)
4250	{
4251	if (__ampm == `1`)
4252	__h = __h12 == hours (`12`) ? hours (`0`) : __h12;
4253	else if (__ampm == `2`)
4254	__h = __h12 == hours (`12`) ? __h12 : __h12 + hours (`12`);
4255	else [[unlikely]]
4256	__err \|= ios_base::failbit;
4257	}
4258
4259	auto __t = _M_time.zero();
4260	bool __ok = false;
4261
4262	if (__h != __bad_h)
4263	{
4264	__ok = true;
4265	__t += __h;
4266	}
4267
4268	if (__min != __bad_min)
4269	{
4270	__ok = true;
4271	__t += __min;
4272	}
4273
4274	if (__s != __bad_sec)
4275	{
4276	__ok = true;
4277	__t += __s;
4278	_M_is_leap_second = __s >= seconds (`60`);
4279	}
4280
4281	if (__ok)
4282	_M_time = __t;
4283	else
4284	__err \|= ios_base::failbit;
4285	}
4286
4287	if (!__is_failed(__err)) [[likely]]
4288	{
4289	if (__offset && __tz_offset != __bad_min)
4290	*__offset = __tz_offset;
4291	if (__abbrev && !__tz_abbr.empty())
4292	*__abbrev = std::move(__tz_abbr);
4293	}
4294	}
4295	else
4296	__err \|= ios_base::failbit;
4297	}
4298	if (__err)
4299	__is.setstate(__err);
4300	return __is;
4301	}
4302	/// @endcond
4303	#undef _GLIBCXX_WIDEN
4304
4305	/// @} group chrono
4306	} // namespace chrono
4307
4308	_GLIBCXX_END_NAMESPACE_VERSION
4309	} // namespace std
4310
4311	#endif // C++20
4312
4313	#endif //_GLIBCXX_CHRONO_IO_H
4314

Browse the source code of include/c++/14/bits/chrono_io.h