OSDN Git Service

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