locale_facets.h source code [include/c++/11/bits/locale_facets.h]

1	// Locale support -- C++ --
2
3	// Copyright (C) 1997-2021 Free Software Foundation, Inc.
4	//
5	// This file is part of the GNU ISO C++ Library. This library is free
6	// software; you can redistribute it and/or modify it under the
7	// terms of the GNU General Public License as published by the
8	// Free Software Foundation; either version 3, or (at your option)
9	// any later version.
10
11	// This library is distributed in the hope that it will be useful,
12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	// GNU General Public License for more details.
15
16	// Under Section 7 of GPL version 3, you are granted additional
17	// permissions described in the GCC Runtime Library Exception, version
18	// 3.1, as published by the Free Software Foundation.
19
20	// You should have received a copy of the GNU General Public License and
21	// a copy of the GCC Runtime Library Exception along with this program;
22	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23	// <http://www.gnu.org/licenses/>.
24
25	/* @file bits/locale_facets.h*
26	* This is an internal header file, included by other library headers.
27	* Do not attempt to use it directly. @headername{locale}
28	*/
29
30	//
31	// ISO C++ 14882: 22.1 Locales
32	//
33
34	#ifndef _LOCALE_FACETS_H
35	#define _LOCALE_FACETS_H 1
36
37	#pragma GCC system_header
38
39	#include <cwctype> // For wctype_t
40	#include <cctype>
41	#include <bits/ctype_base.h>
42	#include <iosfwd>
43	#include <bits/ios_base.h> // For ios_base, ios_base::iostate
44	#include <streambuf>
45	#include <bits/cpp_type_traits.h>
46	#include <ext/type_traits.h>
47	#include <ext/numeric_traits.h>
48	#include <bits/streambuf_iterator.h>
49
50	namespace std _GLIBCXX_VISIBILITY(default)
51	{
52	_GLIBCXX_BEGIN_NAMESPACE_VERSION
53
54	// Number of standard facets (for narrow characters only)
55	#define _GLIBCXX_NUM_FACETS 14
56
57	// Number of duplicated facets for cxx11 ABI
58	#define _GLIBCXX_NUM_CXX11_FACETS (_GLIBCXX_USE_DUAL_ABI ? 8 : 0)
59
60	// codecvt<char16_t> and codecvt<char32_t>
61	#ifdef _GLIBCXX_USE_CHAR8_T
62	# define _GLIBCXX_NUM_UNICODE_FACETS 4
63	#else
64	# define _GLIBCXX_NUM_UNICODE_FACETS 2
65	#endif
66
67	// Facets duplicated for alt128 long double format
68	// num_get, num_put, money_get, money_put (+ cxx11 money_get, money_put)
69	#define _GLIBCXX_NUM_LBDL_ALT128_FACETS (4 + (_GLIBCXX_USE_DUAL_ABI ? 2 : 0))
70
71	// Convert string to numeric value of type _Tp and store results.
72	// NB: This is specialized for all required types, there is no
73	// generic definition.
74	template<typename _Tp>
75	void
76	__convert_to_v(const char*, _Tp&, ios_base::iostate&,
77	const __c_locale&) throw();
78
79	// Explicit specializations for required types.
80	template<>
81	void
82	__convert_to_v(const char, float*&, ios_base::iostate&,
83	const __c_locale&) throw();
84
85	template<>
86	void
87	__convert_to_v(const char, double*&, ios_base::iostate&,
88	const __c_locale&) throw();
89
90	template<>
91	void
92	__convert_to_v(const char, long* double&, ios_base::iostate&,
93	const __c_locale&) throw();
94
95	// NB: __pad is a struct, rather than a function, so it can be
96	// partially-specialized.
97	template<typename _CharT, typename _Traits>
98	struct __pad
99	{
100	static void
101	_S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
102	const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
103	};
104
105	// Used by both numeric and monetary facets.
106	// Inserts "group separator" characters into an array of characters.
107	// It's recursive, one iteration per group. It moves the characters
108	// in the buffer this way: "xxxx12345" -> "12,345xxx". Call this
109	// only with __gsize != 0.
110	template<typename _CharT>
111	_CharT*
112	__add_grouping(_CharT* __s, _CharT __sep,
113	const char* __gbeg, size_t __gsize,
114	const _CharT* __first, const _CharT* __last);
115
116	// This template permits specializing facet output code for
117	// ostreambuf_iterator. For ostreambuf_iterator, sputn is
118	// significantly more efficient than incrementing iterators.
119	template<typename _CharT>
120	inline
121	ostreambuf_iterator<_CharT>
122	__write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
123	{
124	__s._M_put(__ws, __len);
125	return __s;
126	}
127
128	// This is the unspecialized form of the template.
129	template<typename _CharT, typename _OutIter>
130	inline
131	_OutIter
132	__write(_OutIter __s, const _CharT* __ws, int __len)
133	{
134	for (int __j = `0`; __j < __len; __j++, ++__s)
135	*__s = __ws[__j];
136	return __s;
137	}
138
139
140	// 22.2.1.1 Template class ctype
141	// Include host and configuration specific ctype enums for ctype_base.
142
143	/**
144	* @brief Common base for ctype facet
145	*
146	* This template class provides implementations of the public functions
147	* that forward to the protected virtual functions.
148	*
149	* This template also provides abstract stubs for the protected virtual
150	* functions.
151	*/
152	template<typename _CharT>
153	class __ctype_abstract_base : public locale::facet, public ctype_base
154	{
155	public:
156	// Types:
157	/// Typedef for the template parameter
158	typedef _CharT char_type;
159
160	/**
161	* @brief Test char_type classification.
162	*
163	* This function finds a mask M for @a __c and compares it to
164	* mask @a __m. It does so by returning the value of
165	* ctype<char_type>::do_is().
166	*
167	* @param __c The char_type to compare the mask of.
168	* @param __m The mask to compare against.
169	* @return (M & __m) != 0.
170	*/
171	bool
172	is(mask __m, char_type __c) const
173	{ return this->do_is(__m, __c); }
174
175	/**
176	* @brief Return a mask array.
177	*
178	* This function finds the mask for each char_type in the range [lo,hi)
179	* and successively writes it to vec. vec must have as many elements
180	* as the char array. It does so by returning the value of
181	* ctype<char_type>::do_is().
182	*
183	* @param __lo Pointer to start of range.
184	* @param __hi Pointer to end of range.
185	* @param __vec Pointer to an array of mask storage.
186	* @return @a __hi.
187	*/
188	const char_type*
189	is(const char_type __lo, const* char_type __hi, mask __vec) const
190	{ return this->do_is(__lo, __hi, __vec); }
191
192	/**
193	* @brief Find char_type matching a mask
194	*
195	* This function searches for and returns the first char_type c in
196	* [lo,hi) for which is(m,c) is true. It does so by returning
197	* ctype<char_type>::do_scan_is().
198	*
199	* @param __m The mask to compare against.
200	* @param __lo Pointer to start of range.
201	* @param __hi Pointer to end of range.
202	* @return Pointer to matching char_type if found, else @a __hi.
203	*/
204	const char_type*
205	scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
206	{ return this->do_scan_is(__m, __lo, __hi); }
207
208	/**
209	* @brief Find char_type not matching a mask
210	*
211	* This function searches for and returns the first char_type c in
212	* [lo,hi) for which is(m,c) is false. It does so by returning
213	* ctype<char_type>::do_scan_not().
214	*
215	* @param __m The mask to compare against.
216	* @param __lo Pointer to first char in range.
217	* @param __hi Pointer to end of range.
218	* @return Pointer to non-matching char if found, else @a __hi.
219	*/
220	const char_type*
221	scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
222	{ return this->do_scan_not(__m, __lo, __hi); }
223
224	/**
225	* @brief Convert to uppercase.
226	*
227	* This function converts the argument to uppercase if possible.
228	* If not possible (for example, '2'), returns the argument. It does
229	* so by returning ctype<char_type>::do_toupper().
230	*
231	* @param __c The char_type to convert.
232	* @return The uppercase char_type if convertible, else @a __c.
233	*/
234	char_type
235	toupper(char_type __c) const
236	{ return this->do_toupper(__c); }
237
238	/**
239	* @brief Convert array to uppercase.
240	*
241	* This function converts each char_type in the range [lo,hi) to
242	* uppercase if possible. Other elements remain untouched. It does so
243	* by returning ctype<char_type>:: do_toupper(lo, hi).
244	*
245	* @param __lo Pointer to start of range.
246	* @param __hi Pointer to end of range.
247	* @return @a __hi.
248	*/
249	const char_type*
250	toupper(char_type __lo, const* char_type* __hi) const
251	{ return this->do_toupper(__lo, __hi); }
252
253	/**
254	* @brief Convert to lowercase.
255	*
256	* This function converts the argument to lowercase if possible. If
257	* not possible (for example, '2'), returns the argument. It does so
258	* by returning ctype<char_type>::do_tolower(c).
259	*
260	* @param __c The char_type to convert.
261	* @return The lowercase char_type if convertible, else @a __c.
262	*/
263	char_type
264	tolower(char_type __c) const
265	{ return this->do_tolower(__c); }
266
267	/**
268	* @brief Convert array to lowercase.
269	*
270	* This function converts each char_type in the range [__lo,__hi) to
271	* lowercase if possible. Other elements remain untouched. It does so
272	* by returning ctype<char_type>:: do_tolower(__lo, __hi).
273	*
274	* @param __lo Pointer to start of range.
275	* @param __hi Pointer to end of range.
276	* @return @a __hi.
277	*/
278	const char_type*
279	tolower(char_type* __lo, const char_type* __hi) const
280	{ return this->do_tolower(__lo, __hi); }
281
282	/**
283	* @brief Widen char to char_type
284	*
285	* This function converts the char argument to char_type using the
286	* simplest reasonable transformation. It does so by returning
287	* ctype<char_type>::do_widen(c).
288	*
289	* Note: this is not what you want for codepage conversions. See
290	* codecvt for that.
291	*
292	* @param __c The char to convert.
293	* @return The converted char_type.
294	*/
295	char_type
296	widen(char __c) const
297	{ return this->do_widen(__c); }
298
299	/**
300	* @brief Widen array to char_type
301	*
302	* This function converts each char in the input to char_type using the
303	* simplest reasonable transformation. It does so by returning
304	* ctype<char_type>::do_widen(c).
305	*
306	* Note: this is not what you want for codepage conversions. See
307	* codecvt for that.
308	*
309	* @param __lo Pointer to start of range.
310	* @param __hi Pointer to end of range.
311	* @param __to Pointer to the destination array.
312	* @return @a __hi.
313	*/
314	const char*
315	widen(const char* __lo, const char* __hi, char_type* __to) const
316	{ return this->do_widen(__lo, __hi, __to); }
317
318	/**
319	* @brief Narrow char_type to char
320	*
321	* This function converts the char_type to char using the simplest
322	* reasonable transformation. If the conversion fails, dfault is
323	* returned instead. It does so by returning
324	* ctype<char_type>::do_narrow(__c).
325	*
326	* Note: this is not what you want for codepage conversions. See
327	* codecvt for that.
328	*
329	* @param __c The char_type to convert.
330	* @param __dfault Char to return if conversion fails.
331	* @return The converted char.
332	*/
333	char
334	narrow(char_type __c, char __dfault) const
335	{ return this->do_narrow(__c, __dfault); }
336
337	/**
338	* @brief Narrow array to char array
339	*
340	* This function converts each char_type in the input to char using the
341	* simplest reasonable transformation and writes the results to the
342	* destination array. For any char_type in the input that cannot be
343	* converted, @a dfault is used instead. It does so by returning
344	* ctype<char_type>::do_narrow(__lo, __hi, __dfault, __to).
345	*
346	* Note: this is not what you want for codepage conversions. See
347	* codecvt for that.
348	*
349	* @param __lo Pointer to start of range.
350	* @param __hi Pointer to end of range.
351	* @param __dfault Char to use if conversion fails.
352	* @param __to Pointer to the destination array.
353	* @return @a __hi.
354	*/
355	const char_type*
356	narrow(const char_type* __lo, const char_type* __hi,
357	char __dfault, char* __to) const
358	{ return this->do_narrow(__lo, __hi, __dfault, __to); }
359
360	protected:
361	explicit
362	__ctype_abstract_base(size_t __refs = `0`): facet(__refs) { }
363
364	virtual
365	~__ctype_abstract_base() { }
366
367	/**
368	* @brief Test char_type classification.
369	*
370	* This function finds a mask M for @a c and compares it to mask @a m.
371	*
372	* do_is() is a hook for a derived facet to change the behavior of
373	* classifying. do_is() must always return the same result for the
374	* same input.
375	*
376	* @param __c The char_type to find the mask of.
377	* @param __m The mask to compare against.
378	* @return (M & __m) != 0.
379	*/
380	virtual bool
381	do_is(mask __m, char_type __c) const = `0`;
382
383	/**
384	* @brief Return a mask array.
385	*
386	* This function finds the mask for each char_type in the range [lo,hi)
387	* and successively writes it to vec. vec must have as many elements
388	* as the input.
389	*
390	* do_is() is a hook for a derived facet to change the behavior of
391	* classifying. do_is() must always return the same result for the
392	* same input.
393	*
394	* @param __lo Pointer to start of range.
395	* @param __hi Pointer to end of range.
396	* @param __vec Pointer to an array of mask storage.
397	* @return @a __hi.
398	*/
399	virtual const char_type*
400	do_is(const char_type* __lo, const char_type* __hi,
401	mask* __vec) const = `0`;
402
403	/**
404	* @brief Find char_type matching mask
405	*
406	* This function searches for and returns the first char_type c in
407	* [__lo,__hi) for which is(__m,c) is true.
408	*
409	* do_scan_is() is a hook for a derived facet to change the behavior of
410	* match searching. do_is() must always return the same result for the
411	* same input.
412	*
413	* @param __m The mask to compare against.
414	* @param __lo Pointer to start of range.
415	* @param __hi Pointer to end of range.
416	* @return Pointer to a matching char_type if found, else @a __hi.
417	*/
418	virtual const char_type*
419	do_scan_is(mask __m, const char_type* __lo,
420	const char_type* __hi) const = `0`;
421
422	/**
423	* @brief Find char_type not matching mask
424	*
425	* This function searches for and returns a pointer to the first
426	* char_type c of [lo,hi) for which is(m,c) is false.
427	*
428	* do_scan_is() is a hook for a derived facet to change the behavior of
429	* match searching. do_is() must always return the same result for the
430	* same input.
431	*
432	* @param __m The mask to compare against.
433	* @param __lo Pointer to start of range.
434	* @param __hi Pointer to end of range.
435	* @return Pointer to a non-matching char_type if found, else @a __hi.
436	*/
437	virtual const char_type*
438	do_scan_not(mask __m, const char_type* __lo,
439	const char_type* __hi) const = `0`;
440
441	/**
442	* @brief Convert to uppercase.
443	*
444	* This virtual function converts the char_type argument to uppercase
445	* if possible. If not possible (for example, '2'), returns the
446	* argument.
447	*
448	* do_toupper() is a hook for a derived facet to change the behavior of
449	* uppercasing. do_toupper() must always return the same result for
450	* the same input.
451	*
452	* @param __c The char_type to convert.
453	* @return The uppercase char_type if convertible, else @a __c.
454	*/
455	virtual char_type
456	do_toupper(char_type __c) const = `0`;
457
458	/**
459	* @brief Convert array to uppercase.
460	*
461	* This virtual function converts each char_type in the range [__lo,__hi)
462	* to uppercase if possible. Other elements remain untouched.
463	*
464	* do_toupper() is a hook for a derived facet to change the behavior of
465	* uppercasing. do_toupper() must always return the same result for
466	* the same input.
467	*
468	* @param __lo Pointer to start of range.
469	* @param __hi Pointer to end of range.
470	* @return @a __hi.
471	*/
472	virtual const char_type*
473	do_toupper(char_type* __lo, const char_type* __hi) const = `0`;
474
475	/**
476	* @brief Convert to lowercase.
477	*
478	* This virtual function converts the argument to lowercase if
479	* possible. If not possible (for example, '2'), returns the argument.
480	*
481	* do_tolower() is a hook for a derived facet to change the behavior of
482	* lowercasing. do_tolower() must always return the same result for
483	* the same input.
484	*
485	* @param __c The char_type to convert.
486	* @return The lowercase char_type if convertible, else @a __c.
487	*/
488	virtual char_type
489	do_tolower(char_type __c) const = `0`;
490
491	/**
492	* @brief Convert array to lowercase.
493	*
494	* This virtual function converts each char_type in the range [__lo,__hi)
495	* to lowercase if possible. Other elements remain untouched.
496	*
497	* do_tolower() is a hook for a derived facet to change the behavior of
498	* lowercasing. do_tolower() must always return the same result for
499	* the same input.
500	*
501	* @param __lo Pointer to start of range.
502	* @param __hi Pointer to end of range.
503	* @return @a __hi.
504	*/
505	virtual const char_type*
506	do_tolower(char_type* __lo, const char_type* __hi) const = `0`;
507
508	/**
509	* @brief Widen char
510	*
511	* This virtual function converts the char to char_type using the
512	* simplest reasonable transformation.
513	*
514	* do_widen() is a hook for a derived facet to change the behavior of
515	* widening. do_widen() must always return the same result for the
516	* same input.
517	*
518	* Note: this is not what you want for codepage conversions. See
519	* codecvt for that.
520	*
521	* @param __c The char to convert.
522	* @return The converted char_type
523	*/
524	virtual char_type
525	do_widen(char __c) const = `0`;
526
527	/**
528	* @brief Widen char array
529	*
530	* This function converts each char in the input to char_type using the
531	* simplest reasonable transformation.
532	*
533	* do_widen() is a hook for a derived facet to change the behavior of
534	* widening. do_widen() must always return the same result for the
535	* same input.
536	*
537	* Note: this is not what you want for codepage conversions. See
538	* codecvt for that.
539	*
540	* @param __lo Pointer to start range.
541	* @param __hi Pointer to end of range.
542	* @param __to Pointer to the destination array.
543	* @return @a __hi.
544	*/
545	virtual const char*
546	do_widen(const char* __lo, const char* __hi, char_type* __to) const = `0`;
547
548	/**
549	* @brief Narrow char_type to char
550	*
551	* This virtual function converts the argument to char using the
552	* simplest reasonable transformation. If the conversion fails, dfault
553	* is returned instead.
554	*
555	* do_narrow() is a hook for a derived facet to change the behavior of
556	* narrowing. do_narrow() must always return the same result for the
557	* same input.
558	*
559	* Note: this is not what you want for codepage conversions. See
560	* codecvt for that.
561	*
562	* @param __c The char_type to convert.
563	* @param __dfault Char to return if conversion fails.
564	* @return The converted char.
565	*/
566	virtual char
567	do_narrow(char_type __c, char __dfault) const = `0`;
568
569	/**
570	* @brief Narrow char_type array to char
571	*
572	* This virtual function converts each char_type in the range
573	* [__lo,__hi) to char using the simplest reasonable
574	* transformation and writes the results to the destination
575	* array. For any element in the input that cannot be
576	* converted, @a __dfault is used instead.
577	*
578	* do_narrow() is a hook for a derived facet to change the behavior of
579	* narrowing. do_narrow() must always return the same result for the
580	* same input.
581	*
582	* Note: this is not what you want for codepage conversions. See
583	* codecvt for that.
584	*
585	* @param __lo Pointer to start of range.
586	* @param __hi Pointer to end of range.
587	* @param __dfault Char to use if conversion fails.
588	* @param __to Pointer to the destination array.
589	* @return @a __hi.
590	*/
591	virtual const char_type*
592	do_narrow(const char_type* __lo, const char_type* __hi,
593	char __dfault, char* __to) const = `0`;
594	};
595
596	/**
597	* @brief Primary class template ctype facet.
598	* @ingroup locales
599	*
600	* This template class defines classification and conversion functions for
601	* character sets. It wraps cctype functionality. Ctype gets used by
602	* streams for many I/O operations.
603	*
604	* This template provides the protected virtual functions the developer
605	* will have to replace in a derived class or specialization to make a
606	* working facet. The public functions that access them are defined in
607	* __ctype_abstract_base, to allow for implementation flexibility. See
608	* ctype<wchar_t> for an example. The functions are documented in
609	* __ctype_abstract_base.
610	*
611	* Note: implementations are provided for all the protected virtual
612	* functions, but will likely not be useful.
613	*/
614	template<typename _CharT>
615	class ctype : public __ctype_abstract_base<_CharT>
616	{
617	public:
618	// Types:
619	typedef _CharT char_type;
620	typedef typename __ctype_abstract_base<_CharT>::mask mask;
621
622	/// The facet id for ctype<char_type>
623	static locale::id id;
624
625	explicit
626	ctype(size_t __refs = `0`) : __ctype_abstract_base<_CharT>(__refs) { }
627
628	protected:
629	virtual
630	~ctype();
631
632	virtual bool
633	do_is(mask __m, char_type __c) const;
634
635	virtual const char_type*
636	do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
637
638	virtual const char_type*
639	do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
640
641	virtual const char_type*
642	do_scan_not(mask __m, const char_type* __lo,
643	const char_type* __hi) const;
644
645	virtual char_type
646	do_toupper(char_type __c) const;
647
648	virtual const char_type*
649	do_toupper(char_type* __lo, const char_type* __hi) const;
650
651	virtual char_type
652	do_tolower(char_type __c) const;
653
654	virtual const char_type*
655	do_tolower(char_type* __lo, const char_type* __hi) const;
656
657	virtual char_type
658	do_widen(char __c) const;
659
660	virtual const char*
661	do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
662
663	virtual char
664	do_narrow(char_type, char __dfault) const;
665
666	virtual const char_type*
667	do_narrow(const char_type* __lo, const char_type* __hi,
668	char __dfault, char* __to) const;
669	};
670
671	template<typename _CharT>
672	locale::id ctype<_CharT>::id;
673
674	/**
675	* @brief The ctype<char> specialization.
676	* @ingroup locales
677	*
678	* This class defines classification and conversion functions for
679	* the char type. It gets used by char streams for many I/O
680	* operations. The char specialization provides a number of
681	* optimizations as well.
682	*/
683	template<>
684	class ctype<char> : public locale::facet, public ctype_base
685	{
686	public:
687	// Types:
688	/// Typedef for the template parameter char.
689	typedef char char_type;
690
691	protected:
692	// Data Members:
693	__c_locale _M_c_locale_ctype;
694	bool _M_del;
695	__to_type _M_toupper;
696	__to_type _M_tolower;
697	const mask* _M_table;
698	mutable char _M_widen_ok;
699	mutable char _M_widen[`1` + static_cast<unsigned char>(-`1`)];
700	mutable char _M_narrow[`1` + static_cast<unsigned char>(-`1`)];
701	mutable char _M_narrow_ok; // 0 uninitialized, 1 init,
702	// 2 memcpy can't be used
703
704	public:
705	/// The facet id for ctype<char>
706	static locale::id id;
707	/// The size of the mask table. It is SCHAR_MAX + 1.
708	static const size_t table_size = `1` + static_cast<unsigned char>(-`1`);
709
710	/**
711	* @brief Constructor performs initialization.
712	*
713	* This is the constructor provided by the standard.
714	*
715	* @param __table If non-zero, table is used as the per-char mask.
716	* Else classic_table() is used.
717	* @param __del If true, passes ownership of table to this facet.
718	* @param __refs Passed to the base facet class.
719	*/
720	explicit
721	ctype(const mask* __table = `0`, bool __del = false, size_t __refs = `0`);
722
723	/**
724	* @brief Constructor performs static initialization.
725	*
726	* This constructor is used to construct the initial C locale facet.
727	*
728	* @param __cloc Handle to C locale data.
729	* @param __table If non-zero, table is used as the per-char mask.
730	* @param __del If true, passes ownership of table to this facet.
731	* @param __refs Passed to the base facet class.
732	*/
733	explicit
734	ctype(__c_locale __cloc, const mask* __table = `0`, bool __del = false,
735	size_t __refs = `0`);
736
737	/**
738	* @brief Test char classification.
739	*
740	* This function compares the mask table[c] to @a __m.
741	*
742	* @param __c The char to compare the mask of.
743	* @param __m The mask to compare against.
744	* @return True if __m & table[__c] is true, false otherwise.
745	*/
746	inline bool
747	is(mask __m, char __c) const;
748
749	/**
750	* @brief Return a mask array.
751	*
752	* This function finds the mask for each char in the range [lo, hi) and
753	* successively writes it to vec. vec must have as many elements as
754	* the char array.
755	*
756	* @param __lo Pointer to start of range.
757	* @param __hi Pointer to end of range.
758	* @param __vec Pointer to an array of mask storage.
759	* @return @a __hi.
760	*/
761	inline const char*
762	is(const char* __lo, const char* __hi, mask* __vec) const;
763
764	/**
765	* @brief Find char matching a mask
766	*
767	* This function searches for and returns the first char in [lo,hi) for
768	* which is(m,char) is true.
769	*
770	* @param __m The mask to compare against.
771	* @param __lo Pointer to start of range.
772	* @param __hi Pointer to end of range.
773	* @return Pointer to a matching char if found, else @a __hi.
774	*/
775	inline const char*
776	scan_is(mask __m, const char* __lo, const char* __hi) const;
777
778	/**
779	* @brief Find char not matching a mask
780	*
781	* This function searches for and returns a pointer to the first char
782	* in [__lo,__hi) for which is(m,char) is false.
783	*
784	* @param __m The mask to compare against.
785	* @param __lo Pointer to start of range.
786	* @param __hi Pointer to end of range.
787	* @return Pointer to a non-matching char if found, else @a __hi.
788	*/
789	inline const char*
790	scan_not(mask __m, const char* __lo, const char* __hi) const;
791
792	/**
793	* @brief Convert to uppercase.
794	*
795	* This function converts the char argument to uppercase if possible.
796	* If not possible (for example, '2'), returns the argument.
797	*
798	* toupper() acts as if it returns ctype<char>::do_toupper(c).
799	* do_toupper() must always return the same result for the same input.
800	*
801	* @param __c The char to convert.
802	* @return The uppercase char if convertible, else @a __c.
803	*/
804	char_type
805	toupper(char_type __c) const
806	{ return this->do_toupper(__c); }
807
808	/**
809	* @brief Convert array to uppercase.
810	*
811	* This function converts each char in the range [__lo,__hi) to uppercase
812	* if possible. Other chars remain untouched.
813	*
814	* toupper() acts as if it returns ctype<char>:: do_toupper(__lo, __hi).
815	* do_toupper() must always return the same result for the same input.
816	*
817	* @param __lo Pointer to first char in range.
818	* @param __hi Pointer to end of range.
819	* @return @a __hi.
820	*/
821	const char_type*
822	toupper(char_type __lo, const* char_type* __hi) const
823	{ return this->do_toupper(__lo, __hi); }
824
825	/**
826	* @brief Convert to lowercase.
827	*
828	* This function converts the char argument to lowercase if possible.
829	* If not possible (for example, '2'), returns the argument.
830	*
831	* tolower() acts as if it returns ctype<char>::do_tolower(__c).
832	* do_tolower() must always return the same result for the same input.
833	*
834	* @param __c The char to convert.
835	* @return The lowercase char if convertible, else @a __c.
836	*/
837	char_type
838	tolower(char_type __c) const
839	{ return this->do_tolower(__c); }
840
841	/**
842	* @brief Convert array to lowercase.
843	*
844	* This function converts each char in the range [lo,hi) to lowercase
845	* if possible. Other chars remain untouched.
846	*
847	* tolower() acts as if it returns ctype<char>:: do_tolower(__lo, __hi).
848	* do_tolower() must always return the same result for the same input.
849	*
850	* @param __lo Pointer to first char in range.
851	* @param __hi Pointer to end of range.
852	* @return @a __hi.
853	*/
854	const char_type*
855	tolower(char_type* __lo, const char_type* __hi) const
856	{ return this->do_tolower(__lo, __hi); }
857
858	/**
859	* @brief Widen char
860	*
861	* This function converts the char to char_type using the simplest
862	* reasonable transformation. For an underived ctype<char> facet, the
863	* argument will be returned unchanged.
864	*
865	* This function works as if it returns ctype<char>::do_widen(c).
866	* do_widen() must always return the same result for the same input.
867	*
868	* Note: this is not what you want for codepage conversions. See
869	* codecvt for that.
870	*
871	* @param __c The char to convert.
872	* @return The converted character.
873	*/
874	char_type
875	widen(char __c) const
876	{
877	if (_M_widen_ok)
878	return _M_widen[static_cast<unsigned char>(__c)];
879	this->_M_widen_init();
880	return this->do_widen(__c);
881	}
882
883	/**
884	* @brief Widen char array
885	*
886	* This function converts each char in the input to char using the
887	* simplest reasonable transformation. For an underived ctype<char>
888	* facet, the argument will be copied unchanged.
889	*
890	* This function works as if it returns ctype<char>::do_widen(c).
891	* do_widen() must always return the same result for the same input.
892	*
893	* Note: this is not what you want for codepage conversions. See
894	* codecvt for that.
895	*
896	* @param __lo Pointer to first char in range.
897	* @param __hi Pointer to end of range.
898	* @param __to Pointer to the destination array.
899	* @return @a __hi.
900	*/
901	const char*
902	widen(const char* __lo, const char* __hi, char_type* __to) const
903	{
904	if (_M_widen_ok == `1`)
905	{
906	if (__builtin_expect(__hi != __lo, true))
907	__builtin_memcpy(__to, __lo, __hi - __lo);
908	return __hi;
909	}
910	if (!_M_widen_ok)
911	_M_widen_init();
912	return this->do_widen(__lo, __hi, __to);
913	}
914
915	/**
916	* @brief Narrow char
917	*
918	* This function converts the char to char using the simplest
919	* reasonable transformation. If the conversion fails, dfault is
920	* returned instead. For an underived ctype<char> facet, @a c
921	* will be returned unchanged.
922	*
923	* This function works as if it returns ctype<char>::do_narrow(c).
924	* do_narrow() must always return the same result for the same input.
925	*
926	* Note: this is not what you want for codepage conversions. See
927	* codecvt for that.
928	*
929	* @param __c The char to convert.
930	* @param __dfault Char to return if conversion fails.
931	* @return The converted character.
932	*/
933	char
934	narrow(char_type __c, char __dfault) const
935	{
936	if (_M_narrow[static_cast<unsigned char>(__c)])
937	return _M_narrow[static_cast<unsigned char>(__c)];
938	const char __t = do_narrow(__c, __dfault);
939	if (__t != __dfault)
940	_M_narrow[static_cast<unsigned char>(__c)] = __t;
941	return __t;
942	}
943
944	/**
945	* @brief Narrow char array
946	*
947	* This function converts each char in the input to char using the
948	* simplest reasonable transformation and writes the results to the
949	* destination array. For any char in the input that cannot be
950	* converted, @a dfault is used instead. For an underived ctype<char>
951	* facet, the argument will be copied unchanged.
952	*
953	* This function works as if it returns ctype<char>::do_narrow(lo, hi,
954	* dfault, to). do_narrow() must always return the same result for the
955	* same input.
956	*
957	* Note: this is not what you want for codepage conversions. See
958	* codecvt for that.
959	*
960	* @param __lo Pointer to start of range.
961	* @param __hi Pointer to end of range.
962	* @param __dfault Char to use if conversion fails.
963	* @param __to Pointer to the destination array.
964	* @return @a __hi.
965	*/
966	const char_type*
967	narrow(const char_type* __lo, const char_type* __hi,
968	char __dfault, char* __to) const
969	{
970	if (__builtin_expect(_M_narrow_ok == `1`, true))
971	{
972	if (__builtin_expect(__hi != __lo, true))
973	__builtin_memcpy(__to, __lo, __hi - __lo);
974	return __hi;
975	}
976	if (!_M_narrow_ok)
977	_M_narrow_init();
978	return this->do_narrow(__lo, __hi, __dfault, __to);
979	}
980
981	// _GLIBCXX_RESOLVE_LIB_DEFECTS
982	// DR 695. ctype<char>::classic_table() not accessible.
983	/// Returns a pointer to the mask table provided to the constructor, or
984	/// the default from classic_table() if none was provided.
985	const mask*
986	table() const throw()
987	{ return _M_table; }
988
989	/// Returns a pointer to the C locale mask table.
990	static const mask*
991	classic_table() throw();
992	protected:
993
994	/**
995	* @brief Destructor.
996	*
997	* This function deletes table() if @a del was true in the
998	* constructor.
999	*/
1000	virtual
1001	~ctype();
1002
1003	/**
1004	* @brief Convert to uppercase.
1005	*
1006	* This virtual function converts the char argument to uppercase if
1007	* possible. If not possible (for example, '2'), returns the argument.
1008	*
1009	* do_toupper() is a hook for a derived facet to change the behavior of
1010	* uppercasing. do_toupper() must always return the same result for
1011	* the same input.
1012	*
1013	* @param __c The char to convert.
1014	* @return The uppercase char if convertible, else @a __c.
1015	*/
1016	virtual char_type
1017	do_toupper(char_type __c) const;
1018
1019	/**
1020	* @brief Convert array to uppercase.
1021	*
1022	* This virtual function converts each char in the range [lo,hi) to
1023	* uppercase if possible. Other chars remain untouched.
1024	*
1025	* do_toupper() is a hook for a derived facet to change the behavior of
1026	* uppercasing. do_toupper() must always return the same result for
1027	* the same input.
1028	*
1029	* @param __lo Pointer to start of range.
1030	* @param __hi Pointer to end of range.
1031	* @return @a __hi.
1032	*/
1033	virtual const char_type*
1034	do_toupper(char_type* __lo, const char_type* __hi) const;
1035
1036	/**
1037	* @brief Convert to lowercase.
1038	*
1039	* This virtual function converts the char argument to lowercase if
1040	* possible. If not possible (for example, '2'), returns the argument.
1041	*
1042	* do_tolower() is a hook for a derived facet to change the behavior of
1043	* lowercasing. do_tolower() must always return the same result for
1044	* the same input.
1045	*
1046	* @param __c The char to convert.
1047	* @return The lowercase char if convertible, else @a __c.
1048	*/
1049	virtual char_type
1050	do_tolower(char_type __c) const;
1051
1052	/**
1053	* @brief Convert array to lowercase.
1054	*
1055	* This virtual function converts each char in the range [lo,hi) to
1056	* lowercase if possible. Other chars remain untouched.
1057	*
1058	* do_tolower() is a hook for a derived facet to change the behavior of
1059	* lowercasing. do_tolower() must always return the same result for
1060	* the same input.
1061	*
1062	* @param __lo Pointer to first char in range.
1063	* @param __hi Pointer to end of range.
1064	* @return @a __hi.
1065	*/
1066	virtual const char_type*
1067	do_tolower(char_type* __lo, const char_type* __hi) const;
1068
1069	/**
1070	* @brief Widen char
1071	*
1072	* This virtual function converts the char to char using the simplest
1073	* reasonable transformation. For an underived ctype<char> facet, the
1074	* argument will be returned unchanged.
1075	*
1076	* do_widen() is a hook for a derived facet to change the behavior of
1077	* widening. do_widen() must always return the same result for the
1078	* same input.
1079	*
1080	* Note: this is not what you want for codepage conversions. See
1081	* codecvt for that.
1082	*
1083	* @param __c The char to convert.
1084	* @return The converted character.
1085	*/
1086	virtual char_type
1087	do_widen(char __c) const
1088	{ return __c; }
1089
1090	/**
1091	* @brief Widen char array
1092	*
1093	* This function converts each char in the range [lo,hi) to char using
1094	* the simplest reasonable transformation. For an underived
1095	* ctype<char> facet, the argument will be copied unchanged.
1096	*
1097	* do_widen() is a hook for a derived facet to change the behavior of
1098	* widening. do_widen() must always return the same result for the
1099	* same input.
1100	*
1101	* Note: this is not what you want for codepage conversions. See
1102	* codecvt for that.
1103	*
1104	* @param __lo Pointer to start of range.
1105	* @param __hi Pointer to end of range.
1106	* @param __to Pointer to the destination array.
1107	* @return @a __hi.
1108	*/
1109	virtual const char*
1110	do_widen(const char* __lo, const char* __hi, char_type* __to) const
1111	{
1112	if (__builtin_expect(__hi != __lo, true))
1113	__builtin_memcpy(__to, __lo, __hi - __lo);
1114	return __hi;
1115	}
1116
1117	/**
1118	* @brief Narrow char
1119	*
1120	* This virtual function converts the char to char using the simplest
1121	* reasonable transformation. If the conversion fails, dfault is
1122	* returned instead. For an underived ctype<char> facet, @a c will be
1123	* returned unchanged.
1124	*
1125	* do_narrow() is a hook for a derived facet to change the behavior of
1126	* narrowing. do_narrow() must always return the same result for the
1127	* same input.
1128	*
1129	* Note: this is not what you want for codepage conversions. See
1130	* codecvt for that.
1131	*
1132	* @param __c The char to convert.
1133	* @param __dfault Char to return if conversion fails.
1134	* @return The converted char.
1135	*/
1136	virtual char
1137	do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const
1138	{ return __c; }
1139
1140	/**
1141	* @brief Narrow char array to char array
1142	*
1143	* This virtual function converts each char in the range [lo,hi) to
1144	* char using the simplest reasonable transformation and writes the
1145	* results to the destination array. For any char in the input that
1146	* cannot be converted, @a dfault is used instead. For an underived
1147	* ctype<char> facet, the argument will be copied unchanged.
1148	*
1149	* do_narrow() is a hook for a derived facet to change the behavior of
1150	* narrowing. do_narrow() must always return the same result for the
1151	* same input.
1152	*
1153	* Note: this is not what you want for codepage conversions. See
1154	* codecvt for that.
1155	*
1156	* @param __lo Pointer to start of range.
1157	* @param __hi Pointer to end of range.
1158	* @param __dfault Char to use if conversion fails.
1159	* @param __to Pointer to the destination array.
1160	* @return @a __hi.
1161	*/
1162	virtual const char_type*
1163	do_narrow(const char_type* __lo, const char_type* __hi,
1164	char __dfault __attribute__((__unused__)), char* __to) const
1165	{
1166	if (__builtin_expect(__hi != __lo, true))
1167	__builtin_memcpy(__to, __lo, __hi - __lo);
1168	return __hi;
1169	}
1170
1171	private:
1172	void _M_narrow_init() const;
1173	void _M_widen_init() const;
1174	};
1175
1176	#ifdef _GLIBCXX_USE_WCHAR_T
1177	/**
1178	* @brief The ctype<wchar_t> specialization.
1179	* @ingroup locales
1180	*
1181	* This class defines classification and conversion functions for the
1182	* wchar_t type. It gets used by wchar_t streams for many I/O operations.
1183	* The wchar_t specialization provides a number of optimizations as well.
1184	*
1185	* ctype<wchar_t> inherits its public methods from
1186	* __ctype_abstract_base<wchar_t>.
1187	*/
1188	template<>
1189	class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
1190	{
1191	public:
1192	// Types:
1193	/// Typedef for the template parameter wchar_t.
1194	typedef wchar_t char_type;
1195	typedef wctype_t __wmask_type;
1196
1197	protected:
1198	__c_locale _M_c_locale_ctype;
1199
1200	// Pre-computed narrowed and widened chars.
1201	bool _M_narrow_ok;
1202	char _M_narrow[`128`];
1203	wint_t _M_widen[`1` + static_cast<unsigned char>(-`1`)];
1204
1205	// Pre-computed elements for do_is.
1206	mask _M_bit[`16`];
1207	__wmask_type _M_wmask[`16`];
1208
1209	public:
1210	// Data Members:
1211	/// The facet id for ctype<wchar_t>
1212	static locale::id id;
1213
1214	/**
1215	* @brief Constructor performs initialization.
1216	*
1217	* This is the constructor provided by the standard.
1218	*
1219	* @param __refs Passed to the base facet class.
1220	*/
1221	explicit
1222	ctype(size_t __refs = `0`);
1223
1224	/**
1225	* @brief Constructor performs static initialization.
1226	*
1227	* This constructor is used to construct the initial C locale facet.
1228	*
1229	* @param __cloc Handle to C locale data.
1230	* @param __refs Passed to the base facet class.
1231	*/
1232	explicit
1233	ctype(__c_locale __cloc, size_t __refs = `0`);
1234
1235	protected:
1236	__wmask_type
1237	_M_convert_to_wmask(const mask __m) const throw();
1238
1239	/// Destructor
1240	virtual
1241	~ctype();
1242
1243	/**
1244	* @brief Test wchar_t classification.
1245	*
1246	* This function finds a mask M for @a c and compares it to mask @a m.
1247	*
1248	* do_is() is a hook for a derived facet to change the behavior of
1249	* classifying. do_is() must always return the same result for the
1250	* same input.
1251	*
1252	* @param __c The wchar_t to find the mask of.
1253	* @param __m The mask to compare against.
1254	* @return (M & __m) != 0.
1255	*/
1256	virtual bool
1257	do_is(mask __m, char_type __c) const;
1258
1259	/**
1260	* @brief Return a mask array.
1261	*
1262	* This function finds the mask for each wchar_t in the range [lo,hi)
1263	* and successively writes it to vec. vec must have as many elements
1264	* as the input.
1265	*
1266	* do_is() is a hook for a derived facet to change the behavior of
1267	* classifying. do_is() must always return the same result for the
1268	* same input.
1269	*
1270	* @param __lo Pointer to start of range.
1271	* @param __hi Pointer to end of range.
1272	* @param __vec Pointer to an array of mask storage.
1273	* @return @a __hi.
1274	*/
1275	virtual const char_type*
1276	do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
1277
1278	/**
1279	* @brief Find wchar_t matching mask
1280	*
1281	* This function searches for and returns the first wchar_t c in
1282	* [__lo,__hi) for which is(__m,c) is true.
1283	*
1284	* do_scan_is() is a hook for a derived facet to change the behavior of
1285	* match searching. do_is() must always return the same result for the
1286	* same input.
1287	*
1288	* @param __m The mask to compare against.
1289	* @param __lo Pointer to start of range.
1290	* @param __hi Pointer to end of range.
1291	* @return Pointer to a matching wchar_t if found, else @a __hi.
1292	*/
1293	virtual const char_type*
1294	do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
1295
1296	/**
1297	* @brief Find wchar_t not matching mask
1298	*
1299	* This function searches for and returns a pointer to the first
1300	* wchar_t c of [__lo,__hi) for which is(__m,c) is false.
1301	*
1302	* do_scan_is() is a hook for a derived facet to change the behavior of
1303	* match searching. do_is() must always return the same result for the
1304	* same input.
1305	*
1306	* @param __m The mask to compare against.
1307	* @param __lo Pointer to start of range.
1308	* @param __hi Pointer to end of range.
1309	* @return Pointer to a non-matching wchar_t if found, else @a __hi.
1310	*/
1311	virtual const char_type*
1312	do_scan_not(mask __m, const char_type* __lo,
1313	const char_type* __hi) const;
1314
1315	/**
1316	* @brief Convert to uppercase.
1317	*
1318	* This virtual function converts the wchar_t argument to uppercase if
1319	* possible. If not possible (for example, '2'), returns the argument.
1320	*
1321	* do_toupper() is a hook for a derived facet to change the behavior of
1322	* uppercasing. do_toupper() must always return the same result for
1323	* the same input.
1324	*
1325	* @param __c The wchar_t to convert.
1326	* @return The uppercase wchar_t if convertible, else @a __c.
1327	*/
1328	virtual char_type
1329	do_toupper(char_type __c) const;
1330
1331	/**
1332	* @brief Convert array to uppercase.
1333	*
1334	* This virtual function converts each wchar_t in the range [lo,hi) to
1335	* uppercase if possible. Other elements remain untouched.
1336	*
1337	* do_toupper() is a hook for a derived facet to change the behavior of
1338	* uppercasing. do_toupper() must always return the same result for
1339	* the same input.
1340	*
1341	* @param __lo Pointer to start of range.
1342	* @param __hi Pointer to end of range.
1343	* @return @a __hi.
1344	*/
1345	virtual const char_type*
1346	do_toupper(char_type* __lo, const char_type* __hi) const;
1347
1348	/**
1349	* @brief Convert to lowercase.
1350	*
1351	* This virtual function converts the argument to lowercase if
1352	* possible. If not possible (for example, '2'), returns the argument.
1353	*
1354	* do_tolower() is a hook for a derived facet to change the behavior of
1355	* lowercasing. do_tolower() must always return the same result for
1356	* the same input.
1357	*
1358	* @param __c The wchar_t to convert.
1359	* @return The lowercase wchar_t if convertible, else @a __c.
1360	*/
1361	virtual char_type
1362	do_tolower(char_type __c) const;
1363
1364	/**
1365	* @brief Convert array to lowercase.
1366	*
1367	* This virtual function converts each wchar_t in the range [lo,hi) to
1368	* lowercase if possible. Other elements remain untouched.
1369	*
1370	* do_tolower() is a hook for a derived facet to change the behavior of
1371	* lowercasing. do_tolower() must always return the same result for
1372	* the same input.
1373	*
1374	* @param __lo Pointer to start of range.
1375	* @param __hi Pointer to end of range.
1376	* @return @a __hi.
1377	*/
1378	virtual const char_type*
1379	do_tolower(char_type* __lo, const char_type* __hi) const;
1380
1381	/**
1382	* @brief Widen char to wchar_t
1383	*
1384	* This virtual function converts the char to wchar_t using the
1385	* simplest reasonable transformation. For an underived ctype<wchar_t>
1386	* facet, the argument will be cast to wchar_t.
1387	*
1388	* do_widen() is a hook for a derived facet to change the behavior of
1389	* widening. do_widen() must always return the same result for the
1390	* same input.
1391	*
1392	* Note: this is not what you want for codepage conversions. See
1393	* codecvt for that.
1394	*
1395	* @param __c The char to convert.
1396	* @return The converted wchar_t.
1397	*/
1398	virtual char_type
1399	do_widen(char __c) const;
1400
1401	/**
1402	* @brief Widen char array to wchar_t array
1403	*
1404	* This function converts each char in the input to wchar_t using the
1405	* simplest reasonable transformation. For an underived ctype<wchar_t>
1406	* facet, the argument will be copied, casting each element to wchar_t.
1407	*
1408	* do_widen() is a hook for a derived facet to change the behavior of
1409	* widening. do_widen() must always return the same result for the
1410	* same input.
1411	*
1412	* Note: this is not what you want for codepage conversions. See
1413	* codecvt for that.
1414	*
1415	* @param __lo Pointer to start range.
1416	* @param __hi Pointer to end of range.
1417	* @param __to Pointer to the destination array.
1418	* @return @a __hi.
1419	*/
1420	virtual const char*
1421	do_widen(const char* __lo, const char* __hi, char_type* __to) const;
1422
1423	/**
1424	* @brief Narrow wchar_t to char
1425	*
1426	* This virtual function converts the argument to char using
1427	* the simplest reasonable transformation. If the conversion
1428	* fails, dfault is returned instead. For an underived
1429	* ctype<wchar_t> facet, @a c will be cast to char and
1430	* returned.
1431	*
1432	* do_narrow() is a hook for a derived facet to change the
1433	* behavior of narrowing. do_narrow() must always return the
1434	* same result for the same input.
1435	*
1436	* Note: this is not what you want for codepage conversions. See
1437	* codecvt for that.
1438	*
1439	* @param __c The wchar_t to convert.
1440	* @param __dfault Char to return if conversion fails.
1441	* @return The converted char.
1442	*/
1443	virtual char
1444	do_narrow(char_type __c, char __dfault) const;
1445
1446	/**
1447	* @brief Narrow wchar_t array to char array
1448	*
1449	* This virtual function converts each wchar_t in the range [lo,hi) to
1450	* char using the simplest reasonable transformation and writes the
1451	* results to the destination array. For any wchar_t in the input that
1452	* cannot be converted, @a dfault is used instead. For an underived
1453	* ctype<wchar_t> facet, the argument will be copied, casting each
1454	* element to char.
1455	*
1456	* do_narrow() is a hook for a derived facet to change the behavior of
1457	* narrowing. do_narrow() must always return the same result for the
1458	* same input.
1459	*
1460	* Note: this is not what you want for codepage conversions. See
1461	* codecvt for that.
1462	*
1463	* @param __lo Pointer to start of range.
1464	* @param __hi Pointer to end of range.
1465	* @param __dfault Char to use if conversion fails.
1466	* @param __to Pointer to the destination array.
1467	* @return @a __hi.
1468	*/
1469	virtual const char_type*
1470	do_narrow(const char_type* __lo, const char_type* __hi,
1471	char __dfault, char* __to) const;
1472
1473	// For use at construction time only.
1474	void
1475	_M_initialize_ctype() throw();
1476	};
1477	#endif //_GLIBCXX_USE_WCHAR_T
1478
1479	/// class ctype_byname [22.2.1.2].
1480	template<typename _CharT>
1481	class ctype_byname : public ctype<_CharT>
1482	{
1483	public:
1484	typedef typename ctype<_CharT>::mask mask;
1485
1486	explicit
1487	ctype_byname(const char* __s, size_t __refs = `0`);
1488
1489	#if __cplusplus >= 201103L
1490	explicit
1491	ctype_byname(const string& __s, size_t __refs = `0`)
1492	: ctype_byname(__s.c_str(), __refs) { }
1493	#endif
1494
1495	protected:
1496	virtual
1497	~ctype_byname() { }
1498	};
1499
1500	/// 22.2.1.4 Class ctype_byname specializations.
1501	template<>
1502	class ctype_byname<char> : public ctype<char>
1503	{
1504	public:
1505	explicit
1506	ctype_byname(const char* __s, size_t __refs = `0`);
1507
1508	#if __cplusplus >= 201103L
1509	explicit
1510	ctype_byname(const string& __s, size_t __refs = `0`);
1511	#endif
1512
1513	protected:
1514	virtual
1515	~ctype_byname();
1516	};
1517
1518	#ifdef _GLIBCXX_USE_WCHAR_T
1519	template<>
1520	class ctype_byname<wchar_t> : public ctype<wchar_t>
1521	{
1522	public:
1523	explicit
1524	ctype_byname(const char* __s, size_t __refs = `0`);
1525
1526	#if __cplusplus >= 201103L
1527	explicit
1528	ctype_byname(const string& __s, size_t __refs = `0`);
1529	#endif
1530
1531	protected:
1532	virtual
1533	~ctype_byname();
1534	};
1535	#endif
1536
1537	_GLIBCXX_END_NAMESPACE_VERSION
1538	} // namespace
1539
1540	// Include host and configuration specific ctype inlines.
1541	#include <bits/ctype_inline.h>
1542
1543	namespace std _GLIBCXX_VISIBILITY(default)
1544	{
1545	_GLIBCXX_BEGIN_NAMESPACE_VERSION
1546
1547	// 22.2.2 The numeric category.
1548	class __num_base
1549	{
1550	public:
1551	// NB: Code depends on the order of _S_atoms_out elements.
1552	// Below are the indices into _S_atoms_out.
1553	enum
1554	{
1555	_S_ominus,
1556	_S_oplus,
1557	_S_ox,
1558	_S_oX,
1559	_S_odigits,
1560	_S_odigits_end = _S_odigits + `16`,
1561	_S_oudigits = _S_odigits_end,
1562	_S_oudigits_end = _S_oudigits + `16`,
1563	_S_oe = _S_odigits + `14`, // For scientific notation, 'e'
1564	_S_oE = _S_oudigits + `14`, // For scientific notation, 'E'
1565	_S_oend = _S_oudigits_end
1566	};
1567
1568	// A list of valid numeric literals for output. This array
1569	// contains chars that will be passed through the current locale's
1570	// ctype<_CharT>.widen() and then used to render numbers.
1571	// For the standard "C" locale, this is
1572	// "-+xX0123456789abcdef0123456789ABCDEF".
1573	static const char* _S_atoms_out;
1574
1575	// String literal of acceptable (narrow) input, for num_get.
1576	// "-+xX0123456789abcdefABCDEF"
1577	static const char* _S_atoms_in;
1578
1579	enum
1580	{
1581	_S_iminus,
1582	_S_iplus,
1583	_S_ix,
1584	_S_iX,
1585	_S_izero,
1586	_S_ie = _S_izero + `14`,
1587	_S_iE = _S_izero + `20`,
1588	_S_iend = `26`
1589	};
1590
1591	// num_put
1592	// Construct and return valid scanf format for floating point types.
1593	static void
1594	_S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
1595	};
1596
1597	template<typename _CharT>
1598	struct __numpunct_cache : public locale::facet
1599	{
1600	const char* _M_grouping;
1601	size_t _M_grouping_size;
1602	bool _M_use_grouping;
1603	const _CharT* _M_truename;
1604	size_t _M_truename_size;
1605	const _CharT* _M_falsename;
1606	size_t _M_falsename_size;
1607	_CharT _M_decimal_point;
1608	_CharT _M_thousands_sep;
1609
1610	// A list of valid numeric literals for output: in the standard
1611	// "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF".
1612	// This array contains the chars after having been passed
1613	// through the current locale's ctype<_CharT>.widen().
1614	_CharT _M_atoms_out[__num_base::_S_oend];
1615
1616	// A list of valid numeric literals for input: in the standard
1617	// "C" locale, this is "-+xX0123456789abcdefABCDEF"
1618	// This array contains the chars after having been passed
1619	// through the current locale's ctype<_CharT>.widen().
1620	_CharT _M_atoms_in[__num_base::_S_iend];
1621
1622	bool _M_allocated;
1623
1624	__numpunct_cache(size_t __refs = `0`)
1625	: facet(__refs), _M_grouping(`0`), _M_grouping_size(`0`),
1626	_M_use_grouping(false),
1627	_M_truename(`0`), _M_truename_size(`0`), _M_falsename(`0`),
1628	_M_falsename_size(`0`), _M_decimal_point(_CharT()),
1629	_M_thousands_sep(_CharT()), _M_allocated(false)
1630	{ }
1631
1632	~__numpunct_cache();
1633
1634	void
1635	_M_cache(const locale& __loc);
1636
1637	private:
1638	__numpunct_cache&
1639	operator=(const __numpunct_cache&);
1640
1641	explicit
1642	__numpunct_cache(const __numpunct_cache&);
1643	};
1644
1645	template<typename _CharT>
1646	__numpunct_cache<_CharT>::~__numpunct_cache()
1647	{
1648	if (_M_allocated)
1649	{
1650	delete [] _M_grouping;
1651	delete [] _M_truename;
1652	delete [] _M_falsename;
1653	}
1654	}
1655
1656	_GLIBCXX_BEGIN_NAMESPACE_CXX11
1657
1658	/**
1659	* @brief Primary class template numpunct.
1660	* @ingroup locales
1661	*
1662	* This facet stores several pieces of information related to printing and
1663	* scanning numbers, such as the decimal point character. It takes a
1664	* template parameter specifying the char type. The numpunct facet is
1665	* used by streams for many I/O operations involving numbers.
1666	*
1667	* The numpunct template uses protected virtual functions to provide the
1668	* actual results. The public accessors forward the call to the virtual
1669	* functions. These virtual functions are hooks for developers to
1670	* implement the behavior they require from a numpunct facet.
1671	*/
1672	template<typename _CharT>
1673	class numpunct : public locale::facet
1674	{
1675	public:
1676	// Types:
1677	///@{
1678	/// Public typedefs
1679	typedef _CharT char_type;
1680	typedef basic_string<_CharT> string_type;
1681	///@}
1682	typedef __numpunct_cache<_CharT> __cache_type;
1683
1684	protected:
1685	__cache_type* _M_data;
1686
1687	public:
1688	/// Numpunct facet id.
1689	static locale::id id;
1690
1691	/**
1692	* @brief Numpunct constructor.
1693	*
1694	* @param __refs Refcount to pass to the base class.
1695	*/
1696	explicit
1697	numpunct(size_t __refs = `0`)
1698	: facet(__refs), _M_data(`0`)
1699	{ _M_initialize_numpunct(); }
1700
1701	/**
1702	* @brief Internal constructor. Not for general use.
1703	*
1704	* This is a constructor for use by the library itself to set up the
1705	* predefined locale facets.
1706	*
1707	* @param __cache __numpunct_cache object.
1708	* @param __refs Refcount to pass to the base class.
1709	*/
1710	explicit
1711	numpunct(__cache_type* __cache, size_t __refs = `0`)
1712	: facet(__refs), _M_data(__cache)
1713	{ _M_initialize_numpunct(); }
1714
1715	/**
1716	* @brief Internal constructor. Not for general use.
1717	*
1718	* This is a constructor for use by the library itself to set up new
1719	* locales.
1720	*
1721	* @param __cloc The C locale.
1722	* @param __refs Refcount to pass to the base class.
1723	*/
1724	explicit
1725	numpunct(__c_locale __cloc, size_t __refs = `0`)
1726	: facet(__refs), _M_data(`0`)
1727	{ _M_initialize_numpunct(__cloc); }
1728
1729	/**
1730	* @brief Return decimal point character.
1731	*
1732	* This function returns a char_type to use as a decimal point. It
1733	* does so by returning returning
1734	* numpunct<char_type>::do_decimal_point().
1735	*
1736	* @return @a char_type representing a decimal point.
1737	*/
1738	char_type
1739	decimal_point() const
1740	{ return this->do_decimal_point(); }
1741
1742	/**
1743	* @brief Return thousands separator character.
1744	*
1745	* This function returns a char_type to use as a thousands
1746	* separator. It does so by returning returning
1747	* numpunct<char_type>::do_thousands_sep().
1748	*
1749	* @return char_type representing a thousands separator.
1750	*/
1751	char_type
1752	thousands_sep() const
1753	{ return this->do_thousands_sep(); }
1754
1755	/**
1756	* @brief Return grouping specification.
1757	*
1758	* This function returns a string representing groupings for the
1759	* integer part of a number. Groupings indicate where thousands
1760	* separators should be inserted in the integer part of a number.
1761	*
1762	* Each char in the return string is interpret as an integer
1763	* rather than a character. These numbers represent the number
1764	* of digits in a group. The first char in the string
1765	* represents the number of digits in the least significant
1766	* group. If a char is negative, it indicates an unlimited
1767	* number of digits for the group. If more chars from the
1768	* string are required to group a number, the last char is used
1769	* repeatedly.
1770	*
1771	* For example, if the grouping() returns "\003\002" and is
1772	* applied to the number 123456789, this corresponds to
1773	* 12,34,56,789. Note that if the string was "32", this would
1774	* put more than 50 digits into the least significant group if
1775	* the character set is ASCII.
1776	*
1777	* The string is returned by calling
1778	* numpunct<char_type>::do_grouping().
1779	*
1780	* @return string representing grouping specification.
1781	*/
1782	string
1783	grouping() const
1784	{ return this->do_grouping(); }
1785
1786	/**
1787	* @brief Return string representation of bool true.
1788	*
1789	* This function returns a string_type containing the text
1790	* representation for true bool variables. It does so by calling
1791	* numpunct<char_type>::do_truename().
1792	*
1793	* @return string_type representing printed form of true.
1794	*/
1795	string_type
1796	truename() const
1797	{ return this->do_truename(); }
1798
1799	/**
1800	* @brief Return string representation of bool false.
1801	*
1802	* This function returns a string_type containing the text
1803	* representation for false bool variables. It does so by calling
1804	* numpunct<char_type>::do_falsename().
1805	*
1806	* @return string_type representing printed form of false.
1807	*/
1808	string_type
1809	falsename() const
1810	{ return this->do_falsename(); }
1811
1812	protected:
1813	/// Destructor.
1814	virtual
1815	~numpunct();
1816
1817	/**
1818	* @brief Return decimal point character.
1819	*
1820	* Returns a char_type to use as a decimal point. This function is a
1821	* hook for derived classes to change the value returned.
1822	*
1823	* @return @a char_type representing a decimal point.
1824	*/
1825	virtual char_type
1826	do_decimal_point() const
1827	{ return _M_data->_M_decimal_point; }
1828
1829	/**
1830	* @brief Return thousands separator character.
1831	*
1832	* Returns a char_type to use as a thousands separator. This function
1833	* is a hook for derived classes to change the value returned.
1834	*
1835	* @return @a char_type representing a thousands separator.
1836	*/
1837	virtual char_type
1838	do_thousands_sep() const
1839	{ return _M_data->_M_thousands_sep; }
1840
1841	/**
1842	* @brief Return grouping specification.
1843	*
1844	* Returns a string representing groupings for the integer part of a
1845	* number. This function is a hook for derived classes to change the
1846	* value returned. @see grouping() for details.
1847	*
1848	* @return String representing grouping specification.
1849	*/
1850	virtual string
1851	do_grouping() const
1852	{ return _M_data->_M_grouping; }
1853
1854	/**
1855	* @brief Return string representation of bool true.
1856	*
1857	* Returns a string_type containing the text representation for true
1858	* bool variables. This function is a hook for derived classes to
1859	* change the value returned.
1860	*
1861	* @return string_type representing printed form of true.
1862	*/
1863	virtual string_type
1864	do_truename() const
1865	{ return _M_data->_M_truename; }
1866
1867	/**
1868	* @brief Return string representation of bool false.
1869	*
1870	* Returns a string_type containing the text representation for false
1871	* bool variables. This function is a hook for derived classes to
1872	* change the value returned.
1873	*
1874	* @return string_type representing printed form of false.
1875	*/
1876	virtual string_type
1877	do_falsename() const
1878	{ return _M_data->_M_falsename; }
1879
1880	// For use at construction time only.
1881	void
1882	_M_initialize_numpunct(__c_locale __cloc = `0`);
1883	};
1884
1885	template<typename _CharT>
1886	locale::id numpunct<_CharT>::id;
1887
1888	template<>
1889	numpunct<char>::~numpunct();
1890
1891	template<>
1892	void
1893	numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
1894
1895	#ifdef _GLIBCXX_USE_WCHAR_T
1896	template<>
1897	numpunct<wchar_t>::~numpunct();
1898
1899	template<>
1900	void
1901	numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
1902	#endif
1903
1904	/// class numpunct_byname [22.2.3.2].
1905	template<typename _CharT>
1906	class numpunct_byname : public numpunct<_CharT>
1907	{
1908	public:
1909	typedef _CharT char_type;
1910	typedef basic_string<_CharT> string_type;
1911
1912	explicit
1913	numpunct_byname(const char* __s, size_t __refs = `0`)
1914	: numpunct<_CharT>(__refs)
1915	{
1916	if (__builtin_strcmp(__s, "C") != `0`
1917	&& __builtin_strcmp(__s, "POSIX") != `0`)
1918	{
1919	__c_locale __tmp;
1920	this->_S_create_c_locale(__tmp, __s);
1921	this->_M_initialize_numpunct(__tmp);
1922	this->_S_destroy_c_locale(__tmp);
1923	}
1924	}
1925
1926	#if __cplusplus >= 201103L
1927	explicit
1928	numpunct_byname(const string& __s, size_t __refs = `0`)
1929	: numpunct_byname(__s.c_str(), __refs) { }
1930	#endif
1931
1932	protected:
1933	virtual
1934	~numpunct_byname() { }
1935	};
1936
1937	_GLIBCXX_END_NAMESPACE_CXX11
1938
1939	_GLIBCXX_BEGIN_NAMESPACE_LDBL
1940
1941	/**
1942	* @brief Primary class template num_get.
1943	* @ingroup locales
1944	*
1945	* This facet encapsulates the code to parse and return a number
1946	* from a string. It is used by the istream numeric extraction
1947	* operators.
1948	*
1949	* The num_get template uses protected virtual functions to provide the
1950	* actual results. The public accessors forward the call to the virtual
1951	* functions. These virtual functions are hooks for developers to
1952	* implement the behavior they require from the num_get facet.
1953	*/
1954	template<typename _CharT, typename _InIter>
1955	class num_get : public locale::facet
1956	{
1957	public:
1958	// Types:
1959	///@{
1960	/// Public typedefs
1961	typedef _CharT char_type;
1962	typedef _InIter iter_type;
1963	///@}
1964
1965	/// Numpunct facet id.
1966	static locale::id id;
1967
1968	/**
1969	* @brief Constructor performs initialization.
1970	*
1971	* This is the constructor provided by the standard.
1972	*
1973	* @param __refs Passed to the base facet class.
1974	*/
1975	explicit
1976	num_get(size_t __refs = `0`) : facet(__refs) { }
1977
1978	/**
1979	* @brief Numeric parsing.
1980	*
1981	* Parses the input stream into the bool @a v. It does so by calling
1982	* num_get::do_get().
1983	*
1984	* If ios_base::boolalpha is set, attempts to read
1985	* ctype<CharT>::truename() or ctype<CharT>::falsename(). Sets
1986	* @a v to true or false if successful. Sets err to
1987	* ios_base::failbit if reading the string fails. Sets err to
1988	* ios_base::eofbit if the stream is emptied.
1989	*
1990	* If ios_base::boolalpha is not set, proceeds as with reading a long,
1991	* except if the value is 1, sets @a v to true, if the value is 0, sets
1992	* @a v to false, and otherwise set err to ios_base::failbit.
1993	*
1994	* @param __in Start of input stream.
1995	* @param __end End of input stream.
1996	* @param __io Source of locale and flags.
1997	* @param __err Error flags to set.
1998	* @param __v Value to format and insert.
1999	* @return Iterator after reading.
2000	*/
2001	iter_type
2002	get(iter_type __in, iter_type __end, ios_base& __io,
2003	ios_base::iostate& __err, bool& __v) const
2004	{ return this->do_get(__in, __end, __io, __err, __v); }
2005
2006	///@{
2007	/**
2008	* @brief Numeric parsing.
2009	*
2010	* Parses the input stream into the integral variable @a v. It does so
2011	* by calling num_get::do_get().
2012	*
2013	* Parsing is affected by the flag settings in @a io.
2014	*
2015	* The basic parse is affected by the value of io.flags() &
2016	* ios_base::basefield. If equal to ios_base::oct, parses like the
2017	* scanf %o specifier. Else if equal to ios_base::hex, parses like %X
2018	* specifier. Else if basefield equal to 0, parses like the %i
2019	* specifier. Otherwise, parses like %d for signed and %u for unsigned
2020	* types. The matching type length modifier is also used.
2021	*
2022	* Digit grouping is interpreted according to
2023	* numpunct::grouping() and numpunct::thousands_sep(). If the
2024	* pattern of digit groups isn't consistent, sets err to
2025	* ios_base::failbit.
2026	*
2027	* If parsing the string yields a valid value for @a v, @a v is set.
2028	* Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2029	* Sets err to ios_base::eofbit if the stream is emptied.
2030	*
2031	* @param __in Start of input stream.
2032	* @param __end End of input stream.
2033	* @param __io Source of locale and flags.
2034	* @param __err Error flags to set.
2035	* @param __v Value to format and insert.
2036	* @return Iterator after reading.
2037	*/
2038	iter_type
2039	get(iter_type __in, iter_type __end, ios_base& __io,
2040	ios_base::iostate& __err, long& __v) const
2041	{ return this->do_get(__in, __end, __io, __err, __v); }
2042
2043	iter_type
2044	get(iter_type __in, iter_type __end, ios_base& __io,
2045	ios_base::iostate& __err, unsigned short& __v) const
2046	{ return this->do_get(__in, __end, __io, __err, __v); }
2047
2048	iter_type
2049	get(iter_type __in, iter_type __end, ios_base& __io,
2050	ios_base::iostate& __err, unsigned int& __v) const
2051	{ return this->do_get(__in, __end, __io, __err, __v); }
2052
2053	iter_type
2054	get(iter_type __in, iter_type __end, ios_base& __io,
2055	ios_base::iostate& __err, unsigned long& __v) const
2056	{ return this->do_get(__in, __end, __io, __err, __v); }
2057
2058	#ifdef _GLIBCXX_USE_LONG_LONG
2059	iter_type
2060	get(iter_type __in, iter_type __end, ios_base& __io,
2061	ios_base::iostate& __err, long long& __v) const
2062	{ return this->do_get(__in, __end, __io, __err, __v); }
2063
2064	iter_type
2065	get(iter_type __in, iter_type __end, ios_base& __io,
2066	ios_base::iostate& __err, unsigned long long& __v) const
2067	{ return this->do_get(__in, __end, __io, __err, __v); }
2068	#endif
2069	///@}
2070
2071	///@{
2072	/**
2073	* @brief Numeric parsing.
2074	*
2075	* Parses the input stream into the integral variable @a v. It does so
2076	* by calling num_get::do_get().
2077	*
2078	* The input characters are parsed like the scanf %g specifier. The
2079	* matching type length modifier is also used.
2080	*
2081	* The decimal point character used is numpunct::decimal_point().
2082	* Digit grouping is interpreted according to
2083	* numpunct::grouping() and numpunct::thousands_sep(). If the
2084	* pattern of digit groups isn't consistent, sets err to
2085	* ios_base::failbit.
2086	*
2087	* If parsing the string yields a valid value for @a v, @a v is set.
2088	* Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2089	* Sets err to ios_base::eofbit if the stream is emptied.
2090	*
2091	* @param __in Start of input stream.
2092	* @param __end End of input stream.
2093	* @param __io Source of locale and flags.
2094	* @param __err Error flags to set.
2095	* @param __v Value to format and insert.
2096	* @return Iterator after reading.
2097	*/
2098	iter_type
2099	get(iter_type __in, iter_type __end, ios_base& __io,
2100	ios_base::iostate& __err, float& __v) const
2101	{ return this->do_get(__in, __end, __io, __err, __v); }
2102
2103	iter_type
2104	get(iter_type __in, iter_type __end, ios_base& __io,
2105	ios_base::iostate& __err, double& __v) const
2106	{ return this->do_get(__in, __end, __io, __err, __v); }
2107
2108	iter_type
2109	get(iter_type __in, iter_type __end, ios_base& __io,
2110	ios_base::iostate& __err, long double& __v) const
2111	{ return this->do_get(__in, __end, __io, __err, __v); }
2112	///@}
2113
2114	/**
2115	* @brief Numeric parsing.
2116	*
2117	* Parses the input stream into the pointer variable @a v. It does so
2118	* by calling num_get::do_get().
2119	*
2120	* The input characters are parsed like the scanf %p specifier.
2121	*
2122	* Digit grouping is interpreted according to
2123	* numpunct::grouping() and numpunct::thousands_sep(). If the
2124	* pattern of digit groups isn't consistent, sets err to
2125	* ios_base::failbit.
2126	*
2127	* Note that the digit grouping effect for pointers is a bit ambiguous
2128	* in the standard and shouldn't be relied on. See DR 344.
2129	*
2130	* If parsing the string yields a valid value for @a v, @a v is set.
2131	* Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2132	* Sets err to ios_base::eofbit if the stream is emptied.
2133	*
2134	* @param __in Start of input stream.
2135	* @param __end End of input stream.
2136	* @param __io Source of locale and flags.
2137	* @param __err Error flags to set.
2138	* @param __v Value to format and insert.
2139	* @return Iterator after reading.
2140	*/
2141	iter_type
2142	get(iter_type __in, iter_type __end, ios_base& __io,
2143	ios_base::iostate& __err, void& __v) const*
2144	{ return this->do_get(__in, __end, __io, __err, __v); }
2145
2146	protected:
2147	/// Destructor.
2148	virtual ~num_get() { }
2149
2150	_GLIBCXX_DEFAULT_ABI_TAG
2151	iter_type
2152	_M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
2153	string&) const;
2154
2155	template<typename _ValueT>
2156	_GLIBCXX_DEFAULT_ABI_TAG
2157	iter_type
2158	_M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
2159	_ValueT&) const;
2160
2161	template<typename _CharT2>
2162	typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
2163	_M_find(const _CharT2, size_t __len, _CharT2 __c) const*
2164	{
2165	int __ret = -`1`;
2166	if (__len <= `10`)
2167	{
2168	if (__c >= _CharT2(`'0'`) && __c < _CharT2(_CharT2(`'0'`) + __len))
2169	__ret = __c - _CharT2(`'0'`);
2170	}
2171	else
2172	{
2173	if (__c >= _CharT2(`'0'`) && __c <= _CharT2(`'9'`))
2174	__ret = __c - _CharT2(`'0'`);
2175	else if (__c >= _CharT2(`'a'`) && __c <= _CharT2(`'f'`))
2176	__ret = `10` + (__c - _CharT2(`'a'`));
2177	else if (__c >= _CharT2(`'A'`) && __c <= _CharT2(`'F'`))
2178	__ret = `10` + (__c - _CharT2(`'A'`));
2179	}
2180	return __ret;
2181	}
2182
2183	template<typename _CharT2>
2184	typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
2185	int>::__type
2186	_M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
2187	{
2188	int __ret = -`1`;
2189	const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
2190	if (__q)
2191	{
2192	__ret = __q - __zero;
2193	if (__ret > `15`)
2194	__ret -= `6`;
2195	}
2196	return __ret;
2197	}
2198
2199	///@{
2200	/**
2201	* @brief Numeric parsing.
2202	*
2203	* Parses the input stream into the variable @a v. This function is a
2204	* hook for derived classes to change the value returned. @see get()
2205	* for more details.
2206	*
2207	* @param __beg Start of input stream.
2208	* @param __end End of input stream.
2209	* @param __io Source of locale and flags.
2210	* @param __err Error flags to set.
2211	* @param __v Value to format and insert.
2212	* @return Iterator after reading.
2213	*/
2214	virtual iter_type
2215	do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
2216
2217	virtual iter_type
2218	do_get(iter_type __beg, iter_type __end, ios_base& __io,
2219	ios_base::iostate& __err, long& __v) const
2220	{ return _M_extract_int(__beg, __end, __io, __err, __v); }
2221
2222	virtual iter_type
2223	do_get(iter_type __beg, iter_type __end, ios_base& __io,
2224	ios_base::iostate& __err, unsigned short& __v) const
2225	{ return _M_extract_int(__beg, __end, __io, __err, __v); }
2226
2227	virtual iter_type
2228	do_get(iter_type __beg, iter_type __end, ios_base& __io,
2229	ios_base::iostate& __err, unsigned int& __v) const
2230	{ return _M_extract_int(__beg, __end, __io, __err, __v); }
2231
2232	virtual iter_type
2233	do_get(iter_type __beg, iter_type __end, ios_base& __io,
2234	ios_base::iostate& __err, unsigned long& __v) const
2235	{ return _M_extract_int(__beg, __end, __io, __err, __v); }
2236
2237	#ifdef _GLIBCXX_USE_LONG_LONG
2238	virtual iter_type
2239	do_get(iter_type __beg, iter_type __end, ios_base& __io,
2240	ios_base::iostate& __err, long long& __v) const
2241	{ return _M_extract_int(__beg, __end, __io, __err, __v); }
2242
2243	virtual iter_type
2244	do_get(iter_type __beg, iter_type __end, ios_base& __io,
2245	ios_base::iostate& __err, unsigned long long& __v) const
2246	{ return _M_extract_int(__beg, __end, __io, __err, __v); }
2247	#endif
2248
2249	virtual iter_type
2250	do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
2251
2252	virtual iter_type
2253	do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
2254	double&) const;
2255
2256	// XXX GLIBCXX_ABI Deprecated
2257	#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
2258	// For __gnu_cxx_ldbl128::num_get and __gnu_cxx_ieee128::num_get
2259	// this entry in the vtable is for a 64-bit "long double" with the
2260	// same format as double. This keeps the vtable layout consistent
2261	// with std::num_get (visible when -mlong-double-64 is used).
2262	virtual iter_type
2263	__do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
2264	double&) const;
2265	#else
2266	virtual iter_type
2267	do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
2268	long double&) const;
2269	#endif
2270
2271	virtual iter_type
2272	do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void&) const*;
2273
2274	// XXX GLIBCXX_ABI Deprecated
2275	#if defined _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT \
2276	&& defined __LONG_DOUBLE_IEEE128__
2277	// For __gnu_cxx_ieee128::num_get this entry in the vtable is for
2278	// the non-IEEE 128-bit "long double" (aka "double double"). This
2279	// is consistent with __gnu_cxx_ldbl128::num_get (-mabi=ibmlongdouble)
2280	virtual iter_type
2281	__do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
2282	__ibm128&) const;
2283	#endif
2284
2285	// XXX GLIBCXX_ABI Deprecated
2286	#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
2287	// For __gnu_cxx_ldbl128::num_get and __gnu_cxx_ieee128::num_get
2288	// this entry in the vtable is for the 128-bit "long double" type.
2289	virtual iter_type
2290	do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
2291	long double&) const;
2292	#endif
2293	///@}
2294	};
2295
2296	template<typename _CharT, typename _InIter>
2297	locale::id num_get<_CharT, _InIter>::id;
2298
2299
2300	/**
2301	* @brief Primary class template num_put.
2302	* @ingroup locales
2303	*
2304	* This facet encapsulates the code to convert a number to a string. It is
2305	* used by the ostream numeric insertion operators.
2306	*
2307	* The num_put template uses protected virtual functions to provide the
2308	* actual results. The public accessors forward the call to the virtual
2309	* functions. These virtual functions are hooks for developers to
2310	* implement the behavior they require from the num_put facet.
2311	*/
2312	template<typename _CharT, typename _OutIter>
2313	class num_put : public locale::facet
2314	{
2315	public:
2316	// Types:
2317	///@{
2318	/// Public typedefs
2319	typedef _CharT char_type;
2320	typedef _OutIter iter_type;
2321	///@}
2322
2323	/// Numpunct facet id.
2324	static locale::id id;
2325
2326	/**
2327	* @brief Constructor performs initialization.
2328	*
2329	* This is the constructor provided by the standard.
2330	*
2331	* @param __refs Passed to the base facet class.
2332	*/
2333	explicit
2334	num_put(size_t __refs = `0`) : facet(__refs) { }
2335
2336	/**
2337	* @brief Numeric formatting.
2338	*
2339	* Formats the boolean @a v and inserts it into a stream. It does so
2340	* by calling num_put::do_put().
2341	*
2342	* If ios_base::boolalpha is set, writes ctype<CharT>::truename() or
2343	* ctype<CharT>::falsename(). Otherwise formats @a v as an int.
2344	*
2345	* @param __s Stream to write to.
2346	* @param __io Source of locale and flags.
2347	* @param __fill Char_type to use for filling.
2348	* @param __v Value to format and insert.
2349	* @return Iterator after writing.
2350	*/
2351	iter_type
2352	put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
2353	{ return this->do_put(__s, __io, __fill, __v); }
2354
2355	///@{
2356	/**
2357	* @brief Numeric formatting.
2358	*
2359	* Formats the integral value @a v and inserts it into a
2360	* stream. It does so by calling num_put::do_put().
2361	*
2362	* Formatting is affected by the flag settings in @a io.
2363	*
2364	* The basic format is affected by the value of io.flags() &
2365	* ios_base::basefield. If equal to ios_base::oct, formats like the
2366	* printf %o specifier. Else if equal to ios_base::hex, formats like
2367	* %x or %X with ios_base::uppercase unset or set respectively.
2368	* Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu
2369	* for unsigned values. Note that if both oct and hex are set, neither
2370	* will take effect.
2371	*
2372	* If ios_base::showpos is set, '+' is output before positive values.
2373	* If ios_base::showbase is set, '0' precedes octal values (except 0)
2374	* and '0[xX]' precedes hex values.
2375	*
2376	* The decimal point character used is numpunct::decimal_point().
2377	* Thousands separators are inserted according to
2378	* numpunct::grouping() and numpunct::thousands_sep().
2379	*
2380	* If io.width() is non-zero, enough @a fill characters are inserted to
2381	* make the result at least that wide. If
2382	* (io.flags() & ios_base::adjustfield) == ios_base::left, result is
2383	* padded at the end. If ios_base::internal, then padding occurs
2384	* immediately after either a '+' or '-' or after '0x' or '0X'.
2385	* Otherwise, padding occurs at the beginning.
2386	*
2387	* @param __s Stream to write to.
2388	* @param __io Source of locale and flags.
2389	* @param __fill Char_type to use for filling.
2390	* @param __v Value to format and insert.
2391	* @return Iterator after writing.
2392	*/
2393	iter_type
2394	put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
2395	{ return this->do_put(__s, __io, __fill, __v); }
2396
2397	iter_type
2398	put(iter_type __s, ios_base& __io, char_type __fill,
2399	unsigned long __v) const
2400	{ return this->do_put(__s, __io, __fill, __v); }
2401
2402	#ifdef _GLIBCXX_USE_LONG_LONG
2403	iter_type
2404	put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
2405	{ return this->do_put(__s, __io, __fill, __v); }
2406
2407	iter_type
2408	put(iter_type __s, ios_base& __io, char_type __fill,
2409	unsigned long long __v) const
2410	{ return this->do_put(__s, __io, __fill, __v); }
2411	#endif
2412	///@}
2413
2414	///@{
2415	/**
2416	* @brief Numeric formatting.
2417	*
2418	* Formats the floating point value @a v and inserts it into a stream.
2419	* It does so by calling num_put::do_put().
2420	*
2421	* Formatting is affected by the flag settings in @a io.
2422	*
2423	* The basic format is affected by the value of io.flags() &
2424	* ios_base::floatfield. If equal to ios_base::fixed, formats like the
2425	* printf %f specifier. Else if equal to ios_base::scientific, formats
2426	* like %e or %E with ios_base::uppercase unset or set respectively.
2427	* Otherwise, formats like %g or %G depending on uppercase. Note that
2428	* if both fixed and scientific are set, the effect will also be like
2429	* %g or %G.
2430	*
2431	* The output precision is given by io.precision(). This precision is
2432	* capped at numeric_limits::digits10 + 2 (different for double and
2433	* long double). The default precision is 6.
2434	*
2435	* If ios_base::showpos is set, '+' is output before positive values.
2436	* If ios_base::showpoint is set, a decimal point will always be
2437	* output.
2438	*
2439	* The decimal point character used is numpunct::decimal_point().
2440	* Thousands separators are inserted according to
2441	* numpunct::grouping() and numpunct::thousands_sep().
2442	*
2443	* If io.width() is non-zero, enough @a fill characters are inserted to
2444	* make the result at least that wide. If
2445	* (io.flags() & ios_base::adjustfield) == ios_base::left, result is
2446	* padded at the end. If ios_base::internal, then padding occurs
2447	* immediately after either a '+' or '-' or after '0x' or '0X'.
2448	* Otherwise, padding occurs at the beginning.
2449	*
2450	* @param __s Stream to write to.
2451	* @param __io Source of locale and flags.
2452	* @param __fill Char_type to use for filling.
2453	* @param __v Value to format and insert.
2454	* @return Iterator after writing.
2455	*/
2456	iter_type
2457	put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
2458	{ return this->do_put(__s, __io, __fill, __v); }
2459
2460	iter_type
2461	put(iter_type __s, ios_base& __io, char_type __fill,
2462	long double __v) const
2463	{ return this->do_put(__s, __io, __fill, __v); }
2464	///@}
2465
2466	/**
2467	* @brief Numeric formatting.
2468	*
2469	* Formats the pointer value @a v and inserts it into a stream. It
2470	* does so by calling num_put::do_put().
2471	*
2472	* This function formats @a v as an unsigned long with ios_base::hex
2473	* and ios_base::showbase set.
2474	*
2475	* @param __s Stream to write to.
2476	* @param __io Source of locale and flags.
2477	* @param __fill Char_type to use for filling.
2478	* @param __v Value to format and insert.
2479	* @return Iterator after writing.
2480	*/
2481	iter_type
2482	put(iter_type __s, ios_base& __io, char_type __fill,
2483	const void* __v) const
2484	{ return this->do_put(__s, __io, __fill, __v); }
2485
2486	protected:
2487	template<typename _ValueT>
2488	iter_type
2489	_M_insert_float(iter_type, ios_base& __io, char_type __fill,
2490	char __mod, _ValueT __v) const;
2491
2492	void
2493	_M_group_float(const char* __grouping, size_t __grouping_size,
2494	char_type __sep, const char_type* __p, char_type* __new,
2495	char_type* __cs, int& __len) const;
2496
2497	template<typename _ValueT>
2498	iter_type
2499	_M_insert_int(iter_type, ios_base& __io, char_type __fill,
2500	_ValueT __v) const;
2501
2502	void
2503	_M_group_int(const char* __grouping, size_t __grouping_size,
2504	char_type __sep, ios_base& __io, char_type* __new,
2505	char_type* __cs, int& __len) const;
2506
2507	void
2508	_M_pad(char_type __fill, streamsize __w, ios_base& __io,
2509	char_type* __new, const char_type* __cs, int& __len) const;
2510
2511	/// Destructor.
2512	virtual
2513	~num_put() { }
2514
2515	///@{
2516	/**
2517	* @brief Numeric formatting.
2518	*
2519	* These functions do the work of formatting numeric values and
2520	* inserting them into a stream. This function is a hook for derived
2521	* classes to change the value returned.
2522	*
2523	* @param __s Stream to write to.
2524	* @param __io Source of locale and flags.
2525	* @param __fill Char_type to use for filling.
2526	* @param __v Value to format and insert.
2527	* @return Iterator after writing.
2528	*/
2529	virtual iter_type
2530	do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
2531
2532	virtual iter_type
2533	do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
2534	{ return _M_insert_int(__s, __io, __fill, __v); }
2535
2536	virtual iter_type
2537	do_put(iter_type __s, ios_base& __io, char_type __fill,
2538	unsigned long __v) const
2539	{ return _M_insert_int(__s, __io, __fill, __v); }
2540
2541	#ifdef _GLIBCXX_USE_LONG_LONG
2542	virtual iter_type
2543	do_put(iter_type __s, ios_base& __io, char_type __fill,
2544	long long __v) const
2545	{ return _M_insert_int(__s, __io, __fill, __v); }
2546
2547	virtual iter_type
2548	do_put(iter_type __s, ios_base& __io, char_type __fill,
2549	unsigned long long __v) const
2550	{ return _M_insert_int(__s, __io, __fill, __v); }
2551	#endif
2552
2553	virtual iter_type
2554	do_put(iter_type, ios_base&, char_type, double) const;
2555
2556	// XXX GLIBCXX_ABI Deprecated
2557	#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
2558	virtual iter_type
2559	__do_put(iter_type, ios_base&, char_type, double) const;
2560	#else
2561	virtual iter_type
2562	do_put(iter_type, ios_base&, char_type, long double) const;
2563	#endif
2564
2565	virtual iter_type
2566	do_put(iter_type, ios_base&, char_type, const void) const*;
2567
2568	// XXX GLIBCXX_ABI Deprecated
2569	#if defined _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT \
2570	&& defined __LONG_DOUBLE_IEEE128__
2571	virtual iter_type
2572	__do_put(iter_type, ios_base&, char_type, __ibm128) const;
2573	#endif
2574
2575	// XXX GLIBCXX_ABI Deprecated
2576	#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
2577	virtual iter_type
2578	do_put(iter_type, ios_base&, char_type, long double) const;
2579	#endif
2580	///@}
2581	};
2582
2583	template <typename _CharT, typename _OutIter>
2584	locale::id num_put<_CharT, _OutIter>::id;
2585
2586	_GLIBCXX_END_NAMESPACE_LDBL
2587
2588	// Subclause convenience interfaces, inlines.
2589	// NB: These are inline because, when used in a loop, some compilers
2590	// can hoist the body out of the loop; then it's just as fast as the
2591	// C is() function.*
2592
2593	/// Convenience interface to ctype.is(ctype_base::space, __c).
2594	template<typename _CharT>
2595	inline bool
2596	isspace(_CharT __c, const locale& __loc)
2597	{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
2598
2599	/// Convenience interface to ctype.is(ctype_base::print, __c).
2600	template<typename _CharT>
2601	inline bool
2602	isprint(_CharT __c, const locale& __loc)
2603	{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
2604
2605	/// Convenience interface to ctype.is(ctype_base::cntrl, __c).
2606	template<typename _CharT>
2607	inline bool
2608	iscntrl(_CharT __c, const locale& __loc)
2609	{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
2610
2611	/// Convenience interface to ctype.is(ctype_base::upper, __c).
2612	template<typename _CharT>
2613	inline bool
2614	isupper(_CharT __c, const locale& __loc)
2615	{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
2616
2617	/// Convenience interface to ctype.is(ctype_base::lower, __c).
2618	template<typename _CharT>
2619	inline bool
2620	islower(_CharT __c, const locale& __loc)
2621	{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
2622
2623	/// Convenience interface to ctype.is(ctype_base::alpha, __c).
2624	template<typename _CharT>
2625	inline bool
2626	isalpha(_CharT __c, const locale& __loc)
2627	{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
2628
2629	/// Convenience interface to ctype.is(ctype_base::digit, __c).
2630	template<typename _CharT>
2631	inline bool
2632	isdigit(_CharT __c, const locale& __loc)
2633	{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
2634
2635	/// Convenience interface to ctype.is(ctype_base::punct, __c).
2636	template<typename _CharT>
2637	inline bool
2638	ispunct(_CharT __c, const locale& __loc)
2639	{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
2640
2641	/// Convenience interface to ctype.is(ctype_base::xdigit, __c).
2642	template<typename _CharT>
2643	inline bool
2644	isxdigit(_CharT __c, const locale& __loc)
2645	{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
2646
2647	/// Convenience interface to ctype.is(ctype_base::alnum, __c).
2648	template<typename _CharT>
2649	inline bool
2650	isalnum(_CharT __c, const locale& __loc)
2651	{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
2652
2653	/// Convenience interface to ctype.is(ctype_base::graph, __c).
2654	template<typename _CharT>
2655	inline bool
2656	isgraph(_CharT __c, const locale& __loc)
2657	{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
2658
2659	#if __cplusplus >= 201103L
2660	/// Convenience interface to ctype.is(ctype_base::blank, __c).
2661	template<typename _CharT>
2662	inline bool
2663	isblank(_CharT __c, const locale& __loc)
2664	{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }
2665	#endif
2666
2667	/// Convenience interface to ctype.toupper(__c).
2668	template<typename _CharT>
2669	inline _CharT
2670	toupper(_CharT __c, const locale& __loc)
2671	{ return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
2672
2673	/// Convenience interface to ctype.tolower(__c).
2674	template<typename _CharT>
2675	inline _CharT
2676	tolower(_CharT __c, const locale& __loc)
2677	{ return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
2678
2679	_GLIBCXX_END_NAMESPACE_VERSION
2680	} // namespace std
2681
2682	# include <bits/locale_facets.tcc>
2683
2684	#endif
2685

Source File include/c++/11/bits/locale_facets.hHome Page Browse Root

Source File include/c++/11/bits/locale_facets.h
Home Page Browse Root