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

---

Generated while processing qt4/src/3rdparty/clucene/src/CLucene/StdHeader.cpp
Generated on 2014-Aug-03 from project include
Powered by Code Browser 1.7