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