locale source code [ClickHouse/contrib/libcxx/include/locale]

1	// -- C++ --
2	//===-------------------------- locale ------------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP_LOCALE
11	#define _LIBCPP_LOCALE
12
13	/*
14	locale synopsis
15
16	namespace std
17	{
18
19	class locale
20	{
21	public:
22	// types:
23	class facet;
24	class id;
25
26	typedef int category;
27	static const category // values assigned here are for exposition only
28	none = 0x000,
29	collate = 0x010,
30	ctype = 0x020,
31	monetary = 0x040,
32	numeric = 0x080,
33	time = 0x100,
34	messages = 0x200,
35	all = collate \| ctype \| monetary \| numeric \| time \| messages;
36
37	// construct/copy/destroy:
38	locale() noexcept;
39	locale(const locale& other) noexcept;
40	explicit locale(const char std_name);*
41	explicit locale(const string& std_name);
42	locale(const locale& other, const char std_name, category);*
43	locale(const locale& other, const string& std_name, category);
44	template <class Facet> locale(const locale& other, Facet f);*
45	locale(const locale& other, const locale& one, category);
46
47	~locale(); // not virtual
48
49	const locale& operator=(const locale& other) noexcept;
50
51	template <class Facet> locale combine(const locale& other) const;
52
53	// locale operations:
54	basic_string<char> name() const;
55	bool operator==(const locale& other) const;
56	bool operator!=(const locale& other) const;
57	template <class charT, class Traits, class Allocator>
58	bool operator()(const basic_string<charT,Traits,Allocator>& s1,
59	const basic_string<charT,Traits,Allocator>& s2) const;
60
61	// global locale objects:
62	static locale global(const locale&);
63	static const locale& classic();
64	};
65
66	template <class Facet> const Facet& use_facet(const locale&);
67	template <class Facet> bool has_facet(const locale&) noexcept;
68
69	// 22.3.3, convenience interfaces:
70	template <class charT> bool isspace (charT c, const locale& loc);
71	template <class charT> bool isprint (charT c, const locale& loc);
72	template <class charT> bool iscntrl (charT c, const locale& loc);
73	template <class charT> bool isupper (charT c, const locale& loc);
74	template <class charT> bool islower (charT c, const locale& loc);
75	template <class charT> bool isalpha (charT c, const locale& loc);
76	template <class charT> bool isdigit (charT c, const locale& loc);
77	template <class charT> bool ispunct (charT c, const locale& loc);
78	template <class charT> bool isxdigit(charT c, const locale& loc);
79	template <class charT> bool isalnum (charT c, const locale& loc);
80	template <class charT> bool isgraph (charT c, const locale& loc);
81	template <class charT> charT toupper(charT c, const locale& loc);
82	template <class charT> charT tolower(charT c, const locale& loc);
83
84	template<class Codecvt, class Elem = wchar_t,
85	class Wide_alloc = allocator<Elem>,
86	class Byte_alloc = allocator<char>>
87	class wstring_convert
88	{
89	public:
90	typedef basic_string<char, char_traits<char>, Byte_alloc> byte_string;
91	typedef basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
92	typedef typename Codecvt::state_type state_type;
93	typedef typename wide_string::traits_type::int_type int_type;
94
95	explicit wstring_convert(Codecvt pcvt = new Codecvt); // explicit in C++14*
96	wstring_convert(Codecvt pcvt, state_type state);*
97	explicit wstring_convert(const byte_string& byte_err, // explicit in C++14
98	const wide_string& wide_err = wide_string());
99	wstring_convert(const wstring_convert&) = delete; // C++14
100	wstring_convert & operator=(const wstring_convert &) = delete; // C++14
101	~wstring_convert();
102
103	wide_string from_bytes(char byte);
104	wide_string from_bytes(const char ptr);*
105	wide_string from_bytes(const byte_string& str);
106	wide_string from_bytes(const char first, const char* last);*
107
108	byte_string to_bytes(Elem wchar);
109	byte_string to_bytes(const Elem wptr);*
110	byte_string to_bytes(const wide_string& wstr);
111	byte_string to_bytes(const Elem first, const Elem* last);*
112
113	size_t converted() const; // noexcept in C++14
114	state_type state() const;
115	};
116
117	template <class Codecvt, class Elem = wchar_t, class Tr = char_traits<Elem>>
118	class wbuffer_convert
119	: public basic_streambuf<Elem, Tr>
120	{
121	public:
122	typedef typename Tr::state_type state_type;
123
124	explicit wbuffer_convert(streambuf bytebuf = 0, Codecvt* pcvt = new Codecvt,*
125	state_type state = state_type()); // explicit in C++14
126	wbuffer_convert(const wbuffer_convert&) = delete; // C++14
127	wbuffer_convert & operator=(const wbuffer_convert &) = delete; // C++14
128	~wbuffer_convert(); // C++14
129
130	streambuf rdbuf() const;*
131	streambuf rdbuf(streambuf* bytebuf);*
132
133	state_type state() const;
134	};
135
136	// 22.4.1 and 22.4.1.3, ctype:
137	class ctype_base;
138	template <class charT> class ctype;
139	template <> class ctype<char>; // specialization
140	template <class charT> class ctype_byname;
141	template <> class ctype_byname<char>; // specialization
142
143	class codecvt_base;
144	template <class internT, class externT, class stateT> class codecvt;
145	template <class internT, class externT, class stateT> class codecvt_byname;
146
147	// 22.4.2 and 22.4.3, numeric:
148	template <class charT, class InputIterator> class num_get;
149	template <class charT, class OutputIterator> class num_put;
150	template <class charT> class numpunct;
151	template <class charT> class numpunct_byname;
152
153	// 22.4.4, col lation:
154	template <class charT> class collate;
155	template <class charT> class collate_byname;
156
157	// 22.4.5, date and time:
158	class time_base;
159	template <class charT, class InputIterator> class time_get;
160	template <class charT, class InputIterator> class time_get_byname;
161	template <class charT, class OutputIterator> class time_put;
162	template <class charT, class OutputIterator> class time_put_byname;
163
164	// 22.4.6, money:
165	class money_base;
166	template <class charT, class InputIterator> class money_get;
167	template <class charT, class OutputIterator> class money_put;
168	template <class charT, bool Intl> class moneypunct;
169	template <class charT, bool Intl> class moneypunct_byname;
170
171	// 22.4.7, message retrieval:
172	class messages_base;
173	template <class charT> class messages;
174	template <class charT> class messages_byname;
175
176	} // std
177
178	*/
179
180	#include <__config>
181	#include <__locale>
182	#include <__debug>
183	#include <algorithm>
184	#include <memory>
185	#include <ios>
186	#include <streambuf>
187	#include <iterator>
188	#include <limits>
189	#include <version>
190	#ifndef __APPLE__
191	#include <cstdarg>
192	#endif
193	#include <cstdlib>
194	#include <ctime>
195	#include <cstdio>
196	#ifdef _LIBCPP_HAS_CATOPEN
197	#include <nl_types.h>
198	#endif
199
200	#ifdef __APPLE__
201	#include <Availability.h>
202	#endif
203
204	#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
205	#include <__bsd_locale_defaults.h>
206	#else
207	#include <__bsd_locale_fallbacks.h>
208	#endif
209
210	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
211	#pragma GCC system_header
212	#endif
213
214	_LIBCPP_PUSH_MACROS
215	#include <__undef_macros>
216
217
218	_LIBCPP_BEGIN_NAMESPACE_STD
219
220	#if defined(__APPLE__) \|\| defined(__FreeBSD__)
221	# define _LIBCPP_GET_C_LOCALE 0
222	#elif defined(__CloudABI__) \|\| defined(__NetBSD__)
223	# define _LIBCPP_GET_C_LOCALE LC_C_LOCALE
224	#else
225	# define _LIBCPP_GET_C_LOCALE __cloc()
226	// Get the C locale object
227	_LIBCPP_FUNC_VIS locale_t __cloc();
228	#define __cloc_defined
229	#endif
230
231	// __scan_keyword
232	// Scans [__b, __e) until a match is found in the basic_strings range
233	// [__kb, __ke) or until it can be shown that there is no match in [__kb, __ke).
234	// __b will be incremented (visibly), consuming CharT until a match is found
235	// or proved to not exist. A keyword may be "", in which will match anything.
236	// If one keyword is a prefix of another, and the next CharT in the input
237	// might match another keyword, the algorithm will attempt to find the longest
238	// matching keyword. If the longer matching keyword ends up not matching, then
239	// no keyword match is found. If no keyword match is found, __ke is returned
240	// and failbit is set in __err.
241	// Else an iterator pointing to the matching keyword is found. If more than
242	// one keyword matches, an iterator to the first matching keyword is returned.
243	// If on exit __b == __e, eofbit is set in __err. If __case_sensitive is false,
244	// __ct is used to force to lower case before comparing characters.
245	// Examples:
246	// Keywords: "a", "abb"
247	// If the input is "a", the first keyword matches and eofbit is set.
248	// If the input is "abc", no match is found and "ab" are consumed.
249	template <class _InputIterator, class _ForwardIterator, class _Ctype>
250	_LIBCPP_HIDDEN
251	_ForwardIterator
252	__scan_keyword(_InputIterator& __b, _InputIterator __e,
253	_ForwardIterator __kb, _ForwardIterator __ke,
254	const _Ctype& __ct, ios_base::iostate& __err,
255	bool __case_sensitive = true)
256	{
257	typedef typename iterator_traits<_InputIterator>::value_type _CharT;
258	size_t __nkw = static_cast<size_t>(_VSTD::distance(__kb, __ke));
259	const unsigned char __doesnt_match = `'\0'`;
260	const unsigned char __might_match = `'\1'`;
261	const unsigned char __does_match = `'\2'`;
262	unsigned char __statbuf[`100`];
263	unsigned char* __status = __statbuf;
264	unique_ptr<unsigned char, void()(void**)> __stat_hold(`0`, free);
265	if (__nkw > sizeof(__statbuf))
266	{
267	__status = (unsigned char*)malloc(__nkw);
268	if (__status == `0`)
269	__throw_bad_alloc();
270	__stat_hold.reset(__status);
271	}
272	size_t __n_might_match = __nkw; // At this point, any keyword might match
273	size_t __n_does_match = `0`; // but none of them definitely do
274	// Initialize all statuses to __might_match, except for "" keywords are __does_match
275	unsigned char* __st = __status;
276	for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st)
277	{
278	if (!__ky->empty())
279	*__st = __might_match;
280	else
281	{
282	*__st = __does_match;
283	--__n_might_match;
284	++__n_does_match;
285	}
286	}
287	// While there might be a match, test keywords against the next CharT
288	for (size_t __indx = `0`; __b != __e && __n_might_match > `0`; ++__indx)
289	{
290	// Peek at the next CharT but don't consume it
291	_CharT __c = *__b;
292	if (!__case_sensitive)
293	__c = __ct.toupper(__c);
294	bool __consume = false;
295	// For each keyword which might match, see if the __indx character is __c
296	// If a match if found, consume __c
297	// If a match is found, and that is the last character in the keyword,
298	// then that keyword matches.
299	// If the keyword doesn't match this character, then change the keyword
300	// to doesn't match
301	__st = __status;
302	for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st)
303	{
304	if (*__st == __might_match)
305	{
306	_CharT __kc = (*__ky)[__indx];
307	if (!__case_sensitive)
308	__kc = __ct.toupper(__kc);
309	if (__c == __kc)
310	{
311	__consume = true;
312	if (__ky->size() == __indx+`1`)
313	{
314	*__st = __does_match;
315	--__n_might_match;
316	++__n_does_match;
317	}
318	}
319	else
320	{
321	*__st = __doesnt_match;
322	--__n_might_match;
323	}
324	}
325	}
326	// consume if we matched a character
327	if (__consume)
328	{
329	++__b;
330	// If we consumed a character and there might be a matched keyword that
331	// was marked matched on a previous iteration, then such keywords
332	// which are now marked as not matching.
333	if (__n_might_match + __n_does_match > `1`)
334	{
335	__st = __status;
336	for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st)
337	{
338	if (*__st == __does_match && __ky->size() != __indx+`1`)
339	{
340	*__st = __doesnt_match;
341	--__n_does_match;
342	}
343	}
344	}
345	}
346	}
347	// We've exited the loop because we hit eof and/or we have no more "might matches".
348	if (__b == __e)
349	__err \|= ios_base::eofbit;
350	// Return the first matching result
351	for (__st = __status; __kb != __ke; ++__kb, (void) ++__st)
352	if (*__st == __does_match)
353	break;
354	if (__kb == __ke)
355	__err \|= ios_base::failbit;
356	return __kb;
357	}
358
359	struct _LIBCPP_TYPE_VIS __num_get_base
360	{
361	static const int __num_get_buf_sz = `40`;
362
363	static int __get_base(ios_base&);
364	static const char __src[`33`];
365	};
366
367	_LIBCPP_FUNC_VIS
368	void __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end,
369	ios_base::iostate& __err);
370
371	template <class _CharT>
372	struct __num_get
373	: protected __num_get_base
374	{
375	static string __stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point,
376	_CharT& __thousands_sep);
377
378	static int __stage2_float_loop(_CharT __ct, bool& __in_units, char& __exp,
379	char* __a, char*& __a_end,
380	_CharT __decimal_point, _CharT __thousands_sep,
381	const string& __grouping, unsigned* __g,
382	unsigned& __g_end, unsigned& __dc, _CharT __atoms);
383	#ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
384	static string __stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep);
385	static int __stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
386	unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
387	unsigned* __g, unsigned& __g_end, _CharT __atoms);
388
389	#else
390	static string __stage2_int_prep(ios_base& __iob, _CharT& __thousands_sep)
391	{
392	locale __loc = __iob.getloc();
393	const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
394	__thousands_sep = __np.thousands_sep();
395	return __np.grouping();
396	}
397
398	const _CharT* __do_widen(ios_base& __iob, _CharT* __atoms) const
399	{
400	return __do_widen_p(__iob, __atoms);
401	}
402
403
404	static int __stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
405	unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
406	unsigned* __g, unsigned& __g_end, const* _CharT* __atoms);
407	private:
408	template<typename T>
409	const T* __do_widen_p(ios_base& __iob, T* __atoms) const
410	{
411	locale __loc = __iob.getloc();
412	use_facet<ctype<T> >(__loc).widen(__src, __src + `26`, __atoms);
413	return __atoms;
414	}
415
416	const char* __do_widen_p(ios_base& __iob, char* __atoms) const
417	{
418	(void)__iob;
419	(void)__atoms;
420	return __src;
421	}
422	#endif
423	};
424
425	#ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
426	template <class _CharT>
427	string
428	__num_get<_CharT>::__stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep)
429	{
430	locale __loc = __iob.getloc();
431	use_facet<ctype<_CharT> >(__loc).widen(__src, __src + `26`, __atoms);
432	const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
433	__thousands_sep = __np.thousands_sep();
434	return __np.grouping();
435	}
436	#endif
437
438	template <class _CharT>
439	string
440	__num_get<_CharT>::__stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point,
441	_CharT& __thousands_sep)
442	{
443	locale __loc = __iob.getloc();
444	use_facet<ctype<_CharT> >(__loc).widen(__src, __src + `32`, __atoms);
445	const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
446	__decimal_point = __np.decimal_point();
447	__thousands_sep = __np.thousands_sep();
448	return __np.grouping();
449	}
450
451	template <class _CharT>
452	int
453	#ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
454	__num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
455	unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
456	unsigned* __g, unsigned& __g_end, _CharT __atoms)
457	#else
458	__num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
459	unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
460	unsigned* __g, unsigned& __g_end, const* _CharT* __atoms)
461
462	#endif
463	{
464	if (__a_end == __a && (__ct == __atoms[`24`] \|\| __ct == __atoms[`25`]))
465	{
466	*__a_end++ = __ct == __atoms[`24`] ? `'+'` : `'-'`;
467	__dc = `0`;
468	return `0`;
469	}
470	if (__grouping.size() != `0` && __ct == __thousands_sep)
471	{
472	if (__g_end-__g < __num_get_buf_sz)
473	{
474	*__g_end++ = __dc;
475	__dc = `0`;
476	}
477	return `0`;
478	}
479	ptrdiff_t __f = find(__atoms, __atoms + `26`, __ct) - __atoms;
480	if (__f >= `24`)
481	return -`1`;
482	switch (__base)
483	{
484	case `8`:
485	case `10`:
486	if (__f >= __base)
487	return -`1`;
488	break;
489	case `16`:
490	if (__f < `22`)
491	break;
492	if (__a_end != __a && __a_end - __a <= `2` && __a_end[-`1`] == `'0'`)
493	{
494	__dc = `0`;
495	*__a_end++ = __src[__f];
496	return `0`;
497	}
498	return -`1`;
499	}
500	*__a_end++ = __src[__f];
501	++__dc;
502	return `0`;
503	}
504
505	template <class _CharT>
506	int
507	__num_get<_CharT>::__stage2_float_loop(_CharT __ct, bool& __in_units, char& __exp, char* __a, char*& __a_end,
508	_CharT __decimal_point, _CharT __thousands_sep, const string& __grouping,
509	unsigned* __g, unsigned& __g_end, unsigned& __dc, _CharT __atoms)
510	{
511	if (__ct == __decimal_point)
512	{
513	if (!__in_units)
514	return -`1`;
515	__in_units = false;
516	*__a_end++ = `'.'`;
517	if (__grouping.size() != `0` && __g_end-__g < __num_get_buf_sz)
518	*__g_end++ = __dc;
519	return `0`;
520	}
521	if (__ct == __thousands_sep && __grouping.size() != `0`)
522	{
523	if (!__in_units)
524	return -`1`;
525	if (__g_end-__g < __num_get_buf_sz)
526	{
527	*__g_end++ = __dc;
528	__dc = `0`;
529	}
530	return `0`;
531	}
532	ptrdiff_t __f = find(__atoms, __atoms + `32`, __ct) - __atoms;
533	if (__f >= `32`)
534	return -`1`;
535	char __x = __src[__f];
536	if (__x == `'-'` \|\| __x == `'+'`)
537	{
538	if (__a_end == __a \|\| (__a_end[-`1`] & `0x5F`) == (__exp & `0x7F`))
539	{
540	*__a_end++ = __x;
541	return `0`;
542	}
543	return -`1`;
544	}
545	if (__x == `'x'` \|\| __x == `'X'`)
546	__exp = `'P'`;
547	else if ((__x & `0x5F`) == __exp)
548	{
549	__exp \|= (char) `0x80`;
550	if (__in_units)
551	{
552	__in_units = false;
553	if (__grouping.size() != `0` && __g_end-__g < __num_get_buf_sz)
554	*__g_end++ = __dc;
555	}
556	}
557	*__a_end++ = __x;
558	if (__f >= `22`)
559	return `0`;
560	++__dc;
561	return `0`;
562	}
563
564	_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<char>)
565	_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<wchar_t>)
566
567	template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
568	class _LIBCPP_TEMPLATE_VIS num_get
569	: public locale::facet,
570	private __num_get<_CharT>
571	{
572	public:
573	typedef _CharT char_type;
574	typedef _InputIterator iter_type;
575
576	_LIBCPP_INLINE_VISIBILITY
577	explicit num_get(size_t __refs = `0`)
578	: locale::facet(__refs) {}
579
580	_LIBCPP_INLINE_VISIBILITY
581	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
582	ios_base::iostate& __err, bool& __v) const
583	{
584	return do_get(__b, __e, __iob, __err, __v);
585	}
586
587	_LIBCPP_INLINE_VISIBILITY
588	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
589	ios_base::iostate& __err, long& __v) const
590	{
591	return do_get(__b, __e, __iob, __err, __v);
592	}
593
594	_LIBCPP_INLINE_VISIBILITY
595	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
596	ios_base::iostate& __err, long long& __v) const
597	{
598	return do_get(__b, __e, __iob, __err, __v);
599	}
600
601	_LIBCPP_INLINE_VISIBILITY
602	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
603	ios_base::iostate& __err, unsigned short& __v) const
604	{
605	return do_get(__b, __e, __iob, __err, __v);
606	}
607
608	_LIBCPP_INLINE_VISIBILITY
609	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
610	ios_base::iostate& __err, unsigned int& __v) const
611	{
612	return do_get(__b, __e, __iob, __err, __v);
613	}
614
615	_LIBCPP_INLINE_VISIBILITY
616	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
617	ios_base::iostate& __err, unsigned long& __v) const
618	{
619	return do_get(__b, __e, __iob, __err, __v);
620	}
621
622	_LIBCPP_INLINE_VISIBILITY
623	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
624	ios_base::iostate& __err, unsigned long long& __v) const
625	{
626	return do_get(__b, __e, __iob, __err, __v);
627	}
628
629	_LIBCPP_INLINE_VISIBILITY
630	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
631	ios_base::iostate& __err, float& __v) const
632	{
633	return do_get(__b, __e, __iob, __err, __v);
634	}
635
636	_LIBCPP_INLINE_VISIBILITY
637	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
638	ios_base::iostate& __err, double& __v) const
639	{
640	return do_get(__b, __e, __iob, __err, __v);
641	}
642
643	_LIBCPP_INLINE_VISIBILITY
644	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
645	ios_base::iostate& __err, long double& __v) const
646	{
647	return do_get(__b, __e, __iob, __err, __v);
648	}
649
650	_LIBCPP_INLINE_VISIBILITY
651	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
652	ios_base::iostate& __err, void& __v) const*
653	{
654	return do_get(__b, __e, __iob, __err, __v);
655	}
656
657	static locale::id id;
658
659	protected:
660	_LIBCPP_INLINE_VISIBILITY
661	~num_get() {}
662
663	template <class _Fp>
664	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
665	iter_type __do_get_floating_point
666	(iter_type __b, iter_type __e, ios_base& __iob,
667	ios_base::iostate& __err, _Fp& __v) const;
668
669	template <class _Signed>
670	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
671	iter_type __do_get_signed
672	(iter_type __b, iter_type __e, ios_base& __iob,
673	ios_base::iostate& __err, _Signed& __v) const;
674
675	template <class _Unsigned>
676	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
677	iter_type __do_get_unsigned
678	(iter_type __b, iter_type __e, ios_base& __iob,
679	ios_base::iostate& __err, _Unsigned& __v) const;
680
681
682	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
683	ios_base::iostate& __err, bool& __v) const;
684
685	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
686	ios_base::iostate& __err, long& __v) const
687	{ return this->__do_get_signed ( __b, __e, __iob, __err, __v ); }
688
689	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
690	ios_base::iostate& __err, long long& __v) const
691	{ return this->__do_get_signed ( __b, __e, __iob, __err, __v ); }
692
693	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
694	ios_base::iostate& __err, unsigned short& __v) const
695	{ return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }
696
697	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
698	ios_base::iostate& __err, unsigned int& __v) const
699	{ return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }
700
701	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
702	ios_base::iostate& __err, unsigned long& __v) const
703	{ return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }
704
705	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
706	ios_base::iostate& __err, unsigned long long& __v) const
707	{ return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }
708
709	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
710	ios_base::iostate& __err, float& __v) const
711	{ return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); }
712
713	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
714	ios_base::iostate& __err, double& __v) const
715	{ return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); }
716
717	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
718	ios_base::iostate& __err, long double& __v) const
719	{ return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); }
720
721	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
722	ios_base::iostate& __err, void& __v) const*;
723	};
724
725	template <class _CharT, class _InputIterator>
726	locale::id
727	num_get<_CharT, _InputIterator>::id;
728
729	template <class _Tp>
730	_LIBCPP_HIDDEN _Tp
731	__num_get_signed_integral(const char* __a, const char* __a_end,
732	ios_base::iostate& __err, int __base)
733	{
734	if (__a != __a_end)
735	{
736	typename remove_reference<decltype(errno)>::type __save_errno = errno;
737	errno = `0`;
738	char *__p2;
739	long long __ll = strtoll_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
740	typename remove_reference<decltype(errno)>::type __current_errno = errno;
741	if (__current_errno == `0`)
742	errno = __save_errno;
743	if (__p2 != __a_end)
744	{
745	__err = ios_base::failbit;
746	return `0`;
747	}
748	else if (__current_errno == ERANGE \|\|
749	__ll < numeric_limits<_Tp>::min() \|\|
750	numeric_limits<_Tp>::max() < __ll)
751	{
752	__err = ios_base::failbit;
753	if (__ll > `0`)
754	return numeric_limits<_Tp>::max();
755	else
756	return numeric_limits<_Tp>::min();
757	}
758	return static_cast<_Tp>(__ll);
759	}
760	__err = ios_base::failbit;
761	return `0`;
762	}
763
764	template <class _Tp>
765	_LIBCPP_HIDDEN _Tp
766	__num_get_unsigned_integral(const char* __a, const char* __a_end,
767	ios_base::iostate& __err, int __base)
768	{
769	if (__a != __a_end)
770	{
771	const bool __negate = *__a == `'-'`;
772	if (__negate && ++__a == __a_end) {
773	__err = ios_base::failbit;
774	return `0`;
775	}
776	typename remove_reference<decltype(errno)>::type __save_errno = errno;
777	errno = `0`;
778	char *__p2;
779	unsigned long long __ll = strtoull_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
780	typename remove_reference<decltype(errno)>::type __current_errno = errno;
781	if (__current_errno == `0`)
782	errno = __save_errno;
783	if (__p2 != __a_end)
784	{
785	__err = ios_base::failbit;
786	return `0`;
787	}
788	else if (__current_errno == ERANGE \|\| numeric_limits<_Tp>::max() < __ll)
789	{
790	__err = ios_base::failbit;
791	return numeric_limits<_Tp>::max();
792	}
793	_Tp __res = static_cast<_Tp>(__ll);
794	if (__negate) __res = -__res;
795	return __res;
796	}
797	__err = ios_base::failbit;
798	return `0`;
799	}
800
801	template <class _Tp>
802	_LIBCPP_INLINE_VISIBILITY
803	_Tp __do_strtod(const char* __a, char** __p2);
804
805	template <>
806	inline _LIBCPP_INLINE_VISIBILITY
807	float __do_strtod<float>(const char* __a, char** __p2) {
808	return strtof_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
809	}
810
811	template <>
812	inline _LIBCPP_INLINE_VISIBILITY
813	double __do_strtod<double>(const char* __a, char** __p2) {
814	return strtod_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
815	}
816
817	template <>
818	inline _LIBCPP_INLINE_VISIBILITY
819	long double __do_strtod<long double>(const char* __a, char** __p2) {
820	return strtold_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
821	}
822
823	template <class _Tp>
824	_LIBCPP_HIDDEN
825	_Tp
826	__num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err)
827	{
828	if (__a != __a_end)
829	{
830	typename remove_reference<decltype(errno)>::type __save_errno = errno;
831	errno = `0`;
832	char *__p2;
833	_Tp __ld = __do_strtod<_Tp>(__a, &__p2);
834	typename remove_reference<decltype(errno)>::type __current_errno = errno;
835	if (__current_errno == `0`)
836	errno = __save_errno;
837	if (__p2 != __a_end)
838	{
839	__err = ios_base::failbit;
840	return `0`;
841	}
842	else if (__current_errno == ERANGE)
843	__err = ios_base::failbit;
844	return __ld;
845	}
846	__err = ios_base::failbit;
847	return `0`;
848	}
849
850	template <class _CharT, class _InputIterator>
851	_InputIterator
852	num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
853	ios_base& __iob,
854	ios_base::iostate& __err,
855	bool& __v) const
856	{
857	if ((__iob.flags() & ios_base::boolalpha) == `0`)
858	{
859	long __lv = -`1`;
860	__b = do_get(__b, __e, __iob, __err, __lv);
861	switch (__lv)
862	{
863	case `0`:
864	__v = false;
865	break;
866	case `1`:
867	__v = true;
868	break;
869	default:
870	__v = true;
871	__err = ios_base::failbit;
872	break;
873	}
874	return __b;
875	}
876	const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__iob.getloc());
877	const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__iob.getloc());
878	typedef typename numpunct<_CharT>::string_type string_type;
879	const string_type __names[`2`] = {__np.truename(), __np.falsename()};
880	const string_type* __i = __scan_keyword(__b, __e, __names, __names+`2`,
881	__ct, __err);
882	__v = __i == __names;
883	return __b;
884	}
885
886	// signed
887
888	template <class _CharT, class _InputIterator>
889	template <class _Signed>
890	_InputIterator
891	num_get<_CharT, _InputIterator>::__do_get_signed(iter_type __b, iter_type __e,
892	ios_base& __iob,
893	ios_base::iostate& __err,
894	_Signed& __v) const
895	{
896	// Stage 1
897	int __base = this->__get_base(__iob);
898	// Stage 2
899	char_type __thousands_sep;
900	const int __atoms_size = `26`;
901	#ifdef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
902	char_type __atoms1[__atoms_size];
903	const char_type __atoms = this*->__do_widen(__iob, __atoms1);
904	string __grouping = this->__stage2_int_prep(__iob, __thousands_sep);
905	#else
906	char_type __atoms[__atoms_size];
907	string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
908	#endif
909	string __buf;
910	__buf.resize(__buf.capacity());
911	char* __a = &__buf [`0`];
912	char* __a_end = __a;
913	unsigned __g[__num_get_base::__num_get_buf_sz];
914	unsigned* __g_end = __g;
915	unsigned __dc = `0`;
916	for (; __b != __e; ++__b)
917	{
918	if (__a_end == __a + __buf.size())
919	{
920	size_t __tmp = __buf.size();
921	__buf.resize(`2`*__buf.size());
922	__buf.resize(__buf.capacity());
923	__a = &__buf [`0`];
924	__a_end = __a + __tmp;
925	}
926	if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
927	__thousands_sep, __grouping, __g, __g_end,
928	__atoms))
929	break;
930	}
931	if (__grouping.size() != `0` && __g_end-__g < __num_get_base::__num_get_buf_sz)
932	*__g_end++ = __dc;
933	// Stage 3
934	__v = __num_get_signed_integral<_Signed>(__a, __a_end, __err, __base);
935	// Digit grouping checked
936	__check_grouping(__grouping, __g, __g_end, __err);
937	// EOF checked
938	if (__b == __e)
939	__err \|= ios_base::eofbit;
940	return __b;
941	}
942
943	// unsigned
944
945	template <class _CharT, class _InputIterator>
946	template <class _Unsigned>
947	_InputIterator
948	num_get<_CharT, _InputIterator>::__do_get_unsigned(iter_type __b, iter_type __e,
949	ios_base& __iob,
950	ios_base::iostate& __err,
951	_Unsigned& __v) const
952	{
953	// Stage 1
954	int __base = this->__get_base(__iob);
955	// Stage 2
956	char_type __thousands_sep;
957	const int __atoms_size = `26`;
958	#ifdef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
959	char_type __atoms1[__atoms_size];
960	const char_type __atoms = this*->__do_widen(__iob, __atoms1);
961	string __grouping = this->__stage2_int_prep(__iob, __thousands_sep);
962	#else
963	char_type __atoms[__atoms_size];
964	string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
965	#endif
966	string __buf;
967	__buf.resize(__buf.capacity());
968	char* __a = &__buf [`0`];
969	char* __a_end = __a;
970	unsigned __g[__num_get_base::__num_get_buf_sz];
971	unsigned* __g_end = __g;
972	unsigned __dc = `0`;
973	for (; __b != __e; ++__b)
974	{
975	if (__a_end == __a + __buf.size())
976	{
977	size_t __tmp = __buf.size();
978	__buf.resize(`2`*__buf.size());
979	__buf.resize(__buf.capacity());
980	__a = &__buf [`0`];
981	__a_end = __a + __tmp;
982	}
983	if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
984	__thousands_sep, __grouping, __g, __g_end,
985	__atoms))
986	break;
987	}
988	if (__grouping.size() != `0` && __g_end-__g < __num_get_base::__num_get_buf_sz)
989	*__g_end++ = __dc;
990	// Stage 3
991	__v = __num_get_unsigned_integral<_Unsigned>(__a, __a_end, __err, __base);
992	// Digit grouping checked
993	__check_grouping(__grouping, __g, __g_end, __err);
994	// EOF checked
995	if (__b == __e)
996	__err \|= ios_base::eofbit;
997	return __b;
998	}
999
1000	// floating point
1001
1002	template <class _CharT, class _InputIterator>
1003	template <class _Fp>
1004	_InputIterator
1005	num_get<_CharT, _InputIterator>::__do_get_floating_point(iter_type __b, iter_type __e,
1006	ios_base& __iob,
1007	ios_base::iostate& __err,
1008	_Fp& __v) const
1009	{
1010	// Stage 1, nothing to do
1011	// Stage 2
1012	char_type __atoms[`32`];
1013	char_type __decimal_point;
1014	char_type __thousands_sep;
1015	string __grouping = this->__stage2_float_prep(__iob, __atoms,
1016	__decimal_point,
1017	__thousands_sep);
1018	string __buf;
1019	__buf.resize(__buf.capacity());
1020	char* __a = &__buf [`0`];
1021	char* __a_end = __a;
1022	unsigned __g[__num_get_base::__num_get_buf_sz];
1023	unsigned* __g_end = __g;
1024	unsigned __dc = `0`;
1025	bool __in_units = true;
1026	char __exp = `'E'`;
1027	for (; __b != __e; ++__b)
1028	{
1029	if (__a_end == __a + __buf.size())
1030	{
1031	size_t __tmp = __buf.size();
1032	__buf.resize(`2`*__buf.size());
1033	__buf.resize(__buf.capacity());
1034	__a = &__buf [`0`];
1035	__a_end = __a + __tmp;
1036	}
1037	if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
1038	__decimal_point, __thousands_sep,
1039	__grouping, __g, __g_end,
1040	__dc, __atoms))
1041	break;
1042	}
1043	if (__grouping.size() != `0` && __in_units && __g_end-__g < __num_get_base::__num_get_buf_sz)
1044	*__g_end++ = __dc;
1045	// Stage 3
1046	__v = __num_get_float<_Fp>(__a, __a_end, __err);
1047	// Digit grouping checked
1048	__check_grouping(__grouping, __g, __g_end, __err);
1049	// EOF checked
1050	if (__b == __e)
1051	__err \|= ios_base::eofbit;
1052	return __b;
1053	}
1054
1055	template <class _CharT, class _InputIterator>
1056	_InputIterator
1057	num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
1058	ios_base& __iob,
1059	ios_base::iostate& __err,
1060	void& __v) const*
1061	{
1062	// Stage 1
1063	int __base = `16`;
1064	// Stage 2
1065	char_type __atoms[`26`];
1066	char_type __thousands_sep = `0`;
1067	string __grouping;
1068	use_facet<ctype<_CharT> >(__iob.getloc()).widen(__num_get_base::__src,
1069	__num_get_base::__src + `26`, __atoms);
1070	string __buf;
1071	__buf.resize(__buf.capacity());
1072	char* __a = &__buf [`0`];
1073	char* __a_end = __a;
1074	unsigned __g[__num_get_base::__num_get_buf_sz];
1075	unsigned* __g_end = __g;
1076	unsigned __dc = `0`;
1077	for (; __b != __e; ++__b)
1078	{
1079	if (__a_end == __a + __buf.size())
1080	{
1081	size_t __tmp = __buf.size();
1082	__buf.resize(`2`*__buf.size());
1083	__buf.resize(__buf.capacity());
1084	__a = &__buf [`0`];
1085	__a_end = __a + __tmp;
1086	}
1087	if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
1088	__thousands_sep, __grouping,
1089	__g, __g_end, __atoms))
1090	break;
1091	}
1092	// Stage 3
1093	__buf.resize(__a_end - __a);
1094	if (__libcpp_sscanf_l(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != `1`)
1095	__err = ios_base::failbit;
1096	// EOF checked
1097	if (__b == __e)
1098	__err \|= ios_base::eofbit;
1099	return __b;
1100	}
1101
1102	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<char>)
1103	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<wchar_t>)
1104
1105	struct _LIBCPP_TYPE_VIS __num_put_base
1106	{
1107	protected:
1108	static void __format_int(char* __fmt, const char* __len, bool __signd,
1109	ios_base::fmtflags __flags);
1110	static bool __format_float(char* __fmt, const char* __len,
1111	ios_base::fmtflags __flags);
1112	static char* __identify_padding(char* __nb, char* __ne,
1113	const ios_base& __iob);
1114	};
1115
1116	template <class _CharT>
1117	struct __num_put
1118	: protected __num_put_base
1119	{
1120	static void __widen_and_group_int(char* __nb, char* __np, char* __ne,
1121	_CharT* __ob, _CharT& __op, _CharT& __oe,
1122	const locale& __loc);
1123	static void __widen_and_group_float(char* __nb, char* __np, char* __ne,
1124	_CharT* __ob, _CharT& __op, _CharT& __oe,
1125	const locale& __loc);
1126	};
1127
1128	template <class _CharT>
1129	void
1130	__num_put<_CharT>::__widen_and_group_int(char* __nb, char* __np, char* __ne,
1131	_CharT* __ob, _CharT& __op, _CharT& __oe,
1132	const locale& __loc)
1133	{
1134	const ctype<_CharT>& __ct = use_facet<ctype<_CharT> > (__loc);
1135	const numpunct<_CharT>& __npt = use_facet<numpunct<_CharT> >(__loc);
1136	string __grouping = __npt.grouping();
1137	if (__grouping.empty())
1138	{
1139	__ct.widen(__nb, __ne, __ob);
1140	__oe = __ob + (__ne - __nb);
1141	}
1142	else
1143	{
1144	__oe = __ob;
1145	char* __nf = __nb;
1146	if (__nf == `'-'` \|\| __nf == `'+'`)
1147	__oe++ = __ct.widen(__nf++);
1148	if (__ne - __nf >= `2` && __nf[`0`] == `'0'` && (__nf[`1`] == `'x'` \|\|
1149	__nf[`1`] == `'X'`))
1150	{
1151	__oe++ = __ct.widen(__nf++);
1152	__oe++ = __ct.widen(__nf++);
1153	}
1154	reverse(__nf, __ne);
1155	_CharT __thousands_sep = __npt.thousands_sep();
1156	unsigned __dc = `0`;
1157	unsigned __dg = `0`;
1158	for (char* __p = __nf; __p < __ne; ++__p)
1159	{
1160	if (static_cast<unsigned>(__grouping [__dg]) > `0` &&
1161	__dc == static_cast<unsigned>(__grouping [__dg]))
1162	{
1163	*__oe++ = __thousands_sep;
1164	__dc = `0`;
1165	if (__dg < __grouping.size()-`1`)
1166	++__dg;
1167	}
1168	__oe++ = __ct.widen(__p);
1169	++__dc;
1170	}
1171	reverse(__ob + (__nf - __nb), __oe);
1172	}
1173	if (__np == __ne)
1174	__op = __oe;
1175	else
1176	__op = __ob + (__np - __nb);
1177	}
1178
1179	template <class _CharT>
1180	void
1181	__num_put<_CharT>::__widen_and_group_float(char* __nb, char* __np, char* __ne,
1182	_CharT* __ob, _CharT& __op, _CharT& __oe,
1183	const locale& __loc)
1184	{
1185	const ctype<_CharT>& __ct = use_facet<ctype<_CharT> > (__loc);
1186	const numpunct<_CharT>& __npt = use_facet<numpunct<_CharT> >(__loc);
1187	string __grouping = __npt.grouping();
1188	__oe = __ob;
1189	char* __nf = __nb;
1190	if (__nf == `'-'` \|\| __nf == `'+'`)
1191	__oe++ = __ct.widen(__nf++);
1192	char* __ns;
1193	if (__ne - __nf >= `2` && __nf[`0`] == `'0'` && (__nf[`1`] == `'x'` \|\|
1194	__nf[`1`] == `'X'`))
1195	{
1196	__oe++ = __ct.widen(__nf++);
1197	__oe++ = __ct.widen(__nf++);
1198	for (__ns = __nf; __ns < __ne; ++__ns)
1199	if (!isxdigit_l(*__ns, _LIBCPP_GET_C_LOCALE))
1200	break;
1201	}
1202	else
1203	{
1204	for (__ns = __nf; __ns < __ne; ++__ns)
1205	if (!isdigit_l(*__ns, _LIBCPP_GET_C_LOCALE))
1206	break;
1207	}
1208	if (__grouping.empty())
1209	{
1210	__ct.widen(__nf, __ns, __oe);
1211	__oe += __ns - __nf;
1212	}
1213	else
1214	{
1215	reverse(__nf, __ns);
1216	_CharT __thousands_sep = __npt.thousands_sep();
1217	unsigned __dc = `0`;
1218	unsigned __dg = `0`;
1219	for (char* __p = __nf; __p < __ns; ++__p)
1220	{
1221	if (__grouping [__dg] > `0` && __dc == static_cast<unsigned>(__grouping [__dg]))
1222	{
1223	*__oe++ = __thousands_sep;
1224	__dc = `0`;
1225	if (__dg < __grouping.size()-`1`)
1226	++__dg;
1227	}
1228	__oe++ = __ct.widen(__p);
1229	++__dc;
1230	}
1231	reverse(__ob + (__nf - __nb), __oe);
1232	}
1233	for (__nf = __ns; __nf < __ne; ++__nf)
1234	{
1235	if (*__nf == `'.'`)
1236	{
1237	*__oe++ = __npt.decimal_point();
1238	++__nf;
1239	break;
1240	}
1241	else
1242	__oe++ = __ct.widen(__nf);
1243	}
1244	__ct.widen(__nf, __ne, __oe);
1245	__oe += __ne - __nf;
1246	if (__np == __ne)
1247	__op = __oe;
1248	else
1249	__op = __ob + (__np - __nb);
1250	}
1251
1252	_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<char>)
1253	_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<wchar_t>)
1254
1255	template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
1256	class _LIBCPP_TEMPLATE_VIS num_put
1257	: public locale::facet,
1258	private __num_put<_CharT>
1259	{
1260	public:
1261	typedef _CharT char_type;
1262	typedef _OutputIterator iter_type;
1263
1264	_LIBCPP_INLINE_VISIBILITY
1265	explicit num_put(size_t __refs = `0`)
1266	: locale::facet(__refs) {}
1267
1268	_LIBCPP_INLINE_VISIBILITY
1269	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
1270	bool __v) const
1271	{
1272	return do_put(__s, __iob, __fl, __v);
1273	}
1274
1275	_LIBCPP_INLINE_VISIBILITY
1276	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
1277	long __v) const
1278	{
1279	return do_put(__s, __iob, __fl, __v);
1280	}
1281
1282	_LIBCPP_INLINE_VISIBILITY
1283	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
1284	long long __v) const
1285	{
1286	return do_put(__s, __iob, __fl, __v);
1287	}
1288
1289	_LIBCPP_INLINE_VISIBILITY
1290	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
1291	unsigned long __v) const
1292	{
1293	return do_put(__s, __iob, __fl, __v);
1294	}
1295
1296	_LIBCPP_INLINE_VISIBILITY
1297	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
1298	unsigned long long __v) const
1299	{
1300	return do_put(__s, __iob, __fl, __v);
1301	}
1302
1303	_LIBCPP_INLINE_VISIBILITY
1304	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
1305	double __v) const
1306	{
1307	return do_put(__s, __iob, __fl, __v);
1308	}
1309
1310	_LIBCPP_INLINE_VISIBILITY
1311	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
1312	long double __v) const
1313	{
1314	return do_put(__s, __iob, __fl, __v);
1315	}
1316
1317	_LIBCPP_INLINE_VISIBILITY
1318	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
1319	const void* __v) const
1320	{
1321	return do_put(__s, __iob, __fl, __v);
1322	}
1323
1324	static locale::id id;
1325
1326	protected:
1327	_LIBCPP_INLINE_VISIBILITY
1328	~num_put() {}
1329
1330	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
1331	bool __v) const;
1332	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
1333	long __v) const;
1334	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
1335	long long __v) const;
1336	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
1337	unsigned long) const;
1338	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
1339	unsigned long long) const;
1340	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
1341	double __v) const;
1342	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
1343	long double __v) const;
1344	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
1345	const void* __v) const;
1346	};
1347
1348	template <class _CharT, class _OutputIterator>
1349	locale::id
1350	num_put<_CharT, _OutputIterator>::id;
1351
1352	template <class _CharT, class _OutputIterator>
1353	_LIBCPP_HIDDEN
1354	_OutputIterator
1355	__pad_and_output(_OutputIterator __s,
1356	const _CharT* __ob, const _CharT* __op, const _CharT* __oe,
1357	ios_base& __iob, _CharT __fl)
1358	{
1359	streamsize __sz = __oe - __ob;
1360	streamsize __ns = __iob.width();
1361	if (__ns > __sz)
1362	__ns -= __sz;
1363	else
1364	__ns = `0`;
1365	for (;__ob < __op; ++__ob, ++__s)
1366	__s = __ob;
1367	for (; __ns; --__ns, ++__s)
1368	*__s = __fl;
1369	for (; __ob < __oe; ++__ob, ++__s)
1370	__s = __ob;
1371	__iob.width(`0`);
1372	return __s;
1373	}
1374
1375	template <class _CharT, class _Traits>
1376	_LIBCPP_HIDDEN
1377	ostreambuf_iterator<_CharT, _Traits>
1378	__pad_and_output(ostreambuf_iterator<_CharT, _Traits> __s,
1379	const _CharT* __ob, const _CharT* __op, const _CharT* __oe,
1380	ios_base& __iob, _CharT __fl)
1381	{
1382	if (__s.__sbuf_ == nullptr)
1383	return __s;
1384	streamsize __sz = __oe - __ob;
1385	streamsize __ns = __iob.width();
1386	if (__ns > __sz)
1387	__ns -= __sz;
1388	else
1389	__ns = `0`;
1390	streamsize __np = __op - __ob;
1391	if (__np > `0`)
1392	{
1393	if (__s.__sbuf_->sputn(__ob, __np) != __np)
1394	{
1395	__s.__sbuf_ = nullptr;
1396	return __s;
1397	}
1398	}
1399	if (__ns > `0`)
1400	{
1401	basic_string<_CharT, _Traits> __sp(__ns, __fl);
1402	if (__s.__sbuf_->sputn(__sp.data(), __ns) != __ns)
1403	{
1404	__s.__sbuf_ = nullptr;
1405	return __s;
1406	}
1407	}
1408	__np = __oe - __op;
1409	if (__np > `0`)
1410	{
1411	if (__s.__sbuf_->sputn(__op, __np) != __np)
1412	{
1413	__s.__sbuf_ = nullptr;
1414	return __s;
1415	}
1416	}
1417	__iob.width(`0`);
1418	return __s;
1419	}
1420
1421	template <class _CharT, class _OutputIterator>
1422	_OutputIterator
1423	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
1424	char_type __fl, bool __v) const
1425	{
1426	if ((__iob.flags() & ios_base::boolalpha) == `0`)
1427	return do_put(__s, __iob, __fl, (unsigned long)__v);
1428	const numpunct<char_type>& __np = use_facet<numpunct<char_type> >(__iob.getloc());
1429	typedef typename numpunct<char_type>::string_type string_type;
1430	#if _LIBCPP_DEBUG_LEVEL >= 2
1431	string_type __tmp(__v ? __np.truename() : __np.falsename());
1432	string_type __nm = _VSTD::move(__tmp);
1433	#else
1434	string_type __nm = __v ? __np.truename() : __np.falsename();
1435	#endif
1436	for (typename string_type::iterator __i = __nm.begin(); __i != __nm.end(); ++__i, ++__s)
1437	__s = __i;
1438	return __s;
1439	}
1440
1441	template <class _CharT, class _OutputIterator>
1442	_OutputIterator
1443	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
1444	char_type __fl, long __v) const
1445	{
1446	// Stage 1 - Get number in narrow char
1447	char __fmt[`6`] = {`'%'`, `0`};
1448	const char* __len = "l";
1449	this->__format_int(__fmt+`1`, __len, true, __iob.flags());
1450	const unsigned __nbuf = (numeric_limits<long>::digits / `3`)
1451	+ ((numeric_limits<long>::digits % `3`) != `0`)
1452	+ ((__iob.flags() & ios_base::showbase) != `0`)
1453	+ `2`;
1454	char __nar[__nbuf];
1455	int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
1456	char* __ne = __nar + __nc;
1457	char* __np = this->__identify_padding(__nar, __ne, __iob);
1458	// Stage 2 - Widen __nar while adding thousands separators
1459	char_type __o[`2`*(__nbuf-`1`) - `1`];
1460	char_type* __op; // pad here
1461	char_type* __oe; // end of output
1462	this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc());
1463	// [__o, __oe) contains thousands_sep'd wide number
1464	// Stage 3 & 4
1465	return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
1466	}
1467
1468	template <class _CharT, class _OutputIterator>
1469	_OutputIterator
1470	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
1471	char_type __fl, long long __v) const
1472	{
1473	// Stage 1 - Get number in narrow char
1474	char __fmt[`8`] = {`'%'`, `0`};
1475	const char* __len = "ll";
1476	this->__format_int(__fmt+`1`, __len, true, __iob.flags());
1477	const unsigned __nbuf = (numeric_limits<long long>::digits / `3`)
1478	+ ((numeric_limits<long long>::digits % `3`) != `0`)
1479	+ ((__iob.flags() & ios_base::showbase) != `0`)
1480	+ `2`;
1481	char __nar[__nbuf];
1482	int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
1483	char* __ne = __nar + __nc;
1484	char* __np = this->__identify_padding(__nar, __ne, __iob);
1485	// Stage 2 - Widen __nar while adding thousands separators
1486	char_type __o[`2`*(__nbuf-`1`) - `1`];
1487	char_type* __op; // pad here
1488	char_type* __oe; // end of output
1489	this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc());
1490	// [__o, __oe) contains thousands_sep'd wide number
1491	// Stage 3 & 4
1492	return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
1493	}
1494
1495	template <class _CharT, class _OutputIterator>
1496	_OutputIterator
1497	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
1498	char_type __fl, unsigned long __v) const
1499	{
1500	// Stage 1 - Get number in narrow char
1501	char __fmt[`6`] = {`'%'`, `0`};
1502	const char* __len = "l";
1503	this->__format_int(__fmt+`1`, __len, false, __iob.flags());
1504	const unsigned __nbuf = (numeric_limits<unsigned long>::digits / `3`)
1505	+ ((numeric_limits<unsigned long>::digits % `3`) != `0`)
1506	+ ((__iob.flags() & ios_base::showbase) != `0`)
1507	+ `1`;
1508	char __nar[__nbuf];
1509	int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
1510	char* __ne = __nar + __nc;
1511	char* __np = this->__identify_padding(__nar, __ne, __iob);
1512	// Stage 2 - Widen __nar while adding thousands separators
1513	char_type __o[`2`*(__nbuf-`1`) - `1`];
1514	char_type* __op; // pad here
1515	char_type* __oe; // end of output
1516	this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc());
1517	// [__o, __oe) contains thousands_sep'd wide number
1518	// Stage 3 & 4
1519	return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
1520	}
1521
1522	template <class _CharT, class _OutputIterator>
1523	_OutputIterator
1524	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
1525	char_type __fl, unsigned long long __v) const
1526	{
1527	// Stage 1 - Get number in narrow char
1528	char __fmt[`8`] = {`'%'`, `0`};
1529	const char* __len = "ll";
1530	this->__format_int(__fmt+`1`, __len, false, __iob.flags());
1531	const unsigned __nbuf = (numeric_limits<unsigned long long>::digits / `3`)
1532	+ ((numeric_limits<unsigned long long>::digits % `3`) != `0`)
1533	+ ((__iob.flags() & ios_base::showbase) != `0`)
1534	+ `1`;
1535	char __nar[__nbuf];
1536	int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
1537	char* __ne = __nar + __nc;
1538	char* __np = this->__identify_padding(__nar, __ne, __iob);
1539	// Stage 2 - Widen __nar while adding thousands separators
1540	char_type __o[`2`*(__nbuf-`1`) - `1`];
1541	char_type* __op; // pad here
1542	char_type* __oe; // end of output
1543	this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc());
1544	// [__o, __oe) contains thousands_sep'd wide number
1545	// Stage 3 & 4
1546	return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
1547	}
1548
1549	template <class _CharT, class _OutputIterator>
1550	_OutputIterator
1551	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
1552	char_type __fl, double __v) const
1553	{
1554	// Stage 1 - Get number in narrow char
1555	char __fmt[`8`] = {`'%'`, `0`};
1556	const char* __len = "";
1557	bool __specify_precision = this->__format_float(__fmt+`1`, __len, __iob.flags());
1558	const unsigned __nbuf = `30`;
1559	char __nar[__nbuf];
1560	char* __nb = __nar;
1561	int __nc;
1562	if (__specify_precision)
1563	__nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
1564	(int)__iob.precision(), __v);
1565	else
1566	__nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
1567	unique_ptr<char, void()(void**)> __nbh(`0`, free);
1568	if (__nc > static_cast<int>(__nbuf-`1`))
1569	{
1570	if (__specify_precision)
1571	__nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
1572	else
1573	__nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
1574	if (__nb == `0`)
1575	__throw_bad_alloc();
1576	__nbh.reset(__nb);
1577	}
1578	char* __ne = __nb + __nc;
1579	char* __np = this->__identify_padding(__nb, __ne, __iob);
1580	// Stage 2 - Widen __nar while adding thousands separators
1581	char_type __o[`2`*(__nbuf-`1`) - `1`];
1582	char_type* __ob = __o;
1583	unique_ptr<char_type, void()(void**)> __obh(`0`, free);
1584	if (__nb != __nar)
1585	{
1586	__ob = (char_type)malloc(`2`static_cast<size_t>(__nc)*sizeof(char_type));
1587	if (__ob == `0`)
1588	__throw_bad_alloc();
1589	__obh.reset(__ob);
1590	}
1591	char_type* __op; // pad here
1592	char_type* __oe; // end of output
1593	this->__widen_and_group_float(__nb, __np, __ne, __ob, __op, __oe, __iob.getloc());
1594	// [__o, __oe) contains thousands_sep'd wide number
1595	// Stage 3 & 4
1596	__s = __pad_and_output(__s, __ob, __op, __oe, __iob, __fl);
1597	return __s;
1598	}
1599
1600	template <class _CharT, class _OutputIterator>
1601	_OutputIterator
1602	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
1603	char_type __fl, long double __v) const
1604	{
1605	// Stage 1 - Get number in narrow char
1606	char __fmt[`8`] = {`'%'`, `0`};
1607	const char* __len = "L";
1608	bool __specify_precision = this->__format_float(__fmt+`1`, __len, __iob.flags());
1609	const unsigned __nbuf = `30`;
1610	char __nar[__nbuf];
1611	char* __nb = __nar;
1612	int __nc;
1613	if (__specify_precision)
1614	__nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
1615	(int)__iob.precision(), __v);
1616	else
1617	__nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
1618	unique_ptr<char, void()(void**)> __nbh(`0`, free);
1619	if (__nc > static_cast<int>(__nbuf-`1`))
1620	{
1621	if (__specify_precision)
1622	__nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
1623	else
1624	__nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
1625	if (__nb == `0`)
1626	__throw_bad_alloc();
1627	__nbh.reset(__nb);
1628	}
1629	char* __ne = __nb + __nc;
1630	char* __np = this->__identify_padding(__nb, __ne, __iob);
1631	// Stage 2 - Widen __nar while adding thousands separators
1632	char_type __o[`2`*(__nbuf-`1`) - `1`];
1633	char_type* __ob = __o;
1634	unique_ptr<char_type, void()(void**)> __obh(`0`, free);
1635	if (__nb != __nar)
1636	{
1637	__ob = (char_type)malloc(`2`static_cast<size_t>(__nc)*sizeof(char_type));
1638	if (__ob == `0`)
1639	__throw_bad_alloc();
1640	__obh.reset(__ob);
1641	}
1642	char_type* __op; // pad here
1643	char_type* __oe; // end of output
1644	this->__widen_and_group_float(__nb, __np, __ne, __ob, __op, __oe, __iob.getloc());
1645	// [__o, __oe) contains thousands_sep'd wide number
1646	// Stage 3 & 4
1647	__s = __pad_and_output(__s, __ob, __op, __oe, __iob, __fl);
1648	return __s;
1649	}
1650
1651	template <class _CharT, class _OutputIterator>
1652	_OutputIterator
1653	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
1654	char_type __fl, const void* __v) const
1655	{
1656	// Stage 1 - Get pointer in narrow char
1657	char __fmt[`6`] = "%p";
1658	const unsigned __nbuf = `20`;
1659	char __nar[__nbuf];
1660	int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
1661	char* __ne = __nar + __nc;
1662	char* __np = this->__identify_padding(__nar, __ne, __iob);
1663	// Stage 2 - Widen __nar
1664	char_type __o[`2`*(__nbuf-`1`) - `1`];
1665	char_type* __op; // pad here
1666	char_type* __oe; // end of output
1667	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
1668	__ct.widen(__nar, __ne, __o);
1669	__oe = __o + (__ne - __nar);
1670	if (__np == __ne)
1671	__op = __oe;
1672	else
1673	__op = __o + (__np - __nar);
1674	// [__o, __oe) contains wide number
1675	// Stage 3 & 4
1676	return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
1677	}
1678
1679	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<char>)
1680	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<wchar_t>)
1681
1682	template <class _CharT, class _InputIterator>
1683	_LIBCPP_HIDDEN
1684	int
1685	__get_up_to_n_digits(_InputIterator& __b, _InputIterator __e,
1686	ios_base::iostate& __err, const ctype<_CharT>& __ct, int __n)
1687	{
1688	// Precondition: __n >= 1
1689	if (__b == __e)
1690	{
1691	__err \|= ios_base::eofbit \| ios_base::failbit;
1692	return `0`;
1693	}
1694	// get first digit
1695	_CharT __c = *__b;
1696	if (!__ct.is(ctype_base::digit, __c))
1697	{
1698	__err \|= ios_base::failbit;
1699	return `0`;
1700	}
1701	int __r = __ct.narrow(__c, `0`) - `'0'`;
1702	for (++__b, (void) --__n; __b != __e && __n > `0`; ++__b, (void) --__n)
1703	{
1704	// get next digit
1705	__c = *__b;
1706	if (!__ct.is(ctype_base::digit, __c))
1707	return __r;
1708	__r = __r * `10` + __ct.narrow(__c, `0`) - `'0'`;
1709	}
1710	if (__b == __e)
1711	__err \|= ios_base::eofbit;
1712	return __r;
1713	}
1714
1715	class _LIBCPP_TYPE_VIS time_base
1716	{
1717	public:
1718	enum dateorder {no_order, dmy, mdy, ymd, ydm};
1719	};
1720
1721	template <class _CharT>
1722	class _LIBCPP_TEMPLATE_VIS __time_get_c_storage
1723	{
1724	protected:
1725	typedef basic_string<_CharT> string_type;
1726
1727	virtual const string_type* __weeks() const;
1728	virtual const string_type* __months() const;
1729	virtual const string_type* __am_pm() const;
1730	virtual const string_type& __c() const;
1731	virtual const string_type& __r() const;
1732	virtual const string_type& __x() const;
1733	virtual const string_type& __X() const;
1734
1735	_LIBCPP_INLINE_VISIBILITY
1736	~__time_get_c_storage() {}
1737	};
1738
1739	template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__weeks() const;
1740	template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__months() const;
1741	template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__am_pm() const;
1742	template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__c() const;
1743	template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__r() const;
1744	template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__x() const;
1745	template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__X() const;
1746
1747	template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__weeks() const;
1748	template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__months() const;
1749	template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__am_pm() const;
1750	template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__c() const;
1751	template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__r() const;
1752	template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__x() const;
1753	template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__X() const;
1754
1755	template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
1756	class _LIBCPP_TEMPLATE_VIS time_get
1757	: public locale::facet,
1758	public time_base,
1759	private __time_get_c_storage<_CharT>
1760	{
1761	public:
1762	typedef _CharT char_type;
1763	typedef _InputIterator iter_type;
1764	typedef time_base::dateorder dateorder;
1765	typedef basic_string<char_type> string_type;
1766
1767	_LIBCPP_INLINE_VISIBILITY
1768	explicit time_get(size_t __refs = `0`)
1769	: locale::facet(__refs) {}
1770
1771	_LIBCPP_INLINE_VISIBILITY
1772	dateorder date_order() const
1773	{
1774	return this->do_date_order();
1775	}
1776
1777	_LIBCPP_INLINE_VISIBILITY
1778	iter_type get_time(iter_type __b, iter_type __e, ios_base& __iob,
1779	ios_base::iostate& __err, tm* __tm) const
1780	{
1781	return do_get_time(__b, __e, __iob, __err, __tm);
1782	}
1783
1784	_LIBCPP_INLINE_VISIBILITY
1785	iter_type get_date(iter_type __b, iter_type __e, ios_base& __iob,
1786	ios_base::iostate& __err, tm* __tm) const
1787	{
1788	return do_get_date(__b, __e, __iob, __err, __tm);
1789	}
1790
1791	_LIBCPP_INLINE_VISIBILITY
1792	iter_type get_weekday(iter_type __b, iter_type __e, ios_base& __iob,
1793	ios_base::iostate& __err, tm* __tm) const
1794	{
1795	return do_get_weekday(__b, __e, __iob, __err, __tm);
1796	}
1797
1798	_LIBCPP_INLINE_VISIBILITY
1799	iter_type get_monthname(iter_type __b, iter_type __e, ios_base& __iob,
1800	ios_base::iostate& __err, tm* __tm) const
1801	{
1802	return do_get_monthname(__b, __e, __iob, __err, __tm);
1803	}
1804
1805	_LIBCPP_INLINE_VISIBILITY
1806	iter_type get_year(iter_type __b, iter_type __e, ios_base& __iob,
1807	ios_base::iostate& __err, tm* __tm) const
1808	{
1809	return do_get_year(__b, __e, __iob, __err, __tm);
1810	}
1811
1812	_LIBCPP_INLINE_VISIBILITY
1813	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
1814	ios_base::iostate& __err, tm *__tm,
1815	char __fmt, char __mod = `0`) const
1816	{
1817	return do_get(__b, __e, __iob, __err, __tm, __fmt, __mod);
1818	}
1819
1820	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
1821	ios_base::iostate& __err, tm* __tm,
1822	const char_type* __fmtb, const char_type* __fmte) const;
1823
1824	static locale::id id;
1825
1826	protected:
1827	_LIBCPP_INLINE_VISIBILITY
1828	~time_get() {}
1829
1830	virtual dateorder do_date_order() const;
1831	virtual iter_type do_get_time(iter_type __b, iter_type __e, ios_base& __iob,
1832	ios_base::iostate& __err, tm* __tm) const;
1833	virtual iter_type do_get_date(iter_type __b, iter_type __e, ios_base& __iob,
1834	ios_base::iostate& __err, tm* __tm) const;
1835	virtual iter_type do_get_weekday(iter_type __b, iter_type __e, ios_base& __iob,
1836	ios_base::iostate& __err, tm* __tm) const;
1837	virtual iter_type do_get_monthname(iter_type __b, iter_type __e, ios_base& __iob,
1838	ios_base::iostate& __err, tm* __tm) const;
1839	virtual iter_type do_get_year(iter_type __b, iter_type __e, ios_base& __iob,
1840	ios_base::iostate& __err, tm* __tm) const;
1841	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
1842	ios_base::iostate& __err, tm* __tm,
1843	char __fmt, char __mod) const;
1844	private:
1845	void __get_white_space(iter_type& __b, iter_type __e,
1846	ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1847	void __get_percent(iter_type& __b, iter_type __e, ios_base::iostate& __err,
1848	const ctype<char_type>& __ct) const;
1849
1850	void __get_weekdayname(int& __m,
1851	iter_type& __b, iter_type __e,
1852	ios_base::iostate& __err,
1853	const ctype<char_type>& __ct) const;
1854	void __get_monthname(int& __m,
1855	iter_type& __b, iter_type __e,
1856	ios_base::iostate& __err,
1857	const ctype<char_type>& __ct) const;
1858	void __get_day(int& __d,
1859	iter_type& __b, iter_type __e,
1860	ios_base::iostate& __err,
1861	const ctype<char_type>& __ct) const;
1862	void __get_month(int& __m,
1863	iter_type& __b, iter_type __e,
1864	ios_base::iostate& __err,
1865	const ctype<char_type>& __ct) const;
1866	void __get_year(int& __y,
1867	iter_type& __b, iter_type __e,
1868	ios_base::iostate& __err,
1869	const ctype<char_type>& __ct) const;
1870	void __get_year4(int& __y,
1871	iter_type& __b, iter_type __e,
1872	ios_base::iostate& __err,
1873	const ctype<char_type>& __ct) const;
1874	void __get_hour(int& __d,
1875	iter_type& __b, iter_type __e,
1876	ios_base::iostate& __err,
1877	const ctype<char_type>& __ct) const;
1878	void __get_12_hour(int& __h,
1879	iter_type& __b, iter_type __e,
1880	ios_base::iostate& __err,
1881	const ctype<char_type>& __ct) const;
1882	void __get_am_pm(int& __h,
1883	iter_type& __b, iter_type __e,
1884	ios_base::iostate& __err,
1885	const ctype<char_type>& __ct) const;
1886	void __get_minute(int& __m,
1887	iter_type& __b, iter_type __e,
1888	ios_base::iostate& __err,
1889	const ctype<char_type>& __ct) const;
1890	void __get_second(int& __s,
1891	iter_type& __b, iter_type __e,
1892	ios_base::iostate& __err,
1893	const ctype<char_type>& __ct) const;
1894	void __get_weekday(int& __w,
1895	iter_type& __b, iter_type __e,
1896	ios_base::iostate& __err,
1897	const ctype<char_type>& __ct) const;
1898	void __get_day_year_num(int& __w,
1899	iter_type& __b, iter_type __e,
1900	ios_base::iostate& __err,
1901	const ctype<char_type>& __ct) const;
1902	};
1903
1904	template <class _CharT, class _InputIterator>
1905	locale::id
1906	time_get<_CharT, _InputIterator>::id;
1907
1908	// time_get primitives
1909
1910	template <class _CharT, class _InputIterator>
1911	void
1912	time_get<_CharT, _InputIterator>::__get_weekdayname(int& __w,
1913	iter_type& __b, iter_type __e,
1914	ios_base::iostate& __err,
1915	const ctype<char_type>& __ct) const
1916	{
1917	// Note: ignoring case comes from the POSIX strptime spec
1918	const string_type* __wk = this->__weeks();
1919	ptrdiff_t __i = __scan_keyword(__b, __e, __wk, __wk+`14`, __ct, __err, false) - __wk;
1920	if (__i < `14`)
1921	__w = __i % `7`;
1922	}
1923
1924	template <class _CharT, class _InputIterator>
1925	void
1926	time_get<_CharT, _InputIterator>::__get_monthname(int& __m,
1927	iter_type& __b, iter_type __e,
1928	ios_base::iostate& __err,
1929	const ctype<char_type>& __ct) const
1930	{
1931	// Note: ignoring case comes from the POSIX strptime spec
1932	const string_type* __month = this->__months();
1933	ptrdiff_t __i = __scan_keyword(__b, __e, __month, __month+`24`, __ct, __err, false) - __month;
1934	if (__i < `24`)
1935	__m = __i % `12`;
1936	}
1937
1938	template <class _CharT, class _InputIterator>
1939	void
1940	time_get<_CharT, _InputIterator>::__get_day(int& __d,
1941	iter_type& __b, iter_type __e,
1942	ios_base::iostate& __err,
1943	const ctype<char_type>& __ct) const
1944	{
1945	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, `2`);
1946	if (!(__err & ios_base::failbit) && `1` <= __t && __t <= `31`)
1947	__d = __t;
1948	else
1949	__err \|= ios_base::failbit;
1950	}
1951
1952	template <class _CharT, class _InputIterator>
1953	void
1954	time_get<_CharT, _InputIterator>::__get_month(int& __m,
1955	iter_type& __b, iter_type __e,
1956	ios_base::iostate& __err,
1957	const ctype<char_type>& __ct) const
1958	{
1959	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, `2`) - `1`;
1960	if (!(__err & ios_base::failbit) && __t <= `11`)
1961	__m = __t;
1962	else
1963	__err \|= ios_base::failbit;
1964	}
1965
1966	template <class _CharT, class _InputIterator>
1967	void
1968	time_get<_CharT, _InputIterator>::__get_year(int& __y,
1969	iter_type& __b, iter_type __e,
1970	ios_base::iostate& __err,
1971	const ctype<char_type>& __ct) const
1972	{
1973	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, `4`);
1974	if (!(__err & ios_base::failbit))
1975	{
1976	if (__t < `69`)
1977	__t += `2000`;
1978	else if (`69` <= __t && __t <= `99`)
1979	__t += `1900`;
1980	__y = __t - `1900`;
1981	}
1982	}
1983
1984	template <class _CharT, class _InputIterator>
1985	void
1986	time_get<_CharT, _InputIterator>::__get_year4(int& __y,
1987	iter_type& __b, iter_type __e,
1988	ios_base::iostate& __err,
1989	const ctype<char_type>& __ct) const
1990	{
1991	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, `4`);
1992	if (!(__err & ios_base::failbit))
1993	__y = __t - `1900`;
1994	}
1995
1996	template <class _CharT, class _InputIterator>
1997	void
1998	time_get<_CharT, _InputIterator>::__get_hour(int& __h,
1999	iter_type& __b, iter_type __e,
2000	ios_base::iostate& __err,
2001	const ctype<char_type>& __ct) const
2002	{
2003	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, `2`);
2004	if (!(__err & ios_base::failbit) && __t <= `23`)
2005	__h = __t;
2006	else
2007	__err \|= ios_base::failbit;
2008	}
2009
2010	template <class _CharT, class _InputIterator>
2011	void
2012	time_get<_CharT, _InputIterator>::__get_12_hour(int& __h,
2013	iter_type& __b, iter_type __e,
2014	ios_base::iostate& __err,
2015	const ctype<char_type>& __ct) const
2016	{
2017	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, `2`);
2018	if (!(__err & ios_base::failbit) && `1` <= __t && __t <= `12`)
2019	__h = __t;
2020	else
2021	__err \|= ios_base::failbit;
2022	}
2023
2024	template <class _CharT, class _InputIterator>
2025	void
2026	time_get<_CharT, _InputIterator>::__get_minute(int& __m,
2027	iter_type& __b, iter_type __e,
2028	ios_base::iostate& __err,
2029	const ctype<char_type>& __ct) const
2030	{
2031	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, `2`);
2032	if (!(__err & ios_base::failbit) && __t <= `59`)
2033	__m = __t;
2034	else
2035	__err \|= ios_base::failbit;
2036	}
2037
2038	template <class _CharT, class _InputIterator>
2039	void
2040	time_get<_CharT, _InputIterator>::__get_second(int& __s,
2041	iter_type& __b, iter_type __e,
2042	ios_base::iostate& __err,
2043	const ctype<char_type>& __ct) const
2044	{
2045	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, `2`);
2046	if (!(__err & ios_base::failbit) && __t <= `60`)
2047	__s = __t;
2048	else
2049	__err \|= ios_base::failbit;
2050	}
2051
2052	template <class _CharT, class _InputIterator>
2053	void
2054	time_get<_CharT, _InputIterator>::__get_weekday(int& __w,
2055	iter_type& __b, iter_type __e,
2056	ios_base::iostate& __err,
2057	const ctype<char_type>& __ct) const
2058	{
2059	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, `1`);
2060	if (!(__err & ios_base::failbit) && __t <= `6`)
2061	__w = __t;
2062	else
2063	__err \|= ios_base::failbit;
2064	}
2065
2066	template <class _CharT, class _InputIterator>
2067	void
2068	time_get<_CharT, _InputIterator>::__get_day_year_num(int& __d,
2069	iter_type& __b, iter_type __e,
2070	ios_base::iostate& __err,
2071	const ctype<char_type>& __ct) const
2072	{
2073	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, `3`);
2074	if (!(__err & ios_base::failbit) && __t <= `365`)
2075	__d = __t;
2076	else
2077	__err \|= ios_base::failbit;
2078	}
2079
2080	template <class _CharT, class _InputIterator>
2081	void
2082	time_get<_CharT, _InputIterator>::__get_white_space(iter_type& __b, iter_type __e,
2083	ios_base::iostate& __err,
2084	const ctype<char_type>& __ct) const
2085	{
2086	for (; __b != __e && __ct.is(ctype_base::space, *__b); ++__b)
2087	;
2088	if (__b == __e)
2089	__err \|= ios_base::eofbit;
2090	}
2091
2092	template <class _CharT, class _InputIterator>
2093	void
2094	time_get<_CharT, _InputIterator>::__get_am_pm(int& __h,
2095	iter_type& __b, iter_type __e,
2096	ios_base::iostate& __err,
2097	const ctype<char_type>& __ct) const
2098	{
2099	const string_type* __ap = this->__am_pm();
2100	if (__ap[`0`].size() + __ap[`1`].size() == `0`)
2101	{
2102	__err \|= ios_base::failbit;
2103	return;
2104	}
2105	ptrdiff_t __i = __scan_keyword(__b, __e, __ap, __ap+`2`, __ct, __err, false) - __ap;
2106	if (__i == `0` && __h == `12`)
2107	__h = `0`;
2108	else if (__i == `1` && __h < `12`)
2109	__h += `12`;
2110	}
2111
2112	template <class _CharT, class _InputIterator>
2113	void
2114	time_get<_CharT, _InputIterator>::__get_percent(iter_type& __b, iter_type __e,
2115	ios_base::iostate& __err,
2116	const ctype<char_type>& __ct) const
2117	{
2118	if (__b == __e)
2119	{
2120	__err \|= ios_base::eofbit \| ios_base::failbit;
2121	return;
2122	}
2123	if (__ct.narrow(*__b, `0`) != `'%'`)
2124	__err \|= ios_base::failbit;
2125	else if(++__b == __e)
2126	__err \|= ios_base::eofbit;
2127	}
2128
2129	// time_get end primitives
2130
2131	template <class _CharT, class _InputIterator>
2132	_InputIterator
2133	time_get<_CharT, _InputIterator>::get(iter_type __b, iter_type __e,
2134	ios_base& __iob,
2135	ios_base::iostate& __err, tm* __tm,
2136	const char_type* __fmtb, const char_type* __fmte) const
2137	{
2138	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
2139	__err = ios_base::goodbit;
2140	while (__fmtb != __fmte && __err == ios_base::goodbit)
2141	{
2142	if (__b == __e)
2143	{
2144	__err = ios_base::failbit;
2145	break;
2146	}
2147	if (__ct.narrow(*__fmtb, `0`) == `'%'`)
2148	{
2149	if (++__fmtb == __fmte)
2150	{
2151	__err = ios_base::failbit;
2152	break;
2153	}
2154	char __cmd = __ct.narrow(*__fmtb, `0`);
2155	char __opt = `'\0'`;
2156	if (__cmd == `'E'` \|\| __cmd == `'0'`)
2157	{
2158	if (++__fmtb == __fmte)
2159	{
2160	__err = ios_base::failbit;
2161	break;
2162	}
2163	__opt = __cmd;
2164	__cmd = __ct.narrow(*__fmtb, `0`);
2165	}
2166	__b = do_get(__b, __e, __iob, __err, __tm, __cmd, __opt);
2167	++__fmtb;
2168	}
2169	else if (__ct.is(ctype_base::space, *__fmtb))
2170	{
2171	for (++__fmtb; __fmtb != __fmte && __ct.is(ctype_base::space, *__fmtb); ++__fmtb)
2172	;
2173	for ( ; __b != __e && __ct.is(ctype_base::space, *__b); ++__b)
2174	;
2175	}
2176	else if (__ct.toupper(__b) == __ct.toupper(__fmtb))
2177	{
2178	++__b;
2179	++__fmtb;
2180	}
2181	else
2182	__err = ios_base::failbit;
2183	}
2184	if (__b == __e)
2185	__err \|= ios_base::eofbit;
2186	return __b;
2187	}
2188
2189	template <class _CharT, class _InputIterator>
2190	typename time_get<_CharT, _InputIterator>::dateorder
2191	time_get<_CharT, _InputIterator>::do_date_order() const
2192	{
2193	return mdy;
2194	}
2195
2196	template <class _CharT, class _InputIterator>
2197	_InputIterator
2198	time_get<_CharT, _InputIterator>::do_get_time(iter_type __b, iter_type __e,
2199	ios_base& __iob,
2200	ios_base::iostate& __err,
2201	tm* __tm) const
2202	{
2203	const char_type __fmt[] = {`'%'`, `'H'`, `':'`, `'%'`, `'M'`, `':'`, `'%'`, `'S'`};
2204	return get(__b, __e, __iob, __err, __tm, __fmt, __fmt + sizeof(__fmt)/sizeof(__fmt[`0`]));
2205	}
2206
2207	template <class _CharT, class _InputIterator>
2208	_InputIterator
2209	time_get<_CharT, _InputIterator>::do_get_date(iter_type __b, iter_type __e,
2210	ios_base& __iob,
2211	ios_base::iostate& __err,
2212	tm* __tm) const
2213	{
2214	const string_type& __fmt = this->__x();
2215	return get(__b, __e, __iob, __err, __tm, __fmt.data(), __fmt.data() + __fmt.size());
2216	}
2217
2218	template <class _CharT, class _InputIterator>
2219	_InputIterator
2220	time_get<_CharT, _InputIterator>::do_get_weekday(iter_type __b, iter_type __e,
2221	ios_base& __iob,
2222	ios_base::iostate& __err,
2223	tm* __tm) const
2224	{
2225	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
2226	__get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct);
2227	return __b;
2228	}
2229
2230	template <class _CharT, class _InputIterator>
2231	_InputIterator
2232	time_get<_CharT, _InputIterator>::do_get_monthname(iter_type __b, iter_type __e,
2233	ios_base& __iob,
2234	ios_base::iostate& __err,
2235	tm* __tm) const
2236	{
2237	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
2238	__get_monthname(__tm->tm_mon, __b, __e, __err, __ct);
2239	return __b;
2240	}
2241
2242	template <class _CharT, class _InputIterator>
2243	_InputIterator
2244	time_get<_CharT, _InputIterator>::do_get_year(iter_type __b, iter_type __e,
2245	ios_base& __iob,
2246	ios_base::iostate& __err,
2247	tm* __tm) const
2248	{
2249	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
2250	__get_year(__tm->tm_year, __b, __e, __err, __ct);
2251	return __b;
2252	}
2253
2254	template <class _CharT, class _InputIterator>
2255	_InputIterator
2256	time_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
2257	ios_base& __iob,
2258	ios_base::iostate& __err, tm* __tm,
2259	char __fmt, char) const
2260	{
2261	__err = ios_base::goodbit;
2262	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
2263	switch (__fmt)
2264	{
2265	case `'a'`:
2266	case `'A'`:
2267	__get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct);
2268	break;
2269	case `'b'`:
2270	case `'B'`:
2271	case `'h'`:
2272	__get_monthname(__tm->tm_mon, __b, __e, __err, __ct);
2273	break;
2274	case `'c'`:
2275	{
2276	const string_type& __fm = this->__c();
2277	__b = get(__b, __e, __iob, __err, __tm, __fm.data(), __fm.data() + __fm.size());
2278	}
2279	break;
2280	case `'d'`:
2281	case `'e'`:
2282	__get_day(__tm->tm_mday, __b, __e, __err, __ct);
2283	break;
2284	case `'D'`:
2285	{
2286	const char_type __fm[] = {`'%'`, `'m'`, `'/'`, `'%'`, `'d'`, `'/'`, `'%'`, `'y'`};
2287	__b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[`0`]));
2288	}
2289	break;
2290	case `'F'`:
2291	{
2292	const char_type __fm[] = {`'%'`, `'Y'`, `'-'`, `'%'`, `'m'`, `'-'`, `'%'`, `'d'`};
2293	__b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[`0`]));
2294	}
2295	break;
2296	case `'H'`:
2297	__get_hour(__tm->tm_hour, __b, __e, __err, __ct);
2298	break;
2299	case `'I'`:
2300	__get_12_hour(__tm->tm_hour, __b, __e, __err, __ct);
2301	break;
2302	case `'j'`:
2303	__get_day_year_num(__tm->tm_yday, __b, __e, __err, __ct);
2304	break;
2305	case `'m'`:
2306	__get_month(__tm->tm_mon, __b, __e, __err, __ct);
2307	break;
2308	case `'M'`:
2309	__get_minute(__tm->tm_min, __b, __e, __err, __ct);
2310	break;
2311	case `'n'`:
2312	case `'t'`:
2313	__get_white_space(__b, __e, __err, __ct);
2314	break;
2315	case `'p'`:
2316	__get_am_pm(__tm->tm_hour, __b, __e, __err, __ct);
2317	break;
2318	case `'r'`:
2319	{
2320	const char_type __fm[] = {`'%'`, `'I'`, `':'`, `'%'`, `'M'`, `':'`, `'%'`, `'S'`, `' '`, `'%'`, `'p'`};
2321	__b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[`0`]));
2322	}
2323	break;
2324	case `'R'`:
2325	{
2326	const char_type __fm[] = {`'%'`, `'H'`, `':'`, `'%'`, `'M'`};
2327	__b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[`0`]));
2328	}
2329	break;
2330	case `'S'`:
2331	__get_second(__tm->tm_sec, __b, __e, __err, __ct);
2332	break;
2333	case `'T'`:
2334	{
2335	const char_type __fm[] = {`'%'`, `'H'`, `':'`, `'%'`, `'M'`, `':'`, `'%'`, `'S'`};
2336	__b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[`0`]));
2337	}
2338	break;
2339	case `'w'`:
2340	__get_weekday(__tm->tm_wday, __b, __e, __err, __ct);
2341	break;
2342	case `'x'`:
2343	return do_get_date(__b, __e, __iob, __err, __tm);
2344	case `'X'`:
2345	{
2346	const string_type& __fm = this->__X();
2347	__b = get(__b, __e, __iob, __err, __tm, __fm.data(), __fm.data() + __fm.size());
2348	}
2349	break;
2350	case `'y'`:
2351	__get_year(__tm->tm_year, __b, __e, __err, __ct);
2352	break;
2353	case `'Y'`:
2354	__get_year4(__tm->tm_year, __b, __e, __err, __ct);
2355	break;
2356	case `'%'`:
2357	__get_percent(__b, __e, __err, __ct);
2358	break;
2359	default:
2360	__err \|= ios_base::failbit;
2361	}
2362	return __b;
2363	}
2364
2365	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get<char>)
2366	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get<wchar_t>)
2367
2368	class _LIBCPP_TYPE_VIS __time_get
2369	{
2370	protected:
2371	locale_t __loc_;
2372
2373	__time_get(const char* __nm);
2374	__time_get(const string& __nm);
2375	~__time_get();
2376	};
2377
2378	template <class _CharT>
2379	class _LIBCPP_TEMPLATE_VIS __time_get_storage
2380	: public __time_get
2381	{
2382	protected:
2383	typedef basic_string<_CharT> string_type;
2384
2385	string_type __weeks_[`14`];
2386	string_type __months_[`24`];
2387	string_type __am_pm_[`2`];
2388	string_type __c_;
2389	string_type __r_;
2390	string_type __x_;
2391	string_type __X_;
2392
2393	explicit __time_get_storage(const char* __nm);
2394	explicit __time_get_storage(const string& __nm);
2395
2396	_LIBCPP_INLINE_VISIBILITY ~__time_get_storage() {}
2397
2398	time_base::dateorder __do_date_order() const;
2399
2400	private:
2401	void init(const ctype<_CharT>&);
2402	string_type __analyze(char __fmt, const ctype<_CharT>&);
2403	};
2404
2405	#define _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(_CharT) \
2406	template <> _LIBCPP_FUNC_VIS time_base::dateorder __time_get_storage<_CharT>::__do_date_order() const; \
2407	template <> _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::__time_get_storage(const char*); \
2408	template <> _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::__time_get_storage(const string&); \
2409	template <> _LIBCPP_FUNC_VIS void __time_get_storage<_CharT>::init(const ctype<_CharT>&); \
2410	template <> _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::string_type __time_get_storage<_CharT>::__analyze(char, const ctype<_CharT>&); \
2411	extern template _LIBCPP_FUNC_VIS time_base::dateorder __time_get_storage<_CharT>::__do_date_order() const; \
2412	extern template _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::__time_get_storage(const char*); \
2413	extern template _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::__time_get_storage(const string&); \
2414	extern template _LIBCPP_FUNC_VIS void __time_get_storage<_CharT>::init(const ctype<_CharT>&); \
2415	extern template _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::string_type __time_get_storage<_CharT>::__analyze(char, const ctype<_CharT>&); \
2416	/**/
2417
2418	_LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(char)
2419	_LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(wchar_t)
2420	#undef _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION
2421
2422	template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
2423	class _LIBCPP_TEMPLATE_VIS time_get_byname
2424	: public time_get<_CharT, _InputIterator>,
2425	private __time_get_storage<_CharT>
2426	{
2427	public:
2428	typedef time_base::dateorder dateorder;
2429	typedef _InputIterator iter_type;
2430	typedef _CharT char_type;
2431	typedef basic_string<char_type> string_type;
2432
2433	_LIBCPP_INLINE_VISIBILITY
2434	explicit time_get_byname(const char* __nm, size_t __refs = `0`)
2435	: time_get<_CharT, _InputIterator>(__refs),
2436	__time_get_storage<_CharT>(__nm) {}
2437	_LIBCPP_INLINE_VISIBILITY
2438	explicit time_get_byname(const string& __nm, size_t __refs = `0`)
2439	: time_get<_CharT, _InputIterator>(__refs),
2440	__time_get_storage<_CharT>(__nm) {}
2441
2442	protected:
2443	_LIBCPP_INLINE_VISIBILITY
2444	~time_get_byname() {}
2445
2446	_LIBCPP_INLINE_VISIBILITY
2447	virtual dateorder do_date_order() const {return this->__do_date_order();}
2448	private:
2449	_LIBCPP_INLINE_VISIBILITY
2450	virtual const string_type* __weeks() const {return this->__weeks_;}
2451	_LIBCPP_INLINE_VISIBILITY
2452	virtual const string_type* __months() const {return this->__months_;}
2453	_LIBCPP_INLINE_VISIBILITY
2454	virtual const string_type* __am_pm() const {return this->__am_pm_;}
2455	_LIBCPP_INLINE_VISIBILITY
2456	virtual const string_type& __c() const {return this->__c_;}
2457	_LIBCPP_INLINE_VISIBILITY
2458	virtual const string_type& __r() const {return this->__r_;}
2459	_LIBCPP_INLINE_VISIBILITY
2460	virtual const string_type& __x() const {return this->__x_;}
2461	_LIBCPP_INLINE_VISIBILITY
2462	virtual const string_type& __X() const {return this->__X_;}
2463	};
2464
2465	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<char>)
2466	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<wchar_t>)
2467
2468	class _LIBCPP_TYPE_VIS __time_put
2469	{
2470	locale_t __loc_;
2471	protected:
2472	_LIBCPP_INLINE_VISIBILITY __time_put() : __loc_(_LIBCPP_GET_C_LOCALE) {}
2473	__time_put(const char* __nm);
2474	__time_put(const string& __nm);
2475	~__time_put();
2476	void __do_put(char* __nb, char& __ne, const* tm* __tm,
2477	char __fmt, char __mod) const;
2478	void __do_put(wchar_t* __wb, wchar_t& __we, const* tm* __tm,
2479	char __fmt, char __mod) const;
2480	};
2481
2482	template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
2483	class _LIBCPP_TEMPLATE_VIS time_put
2484	: public locale::facet,
2485	private __time_put
2486	{
2487	public:
2488	typedef _CharT char_type;
2489	typedef _OutputIterator iter_type;
2490
2491	_LIBCPP_INLINE_VISIBILITY
2492	explicit time_put(size_t __refs = `0`)
2493	: locale::facet(__refs) {}
2494
2495	iter_type put(iter_type __s, ios_base& __iob, char_type __fl, const tm* __tm,
2496	const char_type* __pb, const char_type* __pe) const;
2497
2498	_LIBCPP_INLINE_VISIBILITY
2499	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
2500	const tm* __tm, char __fmt, char __mod = `0`) const
2501	{
2502	return do_put(__s, __iob, __fl, __tm, __fmt, __mod);
2503	}
2504
2505	static locale::id id;
2506
2507	protected:
2508	_LIBCPP_INLINE_VISIBILITY
2509	~time_put() {}
2510	virtual iter_type do_put(iter_type __s, ios_base&, char_type, const tm* __tm,
2511	char __fmt, char __mod) const;
2512
2513	_LIBCPP_INLINE_VISIBILITY
2514	explicit time_put(const char* __nm, size_t __refs)
2515	: locale::facet(__refs),
2516	__time_put(__nm) {}
2517	_LIBCPP_INLINE_VISIBILITY
2518	explicit time_put(const string& __nm, size_t __refs)
2519	: locale::facet(__refs),
2520	__time_put(__nm) {}
2521	};
2522
2523	template <class _CharT, class _OutputIterator>
2524	locale::id
2525	time_put<_CharT, _OutputIterator>::id;
2526
2527	template <class _CharT, class _OutputIterator>
2528	_OutputIterator
2529	time_put<_CharT, _OutputIterator>::put(iter_type __s, ios_base& __iob,
2530	char_type __fl, const tm* __tm,
2531	const char_type* __pb,
2532	const char_type* __pe) const
2533	{
2534	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
2535	for (; __pb != __pe; ++__pb)
2536	{
2537	if (__ct.narrow(*__pb, `0`) == `'%'`)
2538	{
2539	if (++__pb == __pe)
2540	{
2541	*__s++ = __pb[-`1`];
2542	break;
2543	}
2544	char __mod = `0`;
2545	char __fmt = __ct.narrow(*__pb, `0`);
2546	if (__fmt == `'E'` \|\| __fmt == `'O'`)
2547	{
2548	if (++__pb == __pe)
2549	{
2550	*__s++ = __pb[-`2`];
2551	*__s++ = __pb[-`1`];
2552	break;
2553	}
2554	__mod = __fmt;
2555	__fmt = __ct.narrow(*__pb, `0`);
2556	}
2557	__s = do_put(__s, __iob, __fl, __tm, __fmt, __mod);
2558	}
2559	else
2560	__s++ = __pb;
2561	}
2562	return __s;
2563	}
2564
2565	template <class _CharT, class _OutputIterator>
2566	_OutputIterator
2567	time_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base&,
2568	char_type, const tm* __tm,
2569	char __fmt, char __mod) const
2570	{
2571	char_type __nar[`100`];
2572	char_type* __nb = __nar;
2573	char_type* __ne = __nb + `100`;
2574	__do_put(__nb, __ne, __tm, __fmt, __mod);
2575	return _VSTD::copy(__nb, __ne, __s);
2576	}
2577
2578	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<char>)
2579	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<wchar_t>)
2580
2581	template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
2582	class _LIBCPP_TEMPLATE_VIS time_put_byname
2583	: public time_put<_CharT, _OutputIterator>
2584	{
2585	public:
2586	_LIBCPP_INLINE_VISIBILITY
2587	explicit time_put_byname(const char* __nm, size_t __refs = `0`)
2588	: time_put<_CharT, _OutputIterator>(__nm, __refs) {}
2589
2590	_LIBCPP_INLINE_VISIBILITY
2591	explicit time_put_byname(const string& __nm, size_t __refs = `0`)
2592	: time_put<_CharT, _OutputIterator>(__nm, __refs) {}
2593
2594	protected:
2595	_LIBCPP_INLINE_VISIBILITY
2596	~time_put_byname() {}
2597	};
2598
2599	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<char>)
2600	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<wchar_t>)
2601
2602	// money_base
2603
2604	class _LIBCPP_TYPE_VIS money_base
2605	{
2606	public:
2607	enum part {none, space, symbol, sign, value};
2608	struct pattern {char field[`4`];};
2609
2610	_LIBCPP_INLINE_VISIBILITY money_base() {}
2611	};
2612
2613	// moneypunct
2614
2615	template <class _CharT, bool _International = false>
2616	class _LIBCPP_TEMPLATE_VIS moneypunct
2617	: public locale::facet,
2618	public money_base
2619	{
2620	public:
2621	typedef _CharT char_type;
2622	typedef basic_string<char_type> string_type;
2623
2624	_LIBCPP_INLINE_VISIBILITY
2625	explicit moneypunct(size_t __refs = `0`)
2626	: locale::facet(__refs) {}
2627
2628	_LIBCPP_INLINE_VISIBILITY char_type decimal_point() const {return do_decimal_point();}
2629	_LIBCPP_INLINE_VISIBILITY char_type thousands_sep() const {return do_thousands_sep();}
2630	_LIBCPP_INLINE_VISIBILITY string grouping() const {return do_grouping();}
2631	_LIBCPP_INLINE_VISIBILITY string_type curr_symbol() const {return do_curr_symbol();}
2632	_LIBCPP_INLINE_VISIBILITY string_type positive_sign() const {return do_positive_sign();}
2633	_LIBCPP_INLINE_VISIBILITY string_type negative_sign() const {return do_negative_sign();}
2634	_LIBCPP_INLINE_VISIBILITY int frac_digits() const {return do_frac_digits();}
2635	_LIBCPP_INLINE_VISIBILITY pattern pos_format() const {return do_pos_format();}
2636	_LIBCPP_INLINE_VISIBILITY pattern neg_format() const {return do_neg_format();}
2637
2638	static locale::id id;
2639	static const bool intl = _International;
2640
2641	protected:
2642	_LIBCPP_INLINE_VISIBILITY
2643	~moneypunct() {}
2644
2645	virtual char_type do_decimal_point() const {return numeric_limits<char_type>::max();}
2646	virtual char_type do_thousands_sep() const {return numeric_limits<char_type>::max();}
2647	virtual string do_grouping() const {return string ();}
2648	virtual string_type do_curr_symbol() const {return string_type();}
2649	virtual string_type do_positive_sign() const {return string_type();}
2650	virtual string_type do_negative_sign() const {return string_type(`1`, `'-'`);}
2651	virtual int do_frac_digits() const {return `0`;}
2652	virtual pattern do_pos_format() const
2653	{pattern __p = {{symbol, sign, none, value}}; return __p;}
2654	virtual pattern do_neg_format() const
2655	{pattern __p = {{symbol, sign, none, value}}; return __p;}
2656	};
2657
2658	template <class _CharT, bool _International>
2659	locale::id
2660	moneypunct<_CharT, _International>::id;
2661
2662	template <class _CharT, bool _International>
2663	const bool
2664	moneypunct<_CharT, _International>::intl;
2665
2666	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, false>)
2667	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, true>)
2668	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, false>)
2669	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, true>)
2670
2671	// moneypunct_byname
2672
2673	template <class _CharT, bool _International = false>
2674	class _LIBCPP_TEMPLATE_VIS moneypunct_byname
2675	: public moneypunct<_CharT, _International>
2676	{
2677	public:
2678	typedef money_base::pattern pattern;
2679	typedef _CharT char_type;
2680	typedef basic_string<char_type> string_type;
2681
2682	_LIBCPP_INLINE_VISIBILITY
2683	explicit moneypunct_byname(const char* __nm, size_t __refs = `0`)
2684	: moneypunct<_CharT, _International>(__refs) {init(__nm);}
2685
2686	_LIBCPP_INLINE_VISIBILITY
2687	explicit moneypunct_byname(const string& __nm, size_t __refs = `0`)
2688	: moneypunct<_CharT, _International>(__refs) {init(__nm.c_str());}
2689
2690	protected:
2691	_LIBCPP_INLINE_VISIBILITY
2692	~moneypunct_byname() {}
2693
2694	virtual char_type do_decimal_point() const {return __decimal_point_;}
2695	virtual char_type do_thousands_sep() const {return __thousands_sep_;}
2696	virtual string do_grouping() const {return __grouping_;}
2697	virtual string_type do_curr_symbol() const {return __curr_symbol_;}
2698	virtual string_type do_positive_sign() const {return __positive_sign_;}
2699	virtual string_type do_negative_sign() const {return __negative_sign_;}
2700	virtual int do_frac_digits() const {return __frac_digits_;}
2701	virtual pattern do_pos_format() const {return __pos_format_;}
2702	virtual pattern do_neg_format() const {return __neg_format_;}
2703
2704	private:
2705	char_type __decimal_point_;
2706	char_type __thousands_sep_;
2707	string __grouping_;
2708	string_type __curr_symbol_;
2709	string_type __positive_sign_;
2710	string_type __negative_sign_;
2711	int __frac_digits_;
2712	pattern __pos_format_;
2713	pattern __neg_format_;
2714
2715	void init(const char*);
2716	};
2717
2718	template<> _LIBCPP_FUNC_VIS void moneypunct_byname<char, false>::init(const char*);
2719	template<> _LIBCPP_FUNC_VIS void moneypunct_byname<char, true>::init(const char*);
2720	template<> _LIBCPP_FUNC_VIS void moneypunct_byname<wchar_t, false>::init(const char*);
2721	template<> _LIBCPP_FUNC_VIS void moneypunct_byname<wchar_t, true>::init(const char*);
2722
2723	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, false>)
2724	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, true>)
2725	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, false>)
2726	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, true>)
2727
2728	// money_get
2729
2730	template <class _CharT>
2731	class __money_get
2732	{
2733	protected:
2734	typedef _CharT char_type;
2735	typedef basic_string<char_type> string_type;
2736
2737	_LIBCPP_INLINE_VISIBILITY __money_get() {}
2738
2739	static void __gather_info(bool __intl, const locale& __loc,
2740	money_base::pattern& __pat, char_type& __dp,
2741	char_type& __ts, string& __grp,
2742	string_type& __sym, string_type& __psn,
2743	string_type& __nsn, int& __fd);
2744	};
2745
2746	template <class _CharT>
2747	void
2748	__money_get<_CharT>::__gather_info(bool __intl, const locale& __loc,
2749	money_base::pattern& __pat, char_type& __dp,
2750	char_type& __ts, string& __grp,
2751	string_type& __sym, string_type& __psn,
2752	string_type& __nsn, int& __fd)
2753	{
2754	if (__intl)
2755	{
2756	const moneypunct<char_type, true>& __mp =
2757	use_facet<moneypunct<char_type, true> >(__loc);
2758	__pat = __mp.neg_format();
2759	__nsn = __mp.negative_sign();
2760	__psn = __mp.positive_sign();
2761	__dp = __mp.decimal_point();
2762	__ts = __mp.thousands_sep();
2763	__grp = __mp.grouping();
2764	__sym = __mp.curr_symbol();
2765	__fd = __mp.frac_digits();
2766	}
2767	else
2768	{
2769	const moneypunct<char_type, false>& __mp =
2770	use_facet<moneypunct<char_type, false> >(__loc);
2771	__pat = __mp.neg_format();
2772	__nsn = __mp.negative_sign();
2773	__psn = __mp.positive_sign();
2774	__dp = __mp.decimal_point();
2775	__ts = __mp.thousands_sep();
2776	__grp = __mp.grouping();
2777	__sym = __mp.curr_symbol();
2778	__fd = __mp.frac_digits();
2779	}
2780	}
2781
2782	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<char>)
2783	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<wchar_t>)
2784
2785	template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
2786	class _LIBCPP_TEMPLATE_VIS money_get
2787	: public locale::facet,
2788	private __money_get<_CharT>
2789	{
2790	public:
2791	typedef _CharT char_type;
2792	typedef _InputIterator iter_type;
2793	typedef basic_string<char_type> string_type;
2794
2795	_LIBCPP_INLINE_VISIBILITY
2796	explicit money_get(size_t __refs = `0`)
2797	: locale::facet(__refs) {}
2798
2799	_LIBCPP_INLINE_VISIBILITY
2800	iter_type get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob,
2801	ios_base::iostate& __err, long double& __v) const
2802	{
2803	return do_get(__b, __e, __intl, __iob, __err, __v);
2804	}
2805
2806	_LIBCPP_INLINE_VISIBILITY
2807	iter_type get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob,
2808	ios_base::iostate& __err, string_type& __v) const
2809	{
2810	return do_get(__b, __e, __intl, __iob, __err, __v);
2811	}
2812
2813	static locale::id id;
2814
2815	protected:
2816
2817	_LIBCPP_INLINE_VISIBILITY
2818	~money_get() {}
2819
2820	virtual iter_type do_get(iter_type __b, iter_type __e, bool __intl,
2821	ios_base& __iob, ios_base::iostate& __err,
2822	long double& __v) const;
2823	virtual iter_type do_get(iter_type __b, iter_type __e, bool __intl,
2824	ios_base& __iob, ios_base::iostate& __err,
2825	string_type& __v) const;
2826
2827	private:
2828	static bool __do_get(iter_type& __b, iter_type __e,
2829	bool __intl, const locale& __loc,
2830	ios_base::fmtflags __flags, ios_base::iostate& __err,
2831	bool& __neg, const ctype<char_type>& __ct,
2832	unique_ptr<char_type, void()(void**)>& __wb,
2833	char_type& __wn, char_type __we);
2834	};
2835
2836	template <class _CharT, class _InputIterator>
2837	locale::id
2838	money_get<_CharT, _InputIterator>::id;
2839
2840	_LIBCPP_FUNC_VIS void __do_nothing(void*);
2841
2842	template <class _Tp>
2843	_LIBCPP_HIDDEN
2844	void
2845	__double_or_nothing(unique_ptr<_Tp, void()(void*)>& __b, _Tp& __n, _Tp*& __e)
2846	{
2847	bool __owns = __b.get_deleter() != __do_nothing;
2848	size_t __cur_cap = static_cast<size_t>(__e-__b.get()) * sizeof(_Tp);
2849	size_t __new_cap = __cur_cap < numeric_limits<size_t>::max() / `2` ?
2850	`2` * __cur_cap : numeric_limits<size_t>::max();
2851	if (__new_cap == `0`)
2852	__new_cap = sizeof(_Tp);
2853	size_t __n_off = static_cast<size_t>(__n - __b.get());
2854	_Tp* __t = (_Tp*)realloc(__owns ? __b.get() : `0`, __new_cap);
2855	if (__t == `0`)
2856	__throw_bad_alloc();
2857	if (__owns)
2858	__b.release();
2859	__b = unique_ptr<_Tp, void()(void**)>(__t, free);
2860	__new_cap /= sizeof(_Tp);
2861	__n = __b.get() + __n_off;
2862	__e = __b.get() + __new_cap;
2863	}
2864
2865	// true == success
2866	template <class _CharT, class _InputIterator>
2867	bool
2868	money_get<_CharT, _InputIterator>::__do_get(iter_type& __b, iter_type __e,
2869	bool __intl, const locale& __loc,
2870	ios_base::fmtflags __flags,
2871	ios_base::iostate& __err,
2872	bool& __neg,
2873	const ctype<char_type>& __ct,
2874	unique_ptr<char_type, void()(void**)>& __wb,
2875	char_type& __wn, char_type __we)
2876	{
2877	const unsigned __bz = `100`;
2878	unsigned __gbuf[__bz];
2879	unique_ptr<unsigned, void()(void**)> __gb(__gbuf, __do_nothing);
2880	unsigned* __gn = __gb.get();
2881	unsigned* __ge = __gn + __bz;
2882	money_base::pattern __pat;
2883	char_type __dp;
2884	char_type __ts;
2885	string __grp;
2886	string_type __sym;
2887	string_type __psn;
2888	string_type __nsn;
2889	// Capture the spaces read into money_base::{space,none} so they
2890	// can be compared to initial spaces in __sym.
2891	string_type __spaces;
2892	int __fd;
2893	__money_get<_CharT>::__gather_info(__intl, __loc, __pat, __dp, __ts, __grp,
2894	__sym, __psn, __nsn, __fd);
2895	const string_type* __trailing_sign = `0`;
2896	__wn = __wb.get();
2897	for (unsigned __p = `0`; __p < `4` && __b != __e; ++__p)
2898	{
2899	switch (__pat.field[__p])
2900	{
2901	case money_base::space:
2902	if (__p != `3`)
2903	{
2904	if (__ct.is(ctype_base::space, *__b))
2905	__spaces.push_back(*__b++);
2906	else
2907	{
2908	__err \|= ios_base::failbit;
2909	return false;
2910	}
2911	}
2912	_LIBCPP_FALLTHROUGH();
2913	case money_base::none:
2914	if (__p != `3`)
2915	{
2916	while (__b != __e && __ct.is(ctype_base::space, *__b))
2917	__spaces.push_back(*__b++);
2918	}
2919	break;
2920	case money_base::sign:
2921	if (__psn.size() + __nsn.size() > `0`)
2922	{
2923	if (__psn.size() == `0` \|\| __nsn.size() == `0`)
2924	{ // sign is optional
2925	if (__psn.size() > `0`)
2926	{ // __nsn.size() == 0
2927	if (*__b == __psn[`0`])
2928	{
2929	++__b;
2930	if (__psn.size() > `1`)
2931	__trailing_sign = &__psn;
2932	}
2933	else
2934	__neg = true;
2935	}
2936	else if (__b == __nsn[`0`]) // __nsn.size() > 0 && __psn.size() == 0*
2937	{
2938	++__b;
2939	__neg = true;
2940	if (__nsn.size() > `1`)
2941	__trailing_sign = &__nsn;
2942	}
2943	}
2944	else // sign is required
2945	{
2946	if (*__b == __psn[`0`])
2947	{
2948	++__b;
2949	if (__psn.size() > `1`)
2950	__trailing_sign = &__psn;
2951	}
2952	else if (*__b == __nsn[`0`])
2953	{
2954	++__b;
2955	__neg = true;
2956	if (__nsn.size() > `1`)
2957	__trailing_sign = &__nsn;
2958	}
2959	else
2960	{
2961	__err \|= ios_base::failbit;
2962	return false;
2963	}
2964	}
2965	}
2966	break;
2967	case money_base::symbol:
2968	{
2969	bool __more_needed = __trailing_sign \|\|
2970	(__p < `2`) \|\|
2971	(__p == `2` && __pat.field[`3`] != static_cast<char>(money_base::none));
2972	bool __sb = (__flags & ios_base::showbase) != `0`;
2973	if (__sb \|\| __more_needed)
2974	{
2975	typename string_type::const_iterator __sym_space_end = __sym.begin();
2976	if (__p > `0` && (__pat.field[__p - `1`] == money_base::none \|\|
2977	__pat.field[__p - `1`] == money_base::space)) {
2978	// Match spaces we've already read against spaces at
2979	// the beginning of __sym.
2980	while (__sym_space_end != __sym.end() &&
2981	__ct.is(ctype_base::space, *__sym_space_end))
2982	++__sym_space_end;
2983	const size_t __num_spaces = __sym_space_end - __sym.begin();
2984	if (__num_spaces > __spaces.size() \|\|
2985	!equal(__spaces.end() - __num_spaces, __spaces.end(),
2986	__sym.begin())) {
2987	// No match. Put __sym_space_end back at the
2988	// beginning of __sym, which will prevent a
2989	// match in the next loop.
2990	__sym_space_end = __sym.begin();
2991	}
2992	}
2993	typename string_type::const_iterator __sym_curr_char = __sym_space_end;
2994	while (__sym_curr_char != __sym.end() && __b != __e &&
2995	__b == __sym_curr_char) {
2996	++__b;
2997	++__sym_curr_char;
2998	}
2999	if (__sb && __sym_curr_char != __sym.end())
3000	{
3001	__err \|= ios_base::failbit;
3002	return false;
3003	}
3004	}
3005	}
3006	break;
3007	case money_base::value:
3008	{
3009	unsigned __ng = `0`;
3010	for (; __b != __e; ++__b)
3011	{
3012	char_type __c = *__b;
3013	if (__ct.is(ctype_base::digit, __c))
3014	{
3015	if (__wn == __we)
3016	__double_or_nothing(__wb, __wn, __we);
3017	*__wn++ = __c;
3018	++__ng;
3019	}
3020	else if (__grp.size() > `0` && __ng > `0` && __c == __ts)
3021	{
3022	if (__gn == __ge)
3023	__double_or_nothing(__gb, __gn, __ge);
3024	*__gn++ = __ng;
3025	__ng = `0`;
3026	}
3027	else
3028	break;
3029	}
3030	if (__gb.get() != __gn && __ng > `0`)
3031	{
3032	if (__gn == __ge)
3033	__double_or_nothing(__gb, __gn, __ge);
3034	*__gn++ = __ng;
3035	}
3036	if (__fd > `0`)
3037	{
3038	if (__b == __e \|\| *__b != __dp)
3039	{
3040	__err \|= ios_base::failbit;
3041	return false;
3042	}
3043	for (++__b; __fd > `0`; --__fd, ++__b)
3044	{
3045	if (__b == __e \|\| !__ct.is(ctype_base::digit, *__b))
3046	{
3047	__err \|= ios_base::failbit;
3048	return false;
3049	}
3050	if (__wn == __we)
3051	__double_or_nothing(__wb, __wn, __we);
3052	__wn++ = __b;
3053	}
3054	}
3055	if (__wn == __wb.get())
3056	{
3057	__err \|= ios_base::failbit;
3058	return false;
3059	}
3060	}
3061	break;
3062	}
3063	}
3064	if (__trailing_sign)
3065	{
3066	for (unsigned __i = `1`; __i < __trailing_sign->size(); ++__i, ++__b)
3067	{
3068	if (__b == __e \|\| __b != (__trailing_sign)[__i])
3069	{
3070	__err \|= ios_base::failbit;
3071	return false;
3072	}
3073	}
3074	}
3075	if (__gb.get() != __gn)
3076	{
3077	ios_base::iostate __et = ios_base::goodbit;
3078	__check_grouping(__grp, __gb.get(), __gn, __et);
3079	if (__et)
3080	{
3081	__err \|= ios_base::failbit;
3082	return false;
3083	}
3084	}
3085	return true;
3086	}
3087
3088	template <class _CharT, class _InputIterator>
3089	_InputIterator
3090	money_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
3091	bool __intl, ios_base& __iob,
3092	ios_base::iostate& __err,
3093	long double& __v) const
3094	{
3095	const int __bz = `100`;
3096	char_type __wbuf[__bz];
3097	unique_ptr<char_type, void()(void**)> __wb(__wbuf, __do_nothing);
3098	char_type* __wn;
3099	char_type* __we = __wbuf + __bz;
3100	locale __loc = __iob.getloc();
3101	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
3102	bool __neg = false;
3103	if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct,
3104	__wb, __wn, __we))
3105	{
3106	const char __src[] = "0123456789";
3107	char_type __atoms[sizeof(__src)-`1`];
3108	__ct.widen(__src, __src + (sizeof(__src)-`1`), __atoms);
3109	char __nbuf[__bz];
3110	char* __nc = __nbuf;
3111	unique_ptr<char, void()(void**)> __h(`0`, free);
3112	if (__wn - __wb.get() > __bz-`2`)
3113	{
3114	__h.reset((char)malloc(static_cast*<size_t>(__wn - __wb.get() + `2`)));
3115	if (__h.get() == `0`)
3116	__throw_bad_alloc();
3117	__nc = __h.get();
3118	}
3119	if (__neg)
3120	*__nc++ = `'-'`;
3121	for (const char_type* __w = __wb.get(); __w < __wn; ++__w, ++__nc)
3122	__nc = __src[find(__atoms, _VSTD::end(__atoms), __w) - __atoms];
3123	__nc = char*();
3124	if (sscanf(__nbuf, "%Lf", &__v) != `1`)
3125	__throw_runtime_error("money_get error");
3126	}
3127	if (__b == __e)
3128	__err \|= ios_base::eofbit;
3129	return __b;
3130	}
3131
3132	template <class _CharT, class _InputIterator>
3133	_InputIterator
3134	money_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
3135	bool __intl, ios_base& __iob,
3136	ios_base::iostate& __err,
3137	string_type& __v) const
3138	{
3139	const int __bz = `100`;
3140	char_type __wbuf[__bz];
3141	unique_ptr<char_type, void()(void**)> __wb(__wbuf, __do_nothing);
3142	char_type* __wn;
3143	char_type* __we = __wbuf + __bz;
3144	locale __loc = __iob.getloc();
3145	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
3146	bool __neg = false;
3147	if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct,
3148	__wb, __wn, __we))
3149	{
3150	__v.clear();
3151	if (__neg)
3152	__v.push_back(__ct.widen(`'-'`));
3153	char_type __z = __ct.widen(`'0'`);
3154	char_type* __w;
3155	for (__w = __wb.get(); __w < __wn-`1`; ++__w)
3156	if (*__w != __z)
3157	break;
3158	__v.append(__w, __wn);
3159	}
3160	if (__b == __e)
3161	__err \|= ios_base::eofbit;
3162	return __b;
3163	}
3164
3165	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<char>)
3166	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<wchar_t>)
3167
3168	// money_put
3169
3170	template <class _CharT>
3171	class __money_put
3172	{
3173	protected:
3174	typedef _CharT char_type;
3175	typedef basic_string<char_type> string_type;
3176
3177	_LIBCPP_INLINE_VISIBILITY __money_put() {}
3178
3179	static void __gather_info(bool __intl, bool __neg, const locale& __loc,
3180	money_base::pattern& __pat, char_type& __dp,
3181	char_type& __ts, string& __grp,
3182	string_type& __sym, string_type& __sn,
3183	int& __fd);
3184	static void __format(char_type* __mb, char_type& __mi, char_type& __me,
3185	ios_base::fmtflags __flags,
3186	const char_type* __db, const char_type* __de,
3187	const ctype<char_type>& __ct, bool __neg,
3188	const money_base::pattern& __pat, char_type __dp,
3189	char_type __ts, const string& __grp,
3190	const string_type& __sym, const string_type& __sn,
3191	int __fd);
3192	};
3193
3194	template <class _CharT>
3195	void
3196	__money_put<_CharT>::__gather_info(bool __intl, bool __neg, const locale& __loc,
3197	money_base::pattern& __pat, char_type& __dp,
3198	char_type& __ts, string& __grp,
3199	string_type& __sym, string_type& __sn,
3200	int& __fd)
3201	{
3202	if (__intl)
3203	{
3204	const moneypunct<char_type, true>& __mp =
3205	use_facet<moneypunct<char_type, true> >(__loc);
3206	if (__neg)
3207	{
3208	__pat = __mp.neg_format();
3209	__sn = __mp.negative_sign();
3210	}
3211	else
3212	{
3213	__pat = __mp.pos_format();
3214	__sn = __mp.positive_sign();
3215	}
3216	__dp = __mp.decimal_point();
3217	__ts = __mp.thousands_sep();
3218	__grp = __mp.grouping();
3219	__sym = __mp.curr_symbol();
3220	__fd = __mp.frac_digits();
3221	}
3222	else
3223	{
3224	const moneypunct<char_type, false>& __mp =
3225	use_facet<moneypunct<char_type, false> >(__loc);
3226	if (__neg)
3227	{
3228	__pat = __mp.neg_format();
3229	__sn = __mp.negative_sign();
3230	}
3231	else
3232	{
3233	__pat = __mp.pos_format();
3234	__sn = __mp.positive_sign();
3235	}
3236	__dp = __mp.decimal_point();
3237	__ts = __mp.thousands_sep();
3238	__grp = __mp.grouping();
3239	__sym = __mp.curr_symbol();
3240	__fd = __mp.frac_digits();
3241	}
3242	}
3243
3244	template <class _CharT>
3245	void
3246	__money_put<_CharT>::__format(char_type* __mb, char_type& __mi, char_type& __me,
3247	ios_base::fmtflags __flags,
3248	const char_type* __db, const char_type* __de,
3249	const ctype<char_type>& __ct, bool __neg,
3250	const money_base::pattern& __pat, char_type __dp,
3251	char_type __ts, const string& __grp,
3252	const string_type& __sym, const string_type& __sn,
3253	int __fd)
3254	{
3255	__me = __mb;
3256	for (unsigned __p = `0`; __p < `4`; ++__p)
3257	{
3258	switch (__pat.field[__p])
3259	{
3260	case money_base::none:
3261	__mi = __me;
3262	break;
3263	case money_base::space:
3264	__mi = __me;
3265	*__me++ = __ct.widen(`' '`);
3266	break;
3267	case money_base::sign:
3268	if (!__sn.empty())
3269	*__me++ = __sn[`0`];
3270	break;
3271	case money_base::symbol:
3272	if (!__sym.empty() && (__flags & ios_base::showbase))
3273	__me = _VSTD::copy(__sym.begin(), __sym.end(), __me);
3274	break;
3275	case money_base::value:
3276	{
3277	// remember start of value so we can reverse it
3278	char_type* __t = __me;
3279	// find beginning of digits
3280	if (__neg)
3281	++__db;
3282	// find end of digits
3283	const char_type* __d;
3284	for (__d = __db; __d < __de; ++__d)
3285	if (!__ct.is(ctype_base::digit, *__d))
3286	break;
3287	// print fractional part
3288	if (__fd > `0`)
3289	{
3290	int __f;
3291	for (__f = __fd; __d > __db && __f > `0`; --__f)
3292	__me++ = --__d;
3293	char_type __z = __f > `0` ? __ct.widen(`'0'`) : char_type();
3294	for (; __f > `0`; --__f)
3295	*__me++ = __z;
3296	*__me++ = __dp;
3297	}
3298	// print units part
3299	if (__d == __db)
3300	{
3301	*__me++ = __ct.widen(`'0'`);
3302	}
3303	else
3304	{
3305	unsigned __ng = `0`;
3306	unsigned __ig = `0`;
3307	unsigned __gl = __grp.empty() ? numeric_limits<unsigned>::max()
3308	: static_cast<unsigned>(__grp [__ig]);
3309	while (__d != __db)
3310	{
3311	if (__ng == __gl)
3312	{
3313	*__me++ = __ts;
3314	__ng = `0`;
3315	if (++__ig < __grp.size())
3316	__gl = __grp [__ig] == numeric_limits<char>::max() ?
3317	numeric_limits<unsigned>::max() :
3318	static_cast<unsigned>(__grp [__ig]);
3319	}
3320	__me++ = --__d;
3321	++__ng;
3322	}
3323	}
3324	// reverse it
3325	reverse(__t, __me);
3326	}
3327	break;
3328	}
3329	}
3330	// print rest of sign, if any
3331	if (__sn.size() > `1`)
3332	__me = _VSTD::copy(__sn.begin()+`1`, __sn.end(), __me);
3333	// set alignment
3334	if ((__flags & ios_base::adjustfield) == ios_base::left)
3335	__mi = __me;
3336	else if ((__flags & ios_base::adjustfield) != ios_base::internal)
3337	__mi = __mb;
3338	}
3339
3340	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<char>)
3341	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<wchar_t>)
3342
3343	template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
3344	class _LIBCPP_TEMPLATE_VIS money_put
3345	: public locale::facet,
3346	private __money_put<_CharT>
3347	{
3348	public:
3349	typedef _CharT char_type;
3350	typedef _OutputIterator iter_type;
3351	typedef basic_string<char_type> string_type;
3352
3353	_LIBCPP_INLINE_VISIBILITY
3354	explicit money_put(size_t __refs = `0`)
3355	: locale::facet(__refs) {}
3356
3357	_LIBCPP_INLINE_VISIBILITY
3358	iter_type put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl,
3359	long double __units) const
3360	{
3361	return do_put(__s, __intl, __iob, __fl, __units);
3362	}
3363
3364	_LIBCPP_INLINE_VISIBILITY
3365	iter_type put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl,
3366	const string_type& __digits) const
3367	{
3368	return do_put(__s, __intl, __iob, __fl, __digits);
3369	}
3370
3371	static locale::id id;
3372
3373	protected:
3374	_LIBCPP_INLINE_VISIBILITY
3375	~money_put() {}
3376
3377	virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob,
3378	char_type __fl, long double __units) const;
3379	virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob,
3380	char_type __fl, const string_type& __digits) const;
3381	};
3382
3383	template <class _CharT, class _OutputIterator>
3384	locale::id
3385	money_put<_CharT, _OutputIterator>::id;
3386
3387	template <class _CharT, class _OutputIterator>
3388	_OutputIterator
3389	money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
3390	ios_base& __iob, char_type __fl,
3391	long double __units) const
3392	{
3393	// convert to char
3394	const size_t __bs = `100`;
3395	char __buf[__bs];
3396	char* __bb = __buf;
3397	char_type __digits[__bs];
3398	char_type* __db = __digits;
3399	size_t __n = static_cast<size_t>(snprintf(__bb, __bs, "%.0Lf", __units));
3400	unique_ptr<char, void()(void**)> __hn(`0`, free);
3401	unique_ptr<char_type, void()(void**)> __hd(`0`, free);
3402	// secure memory for digit storage
3403	if (__n > __bs-`1`)
3404	{
3405	__n = static_cast<size_t>(__libcpp_asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units));
3406	if (__bb == `0`)
3407	__throw_bad_alloc();
3408	__hn.reset(__bb);
3409	__hd.reset((char_type)malloc(__n sizeof(char_type)));
3410	if (__hd == nullptr)
3411	__throw_bad_alloc();
3412	__db = __hd.get();
3413	}
3414	// gather info
3415	locale __loc = __iob.getloc();
3416	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
3417	__ct.widen(__bb, __bb + __n, __db);
3418	bool __neg = __n > `0` && __bb[`0`] == `'-'`;
3419	money_base::pattern __pat;
3420	char_type __dp;
3421	char_type __ts;
3422	string __grp;
3423	string_type __sym;
3424	string_type __sn;
3425	int __fd;
3426	this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
3427	// secure memory for formatting
3428	char_type __mbuf[__bs];
3429	char_type* __mb = __mbuf;
3430	unique_ptr<char_type, void()(void**)> __hw(`0`, free);
3431	size_t __exn = static_cast<int>(__n) > __fd ?
3432	(__n - static_cast<size_t>(__fd)) * `2` + __sn.size() +
3433	__sym.size() + static_cast<size_t>(__fd) + `1`
3434	: __sn.size() + __sym.size() + static_cast<size_t>(__fd) + `2`;
3435	if (__exn > __bs)
3436	{
3437	__hw.reset((char_type)malloc(__exn sizeof(char_type)));
3438	__mb = __hw.get();
3439	if (__mb == `0`)
3440	__throw_bad_alloc();
3441	}
3442	// format
3443	char_type* __mi;
3444	char_type* __me;
3445	this->__format(__mb, __mi, __me, __iob.flags(),
3446	__db, __db + __n, __ct,
3447	__neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
3448	return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
3449	}
3450
3451	template <class _CharT, class _OutputIterator>
3452	_OutputIterator
3453	money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
3454	ios_base& __iob, char_type __fl,
3455	const string_type& __digits) const
3456	{
3457	// gather info
3458	locale __loc = __iob.getloc();
3459	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
3460	bool __neg = __digits.size() > `0` && __digits[`0`] == __ct.widen(`'-'`);
3461	money_base::pattern __pat;
3462	char_type __dp;
3463	char_type __ts;
3464	string __grp;
3465	string_type __sym;
3466	string_type __sn;
3467	int __fd;
3468	this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
3469	// secure memory for formatting
3470	char_type __mbuf[`100`];
3471	char_type* __mb = __mbuf;
3472	unique_ptr<char_type, void()(void**)> __h(`0`, free);
3473	size_t __exn = static_cast<int>(__digits.size()) > __fd ?
3474	(__digits.size() - static_cast<size_t>(__fd)) * `2` +
3475	__sn.size() + __sym.size() + static_cast<size_t>(__fd) + `1`
3476	: __sn.size() + __sym.size() + static_cast<size_t>(__fd) + `2`;
3477	if (__exn > `100`)
3478	{
3479	__h.reset((char_type)malloc(__exn sizeof(char_type)));
3480	__mb = __h.get();
3481	if (__mb == `0`)
3482	__throw_bad_alloc();
3483	}
3484	// format
3485	char_type* __mi;
3486	char_type* __me;
3487	this->__format(__mb, __mi, __me, __iob.flags(),
3488	__digits.data(), __digits.data() + __digits.size(), __ct,
3489	__neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
3490	return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
3491	}
3492
3493	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<char>)
3494	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<wchar_t>)
3495
3496	// messages
3497
3498	class _LIBCPP_TYPE_VIS messages_base
3499	{
3500	public:
3501	typedef ptrdiff_t catalog;
3502
3503	_LIBCPP_INLINE_VISIBILITY messages_base() {}
3504	};
3505
3506	template <class _CharT>
3507	class _LIBCPP_TEMPLATE_VIS messages
3508	: public locale::facet,
3509	public messages_base
3510	{
3511	public:
3512	typedef _CharT char_type;
3513	typedef basic_string<_CharT> string_type;
3514
3515	_LIBCPP_INLINE_VISIBILITY
3516	explicit messages(size_t __refs = `0`)
3517	: locale::facet(__refs) {}
3518
3519	_LIBCPP_INLINE_VISIBILITY
3520	catalog open(const basic_string<char>& __nm, const locale& __loc) const
3521	{
3522	return do_open(__nm, __loc);
3523	}
3524
3525	_LIBCPP_INLINE_VISIBILITY
3526	string_type get(catalog __c, int __set, int __msgid,
3527	const string_type& __dflt) const
3528	{
3529	return do_get(__c, __set, __msgid, __dflt);
3530	}
3531
3532	_LIBCPP_INLINE_VISIBILITY
3533	void close(catalog __c) const
3534	{
3535	do_close(__c);
3536	}
3537
3538	static locale::id id;
3539
3540	protected:
3541	_LIBCPP_INLINE_VISIBILITY
3542	~messages() {}
3543
3544	virtual catalog do_open(const basic_string<char>&, const locale&) const;
3545	virtual string_type do_get(catalog, int __set, int __msgid,
3546	const string_type& __dflt) const;
3547	virtual void do_close(catalog) const;
3548	};
3549
3550	template <class _CharT>
3551	locale::id
3552	messages<_CharT>::id;
3553
3554	template <class _CharT>
3555	typename messages<_CharT>::catalog
3556	messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const
3557	{
3558	#ifdef _LIBCPP_HAS_CATOPEN
3559	catalog __cat = (catalog)catopen(__nm.c_str(), NL_CAT_LOCALE);
3560	if (__cat != -`1`)
3561	__cat = static_cast<catalog>((static_cast<size_t>(__cat) >> `1`));
3562	return __cat;
3563	#else // !_LIBCPP_HAS_CATOPEN
3564	_LIBCPP_UNUSED_VAR(__nm);
3565	return -`1`;
3566	#endif // _LIBCPP_HAS_CATOPEN
3567	}
3568
3569	template <class _CharT>
3570	typename messages<_CharT>::string_type
3571	messages<_CharT>::do_get(catalog __c, int __set, int __msgid,
3572	const string_type& __dflt) const
3573	{
3574	#ifdef _LIBCPP_HAS_CATOPEN
3575	string __ndflt;
3576	__narrow_to_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__ndflt),
3577	__dflt.c_str(),
3578	__dflt.c_str() + __dflt.size());
3579	if (__c != -`1`)
3580	__c <<= `1`;
3581	nl_catd __cat = (nl_catd)__c;
3582	char* __n = catgets(__cat, __set, __msgid, __ndflt.c_str());
3583	string_type __w;
3584	__widen_from_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__w),
3585	__n, __n + strlen(__n));
3586	return __w;
3587	#else // !_LIBCPP_HAS_CATOPEN
3588	_LIBCPP_UNUSED_VAR(__c);
3589	_LIBCPP_UNUSED_VAR(__set);
3590	_LIBCPP_UNUSED_VAR(__msgid);
3591	return __dflt;
3592	#endif // _LIBCPP_HAS_CATOPEN
3593	}
3594
3595	template <class _CharT>
3596	void
3597	messages<_CharT>::do_close(catalog __c) const
3598	{
3599	#ifdef _LIBCPP_HAS_CATOPEN
3600	if (__c != -`1`)
3601	__c <<= `1`;
3602	nl_catd __cat = (nl_catd)__c;
3603	catclose(__cat);
3604	#else // !_LIBCPP_HAS_CATOPEN
3605	_LIBCPP_UNUSED_VAR(__c);
3606	#endif // _LIBCPP_HAS_CATOPEN
3607	}
3608
3609	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<char>)
3610	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<wchar_t>)
3611
3612	template <class _CharT>
3613	class _LIBCPP_TEMPLATE_VIS messages_byname
3614	: public messages<_CharT>
3615	{
3616	public:
3617	typedef messages_base::catalog catalog;
3618	typedef basic_string<_CharT> string_type;
3619
3620	_LIBCPP_INLINE_VISIBILITY
3621	explicit messages_byname(const char*, size_t __refs = `0`)
3622	: messages<_CharT>(__refs) {}
3623
3624	_LIBCPP_INLINE_VISIBILITY
3625	explicit messages_byname(const string&, size_t __refs = `0`)
3626	: messages<_CharT>(__refs) {}
3627
3628	protected:
3629	_LIBCPP_INLINE_VISIBILITY
3630	~messages_byname() {}
3631	};
3632
3633	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<char>)
3634	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<wchar_t>)
3635
3636	template<class _Codecvt, class _Elem = wchar_t,
3637	class _Wide_alloc = allocator<_Elem>,
3638	class _Byte_alloc = allocator<char> >
3639	class _LIBCPP_TEMPLATE_VIS wstring_convert
3640	{
3641	public:
3642	typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
3643	typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
3644	typedef typename _Codecvt::state_type state_type;
3645	typedef typename wide_string::traits_type::int_type int_type;
3646
3647	private:
3648	byte_string __byte_err_string_;
3649	wide_string __wide_err_string_;
3650	_Codecvt* __cvtptr_;
3651	state_type __cvtstate_;
3652	size_t __cvtcount_;
3653
3654	wstring_convert(const wstring_convert& __wc);
3655	wstring_convert& operator=(const wstring_convert& __wc);
3656	public:
3657	_LIBCPP_INLINE_VISIBILITY
3658	_LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(_Codecvt* __pcvt = new _Codecvt);
3659	_LIBCPP_INLINE_VISIBILITY
3660	wstring_convert(_Codecvt* __pcvt, state_type __state);
3661	_LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(const byte_string& __byte_err,
3662	const wide_string& __wide_err = wide_string());
3663	#ifndef _LIBCPP_CXX03_LANG
3664	_LIBCPP_INLINE_VISIBILITY
3665	wstring_convert(wstring_convert&& __wc);
3666	#endif
3667	~wstring_convert();
3668
3669	_LIBCPP_INLINE_VISIBILITY
3670	wide_string from_bytes(char __byte)
3671	{return from_bytes(&__byte, &__byte+`1`);}
3672	_LIBCPP_INLINE_VISIBILITY
3673	wide_string from_bytes(const char* __ptr)
3674	{return from_bytes(__ptr, __ptr + char_traits<char>::length(__ptr));}
3675	_LIBCPP_INLINE_VISIBILITY
3676	wide_string from_bytes(const byte_string& __str)
3677	{return from_bytes(__str.data(), __str.data() + __str.size());}
3678	wide_string from_bytes(const char* __first, const char* __last);
3679
3680	_LIBCPP_INLINE_VISIBILITY
3681	byte_string to_bytes(_Elem __wchar)
3682	{return to_bytes(&__wchar, &__wchar+`1`);}
3683	_LIBCPP_INLINE_VISIBILITY
3684	byte_string to_bytes(const _Elem* __wptr)
3685	{return to_bytes(__wptr, __wptr + char_traits<_Elem>::length(__wptr));}
3686	_LIBCPP_INLINE_VISIBILITY
3687	byte_string to_bytes(const wide_string& __wstr)
3688	{return to_bytes(__wstr.data(), __wstr.data() + __wstr.size());}
3689	byte_string to_bytes(const _Elem* __first, const _Elem* __last);
3690
3691	_LIBCPP_INLINE_VISIBILITY
3692	size_t converted() const _NOEXCEPT {return __cvtcount_;}
3693	_LIBCPP_INLINE_VISIBILITY
3694	state_type state() const {return __cvtstate_;}
3695	};
3696
3697	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
3698	inline
3699	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
3700	wstring_convert(_Codecvt* __pcvt)
3701	: __cvtptr_(__pcvt), __cvtstate_(), __cvtcount_(`0`)
3702	{
3703	}
3704
3705	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
3706	inline
3707	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
3708	wstring_convert(_Codecvt* __pcvt, state_type __state)
3709	: __cvtptr_(__pcvt), __cvtstate_(__state), __cvtcount_(`0`)
3710	{
3711	}
3712
3713	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
3714	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
3715	wstring_convert(const byte_string& __byte_err, const wide_string& __wide_err)
3716	: __byte_err_string_(__byte_err), __wide_err_string_(__wide_err),
3717	__cvtstate_(), __cvtcount_(`0`)
3718	{
3719	__cvtptr_ = new _Codecvt;
3720	}
3721
3722	#ifndef _LIBCPP_CXX03_LANG
3723
3724	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
3725	inline
3726	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
3727	wstring_convert(wstring_convert&& __wc)
3728	: __byte_err_string_(_VSTD::move(__wc.__byte_err_string_)),
3729	__wide_err_string_(_VSTD::move(__wc.__wide_err_string_)),
3730	__cvtptr_(__wc.__cvtptr_),
3731	__cvtstate_(__wc.__cvtstate_), __cvtcount_(__wc.__cvtcount_)
3732	{
3733	__wc.__cvtptr_ = nullptr;
3734	}
3735
3736	#endif // _LIBCPP_CXX03_LANG
3737
3738	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
3739	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::~wstring_convert()
3740	{
3741	delete __cvtptr_;
3742	}
3743
3744	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
3745	typename wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::wide_string
3746	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
3747	from_bytes(const char* __frm, const char* __frm_end)
3748	{
3749	__cvtcount_ = `0`;
3750	if (__cvtptr_ != nullptr)
3751	{
3752	wide_string __ws(`2`*(__frm_end - __frm), _Elem());
3753	if (__frm != __frm_end)
3754	__ws.resize(__ws.capacity());
3755	codecvt_base::result __r = codecvt_base::ok;
3756	state_type __st = __cvtstate_;
3757	if (__frm != __frm_end)
3758	{
3759	_Elem* __to = &__ws[`0`];
3760	_Elem* __to_end = __to + __ws.size();
3761	const char* __frm_nxt;
3762	do
3763	{
3764	_Elem* __to_nxt;
3765	__r = __cvtptr_->in(__st, __frm, __frm_end, __frm_nxt,
3766	__to, __to_end, __to_nxt);
3767	__cvtcount_ += __frm_nxt - __frm;
3768	if (__frm_nxt == __frm)
3769	{
3770	__r = codecvt_base::error;
3771	}
3772	else if (__r == codecvt_base::noconv)
3773	{
3774	__ws.resize(__to - &__ws[`0`]);
3775	// This only gets executed if _Elem is char
3776	__ws.append((const _Elem)__frm, (const* _Elem*)__frm_end);
3777	__frm = __frm_nxt;
3778	__r = codecvt_base::ok;
3779	}
3780	else if (__r == codecvt_base::ok)
3781	{
3782	__ws.resize(__to_nxt - &__ws[`0`]);
3783	__frm = __frm_nxt;
3784	}
3785	else if (__r == codecvt_base::partial)
3786	{
3787	ptrdiff_t __s = __to_nxt - &__ws[`0`];
3788	__ws.resize(`2` * __s);
3789	__to = &__ws[`0`] + __s;
3790	__to_end = &__ws[`0`] + __ws.size();
3791	__frm = __frm_nxt;
3792	}
3793	} while (__r == codecvt_base::partial && __frm_nxt < __frm_end);
3794	}
3795	if (__r == codecvt_base::ok)
3796	return __ws;
3797	}
3798
3799	if (__wide_err_string_.empty())
3800	__throw_range_error("wstring_convert: from_bytes error");
3801
3802	return __wide_err_string_;
3803	}
3804
3805	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
3806	typename wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::byte_string
3807	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
3808	to_bytes(const _Elem* __frm, const _Elem* __frm_end)
3809	{
3810	__cvtcount_ = `0`;
3811	if (__cvtptr_ != nullptr)
3812	{
3813	byte_string __bs(`2`(__frm_end - __frm), char*());
3814	if (__frm != __frm_end)
3815	__bs.resize(__bs.capacity());
3816	codecvt_base::result __r = codecvt_base::ok;
3817	state_type __st = __cvtstate_;
3818	if (__frm != __frm_end)
3819	{
3820	char* __to = &__bs[`0`];
3821	char* __to_end = __to + __bs.size();
3822	const _Elem* __frm_nxt;
3823	do
3824	{
3825	char* __to_nxt;
3826	__r = __cvtptr_->out(__st, __frm, __frm_end, __frm_nxt,
3827	__to, __to_end, __to_nxt);
3828	__cvtcount_ += __frm_nxt - __frm;
3829	if (__frm_nxt == __frm)
3830	{
3831	__r = codecvt_base::error;
3832	}
3833	else if (__r == codecvt_base::noconv)
3834	{
3835	__bs.resize(__to - &__bs[`0`]);
3836	// This only gets executed if _Elem is char
3837	__bs.append((const char)__frm, (const* char*)__frm_end);
3838	__frm = __frm_nxt;
3839	__r = codecvt_base::ok;
3840	}
3841	else if (__r == codecvt_base::ok)
3842	{
3843	__bs.resize(__to_nxt - &__bs[`0`]);
3844	__frm = __frm_nxt;
3845	}
3846	else if (__r == codecvt_base::partial)
3847	{
3848	ptrdiff_t __s = __to_nxt - &__bs[`0`];
3849	__bs.resize(`2` * __s);
3850	__to = &__bs[`0`] + __s;
3851	__to_end = &__bs[`0`] + __bs.size();
3852	__frm = __frm_nxt;
3853	}
3854	} while (__r == codecvt_base::partial && __frm_nxt < __frm_end);
3855	}
3856	if (__r == codecvt_base::ok)
3857	{
3858	size_t __s = __bs.size();
3859	__bs.resize(__bs.capacity());
3860	char* __to = &__bs[`0`] + __s;
3861	char* __to_end = __to + __bs.size();
3862	do
3863	{
3864	char* __to_nxt;
3865	__r = __cvtptr_->unshift(__st, __to, __to_end, __to_nxt);
3866	if (__r == codecvt_base::noconv)
3867	{
3868	__bs.resize(__to - &__bs[`0`]);
3869	__r = codecvt_base::ok;
3870	}
3871	else if (__r == codecvt_base::ok)
3872	{
3873	__bs.resize(__to_nxt - &__bs[`0`]);
3874	}
3875	else if (__r == codecvt_base::partial)
3876	{
3877	ptrdiff_t __sp = __to_nxt - &__bs[`0`];
3878	__bs.resize(`2` * __sp);
3879	__to = &__bs[`0`] + __sp;
3880	__to_end = &__bs[`0`] + __bs.size();
3881	}
3882	} while (__r == codecvt_base::partial);
3883	if (__r == codecvt_base::ok)
3884	return __bs;
3885	}
3886	}
3887
3888	if (__byte_err_string_.empty())
3889	__throw_range_error("wstring_convert: to_bytes error");
3890
3891	return __byte_err_string_;
3892	}
3893
3894	template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> >
3895	class _LIBCPP_TEMPLATE_VIS wbuffer_convert
3896	: public basic_streambuf<_Elem, _Tr>
3897	{
3898	public:
3899	// types:
3900	typedef _Elem char_type;
3901	typedef _Tr traits_type;
3902	typedef typename traits_type::int_type int_type;
3903	typedef typename traits_type::pos_type pos_type;
3904	typedef typename traits_type::off_type off_type;
3905	typedef typename _Codecvt::state_type state_type;
3906
3907	private:
3908	char* __extbuf_;
3909	const char* __extbufnext_;
3910	const char* __extbufend_;
3911	char __extbuf_min_[`8`];
3912	size_t __ebs_;
3913	char_type* __intbuf_;
3914	size_t __ibs_;
3915	streambuf* __bufptr_;
3916	_Codecvt* __cv_;
3917	state_type __st_;
3918	ios_base::openmode __cm_;
3919	bool __owns_eb_;
3920	bool __owns_ib_;
3921	bool __always_noconv_;
3922
3923	wbuffer_convert(const wbuffer_convert&);
3924	wbuffer_convert& operator=(const wbuffer_convert&);
3925	public:
3926	_LIBCPP_EXPLICIT_AFTER_CXX11 wbuffer_convert(streambuf* __bytebuf = `0`,
3927	_Codecvt* __pcvt = new _Codecvt, state_type __state = state_type());
3928	~wbuffer_convert();
3929
3930	_LIBCPP_INLINE_VISIBILITY
3931	streambuf* rdbuf() const {return __bufptr_;}
3932	_LIBCPP_INLINE_VISIBILITY
3933	streambuf* rdbuf(streambuf* __bytebuf)
3934	{
3935	streambuf* __r = __bufptr_;
3936	__bufptr_ = __bytebuf;
3937	return __r;
3938	}
3939
3940	_LIBCPP_INLINE_VISIBILITY
3941	state_type state() const {return __st_;}
3942
3943	protected:
3944	virtual int_type underflow();
3945	virtual int_type pbackfail(int_type __c = traits_type::eof());
3946	virtual int_type overflow (int_type __c = traits_type::eof());
3947	virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s,
3948	streamsize __n);
3949	virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
3950	ios_base::openmode __wch = ios_base::in \| ios_base::out);
3951	virtual pos_type seekpos(pos_type __sp,
3952	ios_base::openmode __wch = ios_base::in \| ios_base::out);
3953	virtual int sync();
3954
3955	private:
3956	bool __read_mode();
3957	void __write_mode();
3958	wbuffer_convert* __close();
3959	};
3960
3961	template <class _Codecvt, class _Elem, class _Tr>
3962	wbuffer_convert<_Codecvt, _Elem, _Tr>::
3963	wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt, state_type __state)
3964	: __extbuf_(`0`),
3965	__extbufnext_(`0`),
3966	__extbufend_(`0`),
3967	__ebs_(`0`),
3968	__intbuf_(`0`),
3969	__ibs_(`0`),
3970	__bufptr_(__bytebuf),
3971	__cv_(__pcvt),
3972	__st_(__state),
3973	__cm_(`0`),
3974	__owns_eb_(false),
3975	__owns_ib_(false),
3976	__always_noconv_(__cv_ ? __cv_->always_noconv() : false)
3977	{
3978	setbuf(`0`, `4096`);
3979	}
3980
3981	template <class _Codecvt, class _Elem, class _Tr>
3982	wbuffer_convert<_Codecvt, _Elem, _Tr>::~wbuffer_convert()
3983	{
3984	__close();
3985	delete __cv_;
3986	if (__owns_eb_)
3987	delete [] __extbuf_;
3988	if (__owns_ib_)
3989	delete [] __intbuf_;
3990	}
3991
3992	template <class _Codecvt, class _Elem, class _Tr>
3993	typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
3994	wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow()
3995	{
3996	if (__cv_ == `0` \|\| __bufptr_ == `0`)
3997	return traits_type::eof();
3998	bool __initial = __read_mode();
3999	char_type __1buf;
4000	if (this->gptr() == `0`)
4001	this->setg(&__1buf, &__1buf+`1`, &__1buf+`1`);
4002	const size_t __unget_sz = __initial ? `0` : min<size_t>((this->egptr() - this->eback()) / `2`, `4`);
4003	int_type __c = traits_type::eof();
4004	if (this->gptr() == this->egptr())
4005	{
4006	memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type));
4007	if (__always_noconv_)
4008	{
4009	streamsize __nmemb = static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz);
4010	__nmemb = __bufptr_->sgetn((char)this*->eback() + __unget_sz, __nmemb);
4011	if (__nmemb != `0`)
4012	{
4013	this->setg(this->eback(),
4014	this->eback() + __unget_sz,
4015	this->eback() + __unget_sz + __nmemb);
4016	__c = *this->gptr();
4017	}
4018	}
4019	else
4020	{
4021	_LIBCPP_ASSERT(!(__extbufnext_ == NULL && (__extbufend_ != __extbufnext_)), "underflow moving from NULL" );
4022	if (__extbufend_ != __extbufnext_)
4023	memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
4024	__extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
4025	__extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
4026	streamsize __nmemb = _VSTD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
4027	static_cast<streamsize>(__extbufend_ - __extbufnext_));
4028	codecvt_base::result __r;
4029	// FIXME: Do we ever need to restore the state here?
4030	//state_type __svs = __st_;
4031	streamsize __nr = __bufptr_->sgetn(const_cast<char*>(__extbufnext_), __nmemb);
4032	if (__nr != `0`)
4033	{
4034	__extbufend_ = __extbufnext_ + __nr;
4035	char_type* __inext;
4036	__r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_,
4037	this->eback() + __unget_sz,
4038	this->egptr(), __inext);
4039	if (__r == codecvt_base::noconv)
4040	{
4041	this->setg((char_type)__extbuf_, (char_type)__extbuf_,
4042	(char_type) const_cast<char* *>(__extbufend_));
4043	__c = *this->gptr();
4044	}
4045	else if (__inext != this->eback() + __unget_sz)
4046	{
4047	this->setg(this->eback(), this->eback() + __unget_sz, __inext);
4048	__c = *this->gptr();
4049	}
4050	}
4051	}
4052	}
4053	else
4054	__c = *this->gptr();
4055	if (this->eback() == &__1buf)
4056	this->setg(`0`, `0`, `0`);
4057	return __c;
4058	}
4059
4060	template <class _Codecvt, class _Elem, class _Tr>
4061	typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
4062	wbuffer_convert<_Codecvt, _Elem, _Tr>::pbackfail(int_type __c)
4063	{
4064	if (__cv_ != `0` && __bufptr_ != `0` && this->eback() < this->gptr())
4065	{
4066	if (traits_type::eq_int_type(__c, traits_type::eof()))
4067	{
4068	this->gbump(-`1`);
4069	return traits_type::not_eof(__c);
4070	}
4071	if (traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-`1`]))
4072	{
4073	this->gbump(-`1`);
4074	*this->gptr() = traits_type::to_char_type(__c);
4075	return __c;
4076	}
4077	}
4078	return traits_type::eof();
4079	}
4080
4081	template <class _Codecvt, class _Elem, class _Tr>
4082	typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
4083	wbuffer_convert<_Codecvt, _Elem, _Tr>::overflow(int_type __c)
4084	{
4085	if (__cv_ == `0` \|\| __bufptr_ == `0`)
4086	return traits_type::eof();
4087	__write_mode();
4088	char_type __1buf;
4089	char_type* __pb_save = this->pbase();
4090	char_type* __epb_save = this->epptr();
4091	if (!traits_type::eq_int_type(__c, traits_type::eof()))
4092	{
4093	if (this->pptr() == `0`)
4094	this->setp(&__1buf, &__1buf+`1`);
4095	*this->pptr() = traits_type::to_char_type(__c);
4096	this->pbump(`1`);
4097	}
4098	if (this->pptr() != this->pbase())
4099	{
4100	if (__always_noconv_)
4101	{
4102	streamsize __nmemb = static_cast<streamsize>(this->pptr() - this->pbase());
4103	if (__bufptr_->sputn((const char)this*->pbase(), __nmemb) != __nmemb)
4104	return traits_type::eof();
4105	}
4106	else
4107	{
4108	char* __extbe = __extbuf_;
4109	codecvt_base::result __r;
4110	do
4111	{
4112	const char_type* __e;
4113	__r = __cv_->out(__st_, this->pbase(), this->pptr(), __e,
4114	__extbuf_, __extbuf_ + __ebs_, __extbe);
4115	if (__e == this->pbase())
4116	return traits_type::eof();
4117	if (__r == codecvt_base::noconv)
4118	{
4119	streamsize __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
4120	if (__bufptr_->sputn((const char)this*->pbase(), __nmemb) != __nmemb)
4121	return traits_type::eof();
4122	}
4123	else if (__r == codecvt_base::ok \|\| __r == codecvt_base::partial)
4124	{
4125	streamsize __nmemb = static_cast<size_t>(__extbe - __extbuf_);
4126	if (__bufptr_->sputn(__extbuf_, __nmemb) != __nmemb)
4127	return traits_type::eof();
4128	if (__r == codecvt_base::partial)
4129	{
4130	this->setp(const_cast<char_type >(__e), this*->pptr());
4131	this->__pbump(this->epptr() - this->pbase());
4132	}
4133	}
4134	else
4135	return traits_type::eof();
4136	} while (__r == codecvt_base::partial);
4137	}
4138	this->setp(__pb_save, __epb_save);
4139	}
4140	return traits_type::not_eof(__c);
4141	}
4142
4143	template <class _Codecvt, class _Elem, class _Tr>
4144	basic_streambuf<_Elem, _Tr>*
4145	wbuffer_convert<_Codecvt, _Elem, _Tr>::setbuf(char_type* __s, streamsize __n)
4146	{
4147	this->setg(`0`, `0`, `0`);
4148	this->setp(`0`, `0`);
4149	if (__owns_eb_)
4150	delete [] __extbuf_;
4151	if (__owns_ib_)
4152	delete [] __intbuf_;
4153	__ebs_ = __n;
4154	if (__ebs_ > sizeof(__extbuf_min_))
4155	{
4156	if (__always_noconv_ && __s)
4157	{
4158	__extbuf_ = (char*)__s;
4159	__owns_eb_ = false;
4160	}
4161	else
4162	{
4163	__extbuf_ = new char[__ebs_];
4164	__owns_eb_ = true;
4165	}
4166	}
4167	else
4168	{
4169	__extbuf_ = __extbuf_min_;
4170	__ebs_ = sizeof(__extbuf_min_);
4171	__owns_eb_ = false;
4172	}
4173	if (!__always_noconv_)
4174	{
4175	__ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_));
4176	if (__s && __ibs_ >= sizeof(__extbuf_min_))
4177	{
4178	__intbuf_ = __s;
4179	__owns_ib_ = false;
4180	}
4181	else
4182	{
4183	__intbuf_ = new char_type[__ibs_];
4184	__owns_ib_ = true;
4185	}
4186	}
4187	else
4188	{
4189	__ibs_ = `0`;
4190	__intbuf_ = `0`;
4191	__owns_ib_ = false;
4192	}
4193	return this;
4194	}
4195
4196	template <class _Codecvt, class _Elem, class _Tr>
4197	typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type
4198	wbuffer_convert<_Codecvt, _Elem, _Tr>::seekoff(off_type __off, ios_base::seekdir __way,
4199	ios_base::openmode __om)
4200	{
4201	int __width = __cv_->encoding();
4202	if (__cv_ == `0` \|\| __bufptr_ == `0` \|\| (__width <= `0` && __off != `0`) \|\| sync())
4203	return pos_type(off_type(-`1`));
4204	// __width > 0 \|\| __off == 0, now check __way
4205	if (__way != ios_base::beg && __way != ios_base::cur && __way != ios_base::end)
4206	return pos_type(off_type(-`1`));
4207	pos_type __r = __bufptr_->pubseekoff(__width * __off, __way, __om);
4208	__r.state(__st_);
4209	return __r;
4210	}
4211
4212	template <class _Codecvt, class _Elem, class _Tr>
4213	typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type
4214	wbuffer_convert<_Codecvt, _Elem, _Tr>::seekpos(pos_type __sp, ios_base::openmode __wch)
4215	{
4216	if (__cv_ == `0` \|\| __bufptr_ == `0` \|\| sync())
4217	return pos_type(off_type(-`1`));
4218	if (__bufptr_->pubseekpos(__sp, __wch) == pos_type(off_type(-`1`)))
4219	return pos_type(off_type(-`1`));
4220	return __sp;
4221	}
4222
4223	template <class _Codecvt, class _Elem, class _Tr>
4224	int
4225	wbuffer_convert<_Codecvt, _Elem, _Tr>::sync()
4226	{
4227	if (__cv_ == `0` \|\| __bufptr_ == `0`)
4228	return `0`;
4229	if (__cm_ & ios_base::out)
4230	{
4231	if (this->pptr() != this->pbase())
4232	if (overflow() == traits_type::eof())
4233	return -`1`;
4234	codecvt_base::result __r;
4235	do
4236	{
4237	char* __extbe;
4238	__r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe);
4239	streamsize __nmemb = static_cast<streamsize>(__extbe - __extbuf_);
4240	if (__bufptr_->sputn(__extbuf_, __nmemb) != __nmemb)
4241	return -`1`;
4242	} while (__r == codecvt_base::partial);
4243	if (__r == codecvt_base::error)
4244	return -`1`;
4245	if (__bufptr_->pubsync())
4246	return -`1`;
4247	}
4248	else if (__cm_ & ios_base::in)
4249	{
4250	off_type __c;
4251	if (__always_noconv_)
4252	__c = this->egptr() - this->gptr();
4253	else
4254	{
4255	int __width = __cv_->encoding();
4256	__c = __extbufend_ - __extbufnext_;
4257	if (__width > `0`)
4258	__c += __width * (this->egptr() - this->gptr());
4259	else
4260	{
4261	if (this->gptr() != this->egptr())
4262	{
4263	reverse(this->gptr(), this->egptr());
4264	codecvt_base::result __r;
4265	const char_type* __e = this->gptr();
4266	char* __extbe;
4267	do
4268	{
4269	__r = __cv_->out(__st_, __e, this->egptr(), __e,
4270	__extbuf_, __extbuf_ + __ebs_, __extbe);
4271	switch (__r)
4272	{
4273	case codecvt_base::noconv:
4274	__c += this->egptr() - this->gptr();
4275	break;
4276	case codecvt_base::ok:
4277	case codecvt_base::partial:
4278	__c += __extbe - __extbuf_;
4279	break;
4280	default:
4281	return -`1`;
4282	}
4283	} while (__r == codecvt_base::partial);
4284	}
4285	}
4286	}
4287	if (__bufptr_->pubseekoff(-__c, ios_base::cur, __cm_) == pos_type(off_type(-`1`)))
4288	return -`1`;
4289	this->setg(`0`, `0`, `0`);
4290	__cm_ = `0`;
4291	}
4292	return `0`;
4293	}
4294
4295	template <class _Codecvt, class _Elem, class _Tr>
4296	bool
4297	wbuffer_convert<_Codecvt, _Elem, _Tr>::__read_mode()
4298	{
4299	if (!(__cm_ & ios_base::in))
4300	{
4301	this->setp(`0`, `0`);
4302	if (__always_noconv_)
4303	this->setg((char_type*)__extbuf_,
4304	(char_type*)__extbuf_ + __ebs_,
4305	(char_type*)__extbuf_ + __ebs_);
4306	else
4307	this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_);
4308	__cm_ = ios_base::in;
4309	return true;
4310	}
4311	return false;
4312	}
4313
4314	template <class _Codecvt, class _Elem, class _Tr>
4315	void
4316	wbuffer_convert<_Codecvt, _Elem, _Tr>::__write_mode()
4317	{
4318	if (!(__cm_ & ios_base::out))
4319	{
4320	this->setg(`0`, `0`, `0`);
4321	if (__ebs_ > sizeof(__extbuf_min_))
4322	{
4323	if (__always_noconv_)
4324	this->setp((char_type*)__extbuf_,
4325	(char_type*)__extbuf_ + (__ebs_ - `1`));
4326	else
4327	this->setp(__intbuf_, __intbuf_ + (__ibs_ - `1`));
4328	}
4329	else
4330	this->setp(`0`, `0`);
4331	__cm_ = ios_base::out;
4332	}
4333	}
4334
4335	template <class _Codecvt, class _Elem, class _Tr>
4336	wbuffer_convert<_Codecvt, _Elem, _Tr>*
4337	wbuffer_convert<_Codecvt, _Elem, _Tr>::__close()
4338	{
4339	wbuffer_convert* __rt = `0`;
4340	if (__cv_ != `0` && __bufptr_ != `0`)
4341	{
4342	__rt = this;
4343	if ((__cm_ & ios_base::out) && sync())
4344	__rt = `0`;
4345	}
4346	return __rt;
4347	}
4348
4349	_LIBCPP_END_NAMESPACE_STD
4350
4351	_LIBCPP_POP_MACROS
4352
4353	#endif // _LIBCPP_LOCALE
4354

Browse the source code of ClickHouse/contrib/libcxx/include/locale