OSDN Git Service

* include/bits/basic_string.h, include/bits/locale_facets.h: Fix
[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 // Free Software Foundation, Inc.
5 //
6 // This file is part of the GNU ISO C++ Library.  This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 2, or (at your option)
10 // any later version.
11
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 // GNU General Public License for more details.
16
17 // You should have received a copy of the GNU General Public License along
18 // with this library; see the file COPYING.  If not, write to the Free
19 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20 // USA.
21
22 // As a special exception, you may use this file as part of a free software
23 // library without restriction.  Specifically, if other files instantiate
24 // templates or use macros or inline functions from this file, or you compile
25 // this file and link it with other files to produce an executable, this
26 // file does not by itself cause the resulting executable to be covered by
27 // the GNU General Public License.  This exception does not however
28 // invalidate any other reasons why the executable file might be covered by
29 // the GNU General Public License.
30
31 //
32 // ISO C++ 14882: 22.1  Locales
33 //
34
35 /** @file locale_facets.h
36  *  This is an internal header file, included by other library headers.
37  *  You should not attempt to use it directly.
38  */
39
40 #ifndef _LOCALE_FACETS_H
41 #define _LOCALE_FACETS_H 1
42
43 #pragma GCC system_header
44
45 #include <ctime>        // For struct tm
46 #include <cwctype>      // For wctype_t
47 #include <iosfwd>
48 #include <bits/ios_base.h>  // For ios_base, ios_base::iostate
49 #include <streambuf>
50
51 namespace std
52 {
53   // NB: Don't instantiate required wchar_t facets if no wchar_t support.
54 #ifdef _GLIBCXX_USE_WCHAR_T
55 # define  _GLIBCXX_NUM_FACETS 28
56 #else
57 # define  _GLIBCXX_NUM_FACETS 14
58 #endif
59
60   // Convert string to numeric value of type _Tv and store results.
61   // NB: This is specialized for all required types, there is no
62   // generic definition.
63   template<typename _Tv>
64     void
65     __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err,
66                    const __c_locale& __cloc);
67
68   // Explicit specializations for required types.
69   template<>
70     void
71     __convert_to_v(const char*, float&, ios_base::iostate&,
72                    const __c_locale&);
73
74   template<>
75     void
76     __convert_to_v(const char*, double&, ios_base::iostate&,
77                    const __c_locale&);
78
79   template<>
80     void
81     __convert_to_v(const char*, long double&, ios_base::iostate&,
82                    const __c_locale&);
83
84   // NB: __pad is a struct, rather than a function, so it can be
85   // partially-specialized.
86   template<typename _CharT, typename _Traits>
87     struct __pad
88     {
89       static void
90       _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
91              const _CharT* __olds, const streamsize __newlen,
92              const streamsize __oldlen, const bool __num);
93     };
94
95   // Used by both numeric and monetary facets.
96   // Inserts "group separator" characters into an array of characters.
97   // It's recursive, one iteration per group.  It moves the characters
98   // in the buffer this way: "xxxx12345" -> "12,345xxx".  Call this
99   // only with __glen != 0.
100   template<typename _CharT>
101     _CharT*
102     __add_grouping(_CharT* __s, _CharT __sep,
103                    const char* __gbeg, size_t __gsize,
104                    const _CharT* __first, const _CharT* __last);
105
106   // This template permits specializing facet output code for
107   // ostreambuf_iterator.  For ostreambuf_iterator, sputn is
108   // significantly more efficient than incrementing iterators.
109   template<typename _CharT>
110     inline
111     ostreambuf_iterator<_CharT>
112     __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
113     {
114       __s._M_put(__ws, __len);
115       return __s;
116     }
117
118   // This is the unspecialized form of the template.
119   template<typename _CharT, typename _OutIter>
120     inline
121     _OutIter
122     __write(_OutIter __s, const _CharT* __ws, int __len)
123     {
124       for (int __j = 0; __j < __len; __j++, ++__s)
125         *__s = __ws[__j];
126       return __s;
127     }
128
129
130   // 22.2.1.1  Template class ctype
131   // Include host and configuration specific ctype enums for ctype_base.
132   #include <bits/ctype_base.h>
133
134   // Common base for ctype<_CharT>.
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 abtract 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 mask @a m.
156        *  It does so by returning the value of ctype<char_type>::do_is().
157        *
158        *  @param c  The char_type to compare the mask of.
159        *  @param m  The mask to compare against.
160        *  @return  (M & m) != 0.
161       */
162       bool
163       is(mask __m, char_type __c) const
164       { return this->do_is(__m, __c); }
165
166       /**
167        *  @brief  Return a mask array.
168        *
169        *  This function finds the mask for each char_type in the range [lo,hi)
170        *  and successively writes it to vec.  vec must have as many elements
171        *  as the char array.  It does so by returning the value of
172        *  ctype<char_type>::do_is().
173        *
174        *  @param lo  Pointer to start of range.
175        *  @param hi  Pointer to end of range.
176        *  @param vec  Pointer to an array of mask storage.
177        *  @return  @a hi.
178       */
179       const char_type*
180       is(const char_type *__lo, const char_type *__hi, mask *__vec) const
181       { return this->do_is(__lo, __hi, __vec); }
182
183       /**
184        *  @brief  Find char_type matching a mask
185        *
186        *  This function searches for and returns the first char_type c in
187        *  [lo,hi) for which is(m,c) is true.  It does so by returning
188        *  ctype<char_type>::do_scan_is().
189        *
190        *  @param m  The mask to compare against.
191        *  @param lo  Pointer to start of range.
192        *  @param hi  Pointer to end of range.
193        *  @return  Pointer to matching char_type if found, else @a hi.
194       */
195       const char_type*
196       scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
197       { return this->do_scan_is(__m, __lo, __hi); }
198
199       /**
200        *  @brief  Find char_type not matching a mask
201        *
202        *  This function searches for and returns the first char_type c in
203        *  [lo,hi) for which is(m,c) is false.  It does so by returning
204        *  ctype<char_type>::do_scan_not().
205        *
206        *  @param m  The mask to compare against.
207        *  @param lo  Pointer to first char in range.
208        *  @param hi  Pointer to end of range.
209        *  @return  Pointer to non-matching char if found, else @a hi.
210       */
211       const char_type*
212       scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
213       { return this->do_scan_not(__m, __lo, __hi); }
214
215       /**
216        *  @brief  Convert to uppercase.
217        *
218        *  This function converts the argument to uppercase if possible.
219        *  If not possible (for example, '2'), returns the argument.  It does
220        *  so by returning ctype<char_type>::do_toupper().
221        *
222        *  @param c  The char_type to convert.
223        *  @return  The uppercase char_type if convertible, else @a c.
224       */
225       char_type
226       toupper(char_type __c) const
227       { return this->do_toupper(__c); }
228
229       /**
230        *  @brief  Convert array to uppercase.
231        *
232        *  This function converts each char_type in the range [lo,hi) to
233        *  uppercase if possible.  Other elements remain untouched.  It does so
234        *  by returning ctype<char_type>:: do_toupper(lo, hi).
235        *
236        *  @param lo  Pointer to start of range.
237        *  @param hi  Pointer to end of range.
238        *  @return  @a hi.
239       */
240       const char_type*
241       toupper(char_type *__lo, const char_type* __hi) const
242       { return this->do_toupper(__lo, __hi); }
243
244       /**
245        *  @brief  Convert to lowercase.
246        *
247        *  This function converts the argument to lowercase if possible.  If
248        *  not possible (for example, '2'), returns the argument.  It does so
249        *  by returning ctype<char_type>::do_tolower(c).
250        *
251        *  @param c  The char_type to convert.
252        *  @return  The lowercase char_type if convertible, else @a c.
253       */
254       char_type
255       tolower(char_type __c) const
256       { return this->do_tolower(__c); }
257
258       /**
259        *  @brief  Convert array to lowercase.
260        *
261        *  This function converts each char_type in the range [lo,hi) to
262        *  lowercase if possible.  Other elements remain untouched.  It does so
263        *  by returning ctype<char_type>:: do_tolower(lo, hi).
264        *
265        *  @param lo  Pointer to start of range.
266        *  @param hi  Pointer to end of range.
267        *  @return  @a hi.
268       */
269       const char_type*
270       tolower(char_type* __lo, const char_type* __hi) const
271       { return this->do_tolower(__lo, __hi); }
272
273       /**
274        *  @brief  Widen char to char_type
275        *
276        *  This function converts the char argument to char_type using the
277        *  simplest reasonable transformation.  It does so by returning
278        *  ctype<char_type>::do_widen(c).
279        *
280        *  Note: this is not what you want for codepage conversions.  See
281        *  codecvt for that.
282        *
283        *  @param c  The char to convert.
284        *  @return  The converted char_type.
285       */
286       char_type
287       widen(char __c) const
288       { return this->do_widen(__c); }
289
290       /**
291        *  @brief  Widen array to char_type
292        *
293        *  This function converts each char in the input to char_type using the
294        *  simplest reasonable transformation.  It does so by returning
295        *  ctype<char_type>::do_widen(c).
296        *
297        *  Note: this is not what you want for codepage conversions.  See
298        *  codecvt for that.
299        *
300        *  @param lo  Pointer to start of range.
301        *  @param hi  Pointer to end of range.
302        *  @param to  Pointer to the destination array.
303        *  @return  @a hi.
304       */
305       const char*
306       widen(const char* __lo, const char* __hi, char_type* __to) const
307       { return this->do_widen(__lo, __hi, __to); }
308
309       /**
310        *  @brief  Narrow char_type to char
311        *
312        *  This function converts the char_type to char using the simplest
313        *  reasonable transformation.  If the conversion fails, dfault is
314        *  returned instead.  It does so by returning
315        *  ctype<char_type>::do_narrow(c).
316        *
317        *  Note: this is not what you want for codepage conversions.  See
318        *  codecvt for that.
319        *
320        *  @param c  The char_type to convert.
321        *  @param dfault  Char to return if conversion fails.
322        *  @return  The converted char.
323       */
324       char
325       narrow(char_type __c, char __dfault) const
326       { return this->do_narrow(__c, __dfault); }
327
328       /**
329        *  @brief  Narrow array to char array
330        *
331        *  This function converts each char_type in the input to char using the
332        *  simplest reasonable transformation and writes the results to the
333        *  destination array.  For any char_type in the input that cannot be
334        *  converted, @a dfault is used instead.  It does so by returning
335        *  ctype<char_type>::do_narrow(lo, hi, dfault, to).
336        *
337        *  Note: this is not what you want for codepage conversions.  See
338        *  codecvt for that.
339        *
340        *  @param lo  Pointer to start of range.
341        *  @param hi  Pointer to end of range.
342        *  @param dfault  Char to use if conversion fails.
343        *  @param to  Pointer to the destination array.
344        *  @return  @a hi.
345       */
346       const char_type*
347       narrow(const char_type* __lo, const char_type* __hi,
348               char __dfault, char *__to) const
349       { return this->do_narrow(__lo, __hi, __dfault, __to); }
350
351     protected:
352       explicit
353       __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
354
355       virtual
356       ~__ctype_abstract_base() { }
357
358       /**
359        *  @brief  Test char_type classification.
360        *
361        *  This function finds a mask M for @a c and compares it to mask @a m.
362        *
363        *  do_is() is a hook for a derived facet to change the behavior of
364        *  classifying.  do_is() must always return the same result for the
365        *  same input.
366        *
367        *  @param c  The char_type to find the mask of.
368        *  @param m  The mask to compare against.
369        *  @return  (M & m) != 0.
370       */
371       virtual bool
372       do_is(mask __m, char_type __c) const = 0;
373
374       /**
375        *  @brief  Return a mask array.
376        *
377        *  This function finds the mask for each char_type in the range [lo,hi)
378        *  and successively writes it to vec.  vec must have as many elements
379        *  as the input.
380        *
381        *  do_is() is a hook for a derived facet to change the behavior of
382        *  classifying.  do_is() must always return the same result for the
383        *  same input.
384        *
385        *  @param lo  Pointer to start of range.
386        *  @param hi  Pointer to end of range.
387        *  @param vec  Pointer to an array of mask storage.
388        *  @return  @a hi.
389       */
390       virtual const char_type*
391       do_is(const char_type* __lo, const char_type* __hi,
392             mask* __vec) const = 0;
393
394       /**
395        *  @brief  Find char_type matching mask
396        *
397        *  This function searches for and returns the first char_type c in
398        *  [lo,hi) for which is(m,c) is true.
399        *
400        *  do_scan_is() is a hook for a derived facet to change the behavior of
401        *  match searching.  do_is() must always return the same result for the
402        *  same input.
403        *
404        *  @param m  The mask to compare against.
405        *  @param lo  Pointer to start of range.
406        *  @param hi  Pointer to end of range.
407        *  @return  Pointer to a matching char_type if found, else @a hi.
408       */
409       virtual const char_type*
410       do_scan_is(mask __m, const char_type* __lo,
411                  const char_type* __hi) const = 0;
412
413       /**
414        *  @brief  Find char_type not matching mask
415        *
416        *  This function searches for and returns a pointer to the first
417        *  char_type c of [lo,hi) for which is(m,c) is false.
418        *
419        *  do_scan_is() is a hook for a derived facet to change the behavior of
420        *  match searching.  do_is() must always return the same result for the
421        *  same input.
422        *
423        *  @param m  The mask to compare against.
424        *  @param lo  Pointer to start of range.
425        *  @param hi  Pointer to end of range.
426        *  @return  Pointer to a non-matching char_type if found, else @a hi.
427       */
428       virtual const char_type*
429       do_scan_not(mask __m, const char_type* __lo,
430                   const char_type* __hi) const = 0;
431
432       /**
433        *  @brief  Convert to uppercase.
434        *
435        *  This virtual function converts the char_type argument to uppercase
436        *  if possible.  If not possible (for example, '2'), returns the
437        *  argument.
438        *
439        *  do_toupper() is a hook for a derived facet to change the behavior of
440        *  uppercasing.  do_toupper() must always return the same result for
441        *  the same input.
442        *
443        *  @param c  The char_type to convert.
444        *  @return  The uppercase char_type if convertible, else @a c.
445       */
446       virtual char_type
447       do_toupper(char_type) const = 0;
448
449       /**
450        *  @brief  Convert array to uppercase.
451        *
452        *  This virtual function converts each char_type in the range [lo,hi)
453        *  to uppercase if possible.  Other elements remain untouched.
454        *
455        *  do_toupper() is a hook for a derived facet to change the behavior of
456        *  uppercasing.  do_toupper() must always return the same result for
457        *  the same input.
458        *
459        *  @param lo  Pointer to start of range.
460        *  @param hi  Pointer to end of range.
461        *  @return  @a hi.
462       */
463       virtual const char_type*
464       do_toupper(char_type* __lo, const char_type* __hi) const = 0;
465
466       /**
467        *  @brief  Convert to lowercase.
468        *
469        *  This virtual function converts the argument to lowercase if
470        *  possible.  If not possible (for example, '2'), returns the argument.
471        *
472        *  do_tolower() is a hook for a derived facet to change the behavior of
473        *  lowercasing.  do_tolower() must always return the same result for
474        *  the same input.
475        *
476        *  @param c  The char_type to convert.
477        *  @return  The lowercase char_type if convertible, else @a c.
478       */
479       virtual char_type
480       do_tolower(char_type) const = 0;
481
482       /**
483        *  @brief  Convert array to lowercase.
484        *
485        *  This virtual function converts each char_type in the range [lo,hi)
486        *  to lowercase if possible.  Other elements remain untouched.
487        *
488        *  do_tolower() is a hook for a derived facet to change the behavior of
489        *  lowercasing.  do_tolower() must always return the same result for
490        *  the same input.
491        *
492        *  @param lo  Pointer to start of range.
493        *  @param hi  Pointer to end of range.
494        *  @return  @a hi.
495       */
496       virtual const char_type*
497       do_tolower(char_type* __lo, const char_type* __hi) const = 0;
498
499       /**
500        *  @brief  Widen char
501        *
502        *  This virtual function converts the char to char_type using the
503        *  simplest reasonable transformation.
504        *
505        *  do_widen() is a hook for a derived facet to change the behavior of
506        *  widening.  do_widen() must always return the same result for the
507        *  same input.
508        *
509        *  Note: this is not what you want for codepage conversions.  See
510        *  codecvt for that.
511        *
512        *  @param c  The char to convert.
513        *  @return  The converted char_type
514       */
515       virtual char_type
516       do_widen(char) const = 0;
517
518       /**
519        *  @brief  Widen char array
520        *
521        *  This function converts each char in the input to char_type using the
522        *  simplest reasonable transformation.
523        *
524        *  do_widen() is a hook for a derived facet to change the behavior of
525        *  widening.  do_widen() must always return the same result for the
526        *  same input.
527        *
528        *  Note: this is not what you want for codepage conversions.  See
529        *  codecvt for that.
530        *
531        *  @param lo  Pointer to start range.
532        *  @param hi  Pointer to end of range.
533        *  @param to  Pointer to the destination array.
534        *  @return  @a hi.
535       */
536       virtual const char*
537       do_widen(const char* __lo, const char* __hi,
538                char_type* __dest) 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, 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 [lo,hi) to
565        *  char using the simplest reasonable transformation and writes the
566        *  results to the destination array.  For any element in the input that
567        *  cannot be converted, @a dfault is used instead.
568        *
569        *  do_narrow() is a hook for a derived facet to change the behavior of
570        *  narrowing.  do_narrow() must always return the same result for the
571        *  same input.
572        *
573        *  Note: this is not what you want for codepage conversions.  See
574        *  codecvt for that.
575        *
576        *  @param lo  Pointer to start of range.
577        *  @param hi  Pointer to end of range.
578        *  @param dfault  Char to use if conversion fails.
579        *  @param to  Pointer to the destination array.
580        *  @return  @a hi.
581       */
582       virtual const char_type*
583       do_narrow(const char_type* __lo, const char_type* __hi,
584                 char __dfault, char* __dest) const = 0;
585     };
586
587   // NB: Generic, mostly useless implementation.
588   /**
589    *  @brief  Template ctype facet
590    *
591    *  This template class defines classification and conversion functions for
592    *  character sets.  It wraps <cctype> functionality.  Ctype gets used by
593    *  streams for many I/O operations.
594    *
595    *  This template provides the protected virtual functions the developer
596    *  will have to replace in a derived class or specialization to make a
597    *  working facet.  The public functions that access them are defined in
598    *  __ctype_abstract_base, to allow for implementation flexibility.  See
599    *  ctype<wchar_t> for an example.  The functions are documented in
600    *  __ctype_abstract_base.
601    *
602    *  Note: implementations are provided for all the protected virtual
603    *  functions, but will likely not be useful.
604   */
605   template<typename _CharT>
606     class ctype : public __ctype_abstract_base<_CharT>
607     {
608     public:
609       // Types:
610       typedef _CharT                    char_type;
611       typedef typename __ctype_abstract_base<_CharT>::mask mask;
612
613       /// The facet id for ctype<char_type>
614       static locale::id                 id;
615
616       explicit
617       ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
618
619    protected:
620       virtual
621       ~ctype();
622
623       virtual bool
624       do_is(mask __m, char_type __c) const;
625
626       virtual const char_type*
627       do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
628
629       virtual const char_type*
630       do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
631
632       virtual const char_type*
633       do_scan_not(mask __m, const char_type* __lo,
634                   const char_type* __hi) const;
635
636       virtual char_type
637       do_toupper(char_type __c) const;
638
639       virtual const char_type*
640       do_toupper(char_type* __lo, const char_type* __hi) const;
641
642       virtual char_type
643       do_tolower(char_type __c) const;
644
645       virtual const char_type*
646       do_tolower(char_type* __lo, const char_type* __hi) const;
647
648       virtual char_type
649       do_widen(char __c) const;
650
651       virtual const char*
652       do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
653
654       virtual char
655       do_narrow(char_type, char __dfault) const;
656
657       virtual const char_type*
658       do_narrow(const char_type* __lo, const char_type* __hi,
659                 char __dfault, char* __dest) const;
660     };
661
662   template<typename _CharT>
663     locale::id ctype<_CharT>::id;
664
665   // 22.2.1.3  ctype<char> specialization.
666   /**
667    *  @brief  The ctype<char> specialization.
668    *
669    *  This class defines classification and conversion functions for
670    *  the char type.  It gets used by char streams for many I/O
671    *  operations.  The char specialization provides a number of
672    *  optimizations as well.
673   */
674   template<>
675     class ctype<char> : public locale::facet, public ctype_base
676     {
677     public:
678       // Types:
679       /// Typedef for the template parameter char.
680       typedef char              char_type;
681
682     protected:
683       // Data Members:
684       __c_locale                _M_c_locale_ctype;
685       bool                      _M_del;
686       __to_type                 _M_toupper;
687       __to_type                 _M_tolower;
688       const mask*               _M_table;
689       mutable char              _M_widen_ok;
690       mutable char              _M_widen[1 + static_cast<unsigned char>(-1)];
691       mutable char              _M_narrow[1 + static_cast<unsigned char>(-1)];
692       mutable char              _M_narrow_ok;   // 0 uninitialized, 1 init,
693                                                 // 2 memcpy can't be used
694
695     public:
696       /// The facet id for ctype<char>
697       static locale::id        id;
698       /// The size of the mask table.  It is SCHAR_MAX + 1.
699       static const size_t      table_size = 1 + static_cast<unsigned char>(-1);
700
701       /**
702        *  @brief  Constructor performs initialization.
703        *
704        *  This is the constructor provided by the standard.
705        *
706        *  @param table If non-zero, table is used as the per-char mask.
707        *               Else classic_table() is used.
708        *  @param del   If true, passes ownership of table to this facet.
709        *  @param refs  Passed to the base facet class.
710       */
711       explicit
712       ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
713
714       /**
715        *  @brief  Constructor performs static initialization.
716        *
717        *  This constructor is used to construct the initial C locale facet.
718        *
719        *  @param cloc  Handle to C locale data.
720        *  @param table If non-zero, table is used as the per-char mask.
721        *  @param del   If true, passes ownership of table to this facet.
722        *  @param refs  Passed to the base facet class.
723       */
724       explicit
725       ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
726             size_t __refs = 0);
727
728       /**
729        *  @brief  Test char classification.
730        *
731        *  This function compares the mask table[c] to @a m.
732        *
733        *  @param c  The char to compare the mask of.
734        *  @param m  The mask to compare against.
735        *  @return  True if m & table[c] is true, false otherwise.
736       */
737       inline bool
738       is(mask __m, char __c) const;
739
740       /**
741        *  @brief  Return a mask array.
742        *
743        *  This function finds the mask for each char in the range [lo, hi) and
744        *  successively writes it to vec.  vec must have as many elements as
745        *  the char array.
746        *
747        *  @param lo  Pointer to start of range.
748        *  @param hi  Pointer to end of range.
749        *  @param vec  Pointer to an array of mask storage.
750        *  @return  @a hi.
751       */
752       inline const char*
753       is(const char* __lo, const char* __hi, mask* __vec) const;
754
755       /**
756        *  @brief  Find char matching a mask
757        *
758        *  This function searches for and returns the first char in [lo,hi) for
759        *  which is(m,char) is true.
760        *
761        *  @param m  The mask to compare against.
762        *  @param lo  Pointer to start of range.
763        *  @param hi  Pointer to end of range.
764        *  @return  Pointer to a matching char if found, else @a hi.
765       */
766       inline const char*
767       scan_is(mask __m, const char* __lo, const char* __hi) const;
768
769       /**
770        *  @brief  Find char not matching a mask
771        *
772        *  This function searches for and returns a pointer to the first char
773        *  in [lo,hi) for which is(m,char) is false.
774        *
775        *  @param m  The mask to compare against.
776        *  @param lo  Pointer to start of range.
777        *  @param hi  Pointer to end of range.
778        *  @return  Pointer to a non-matching char if found, else @a hi.
779       */
780       inline const char*
781       scan_not(mask __m, const char* __lo, const char* __hi) const;
782
783       /**
784        *  @brief  Convert to uppercase.
785        *
786        *  This function converts the char argument to uppercase if possible.
787        *  If not possible (for example, '2'), returns the argument.
788        *
789        *  toupper() acts as if it returns ctype<char>::do_toupper(c).
790        *  do_toupper() must always return the same result for the same input.
791        *
792        *  @param c  The char to convert.
793        *  @return  The uppercase char if convertible, else @a c.
794       */
795       char_type
796       toupper(char_type __c) const
797       { return this->do_toupper(__c); }
798
799       /**
800        *  @brief  Convert array to uppercase.
801        *
802        *  This function converts each char in the range [lo,hi) to uppercase
803        *  if possible.  Other chars remain untouched.
804        *
805        *  toupper() acts as if it returns ctype<char>:: do_toupper(lo, hi).
806        *  do_toupper() must always return the same result for the same input.
807        *
808        *  @param lo  Pointer to first char in range.
809        *  @param hi  Pointer to end of range.
810        *  @return  @a hi.
811       */
812       const char_type*
813       toupper(char_type *__lo, const char_type* __hi) const
814       { return this->do_toupper(__lo, __hi); }
815
816       /**
817        *  @brief  Convert to lowercase.
818        *
819        *  This function converts the char argument to lowercase if possible.
820        *  If not possible (for example, '2'), returns the argument.
821        *
822        *  tolower() acts as if it returns ctype<char>::do_tolower(c).
823        *  do_tolower() must always return the same result for the same input.
824        *
825        *  @param c  The char to convert.
826        *  @return  The lowercase char if convertible, else @a c.
827       */
828       char_type
829       tolower(char_type __c) const
830       { return this->do_tolower(__c); }
831
832       /**
833        *  @brief  Convert array to lowercase.
834        *
835        *  This function converts each char in the range [lo,hi) to lowercase
836        *  if possible.  Other chars remain untouched.
837        *
838        *  tolower() acts as if it returns ctype<char>:: do_tolower(lo, hi).
839        *  do_tolower() must always return the same result for the same input.
840        *
841        *  @param lo  Pointer to first char in range.
842        *  @param hi  Pointer to end of range.
843        *  @return  @a hi.
844       */
845       const char_type*
846       tolower(char_type* __lo, const char_type* __hi) const
847       { return this->do_tolower(__lo, __hi); }
848
849       /**
850        *  @brief  Widen char
851        *
852        *  This function converts the char to char_type using the simplest
853        *  reasonable transformation.  For an underived ctype<char> facet, the
854        *  argument will be returned unchanged.
855        *
856        *  This function works as if it returns ctype<char>::do_widen(c).
857        *  do_widen() must always return the same result for the same input.
858        *
859        *  Note: this is not what you want for codepage conversions.  See
860        *  codecvt for that.
861        *
862        *  @param c  The char to convert.
863        *  @return  The converted character.
864       */
865       char_type
866       widen(char __c) const
867       {
868         if (_M_widen_ok)
869           return _M_widen[static_cast<unsigned char>(__c)];
870         this->_M_widen_init();
871         return this->do_widen(__c);
872       }
873
874       /**
875        *  @brief  Widen char array
876        *
877        *  This function converts each char in the input to char using the
878        *  simplest reasonable transformation.  For an underived ctype<char>
879        *  facet, the argument will be copied unchanged.
880        *
881        *  This function works as if it returns ctype<char>::do_widen(c).
882        *  do_widen() must always return the same result for the same input.
883        *
884        *  Note: this is not what you want for codepage conversions.  See
885        *  codecvt for that.
886        *
887        *  @param lo  Pointer to first char in range.
888        *  @param hi  Pointer to end of range.
889        *  @param to  Pointer to the destination array.
890        *  @return  @a hi.
891       */
892       const char*
893       widen(const char* __lo, const char* __hi, char_type* __to) const
894       {
895         if (_M_widen_ok == 1)
896           {
897             memcpy(__to, __lo, __hi - __lo);
898             return __hi;
899           }
900         if (!_M_widen_ok)
901           _M_widen_init();
902         return this->do_widen(__lo, __hi, __to);
903       }
904
905       /**
906        *  @brief  Narrow char
907        *
908        *  This function converts the char to char using the simplest
909        *  reasonable transformation.  If the conversion fails, dfault is
910        *  returned instead.  For an underived ctype<char> facet, @a c
911        *  will be returned unchanged.
912        *
913        *  This function works as if it returns ctype<char>::do_narrow(c).
914        *  do_narrow() must always return the same result for the same input.
915        *
916        *  Note: this is not what you want for codepage conversions.  See
917        *  codecvt for that.
918        *
919        *  @param c  The char to convert.
920        *  @param dfault  Char to return if conversion fails.
921        *  @return  The converted character.
922       */
923       char
924       narrow(char_type __c, char __dfault) const
925       {
926         if (_M_narrow[static_cast<unsigned char>(__c)])
927           return _M_narrow[static_cast<unsigned char>(__c)];
928         const char __t = do_narrow(__c, __dfault);
929         if (__t != __dfault)
930           _M_narrow[static_cast<unsigned char>(__c)] = __t;
931         return __t;
932       }
933
934       /**
935        *  @brief  Narrow char array
936        *
937        *  This function converts each char in the input to char using the
938        *  simplest reasonable transformation and writes the results to the
939        *  destination array.  For any char in the input that cannot be
940        *  converted, @a dfault is used instead.  For an underived ctype<char>
941        *  facet, the argument will be copied unchanged.
942        *
943        *  This function works as if it returns ctype<char>::do_narrow(lo, hi,
944        *  dfault, to).  do_narrow() must always return the same result for the
945        *  same input.
946        *
947        *  Note: this is not what you want for codepage conversions.  See
948        *  codecvt for that.
949        *
950        *  @param lo  Pointer to start of range.
951        *  @param hi  Pointer to end of range.
952        *  @param dfault  Char to use if conversion fails.
953        *  @param to  Pointer to the destination array.
954        *  @return  @a hi.
955       */
956       const char_type*
957       narrow(const char_type* __lo, const char_type* __hi,
958              char __dfault, char *__to) const
959       {
960         if (__builtin_expect(_M_narrow_ok == 1, true))
961           {
962             memcpy(__to, __lo, __hi - __lo);
963             return __hi;
964           }
965         if (!_M_narrow_ok)
966           _M_narrow_init();
967         return this->do_narrow(__lo, __hi, __dfault, __to);
968       }
969
970     protected:
971       /// Returns a pointer to the mask table provided to the constructor, or
972       /// the default from classic_table() if none was provided.
973       const mask*
974       table() const throw()
975       { return _M_table; }
976
977       /// Returns a pointer to the C locale mask table.
978       static const mask*
979       classic_table() throw();
980
981       /**
982        *  @brief  Destructor.
983        *
984        *  This function deletes table() if @a del was true in the
985        *  constructor.
986       */
987       virtual
988       ~ctype();
989
990       /**
991        *  @brief  Convert to uppercase.
992        *
993        *  This virtual function converts the char argument to uppercase if
994        *  possible.  If not possible (for example, '2'), returns the argument.
995        *
996        *  do_toupper() is a hook for a derived facet to change the behavior of
997        *  uppercasing.  do_toupper() must always return the same result for
998        *  the same input.
999        *
1000        *  @param c  The char to convert.
1001        *  @return  The uppercase char if convertible, else @a c.
1002       */
1003       virtual char_type
1004       do_toupper(char_type) const;
1005
1006       /**
1007        *  @brief  Convert array to uppercase.
1008        *
1009        *  This virtual function converts each char in the range [lo,hi) to
1010        *  uppercase if possible.  Other chars remain untouched.
1011        *
1012        *  do_toupper() is a hook for a derived facet to change the behavior of
1013        *  uppercasing.  do_toupper() must always return the same result for
1014        *  the same input.
1015        *
1016        *  @param lo  Pointer to start of range.
1017        *  @param hi  Pointer to end of range.
1018        *  @return  @a hi.
1019       */
1020       virtual const char_type*
1021       do_toupper(char_type* __lo, const char_type* __hi) const;
1022
1023       /**
1024        *  @brief  Convert to lowercase.
1025        *
1026        *  This virtual function converts the char argument to lowercase if
1027        *  possible.  If not possible (for example, '2'), returns the argument.
1028        *
1029        *  do_tolower() is a hook for a derived facet to change the behavior of
1030        *  lowercasing.  do_tolower() must always return the same result for
1031        *  the same input.
1032        *
1033        *  @param c  The char to convert.
1034        *  @return  The lowercase char if convertible, else @a c.
1035       */
1036       virtual char_type
1037       do_tolower(char_type) const;
1038
1039       /**
1040        *  @brief  Convert array to lowercase.
1041        *
1042        *  This virtual function converts each char in the range [lo,hi) to
1043        *  lowercase if possible.  Other chars remain untouched.
1044        *
1045        *  do_tolower() is a hook for a derived facet to change the behavior of
1046        *  lowercasing.  do_tolower() must always return the same result for
1047        *  the same input.
1048        *
1049        *  @param lo  Pointer to first char in range.
1050        *  @param hi  Pointer to end of range.
1051        *  @return  @a hi.
1052       */
1053       virtual const char_type*
1054       do_tolower(char_type* __lo, const char_type* __hi) const;
1055
1056       /**
1057        *  @brief  Widen char
1058        *
1059        *  This virtual function converts the char to char using the simplest
1060        *  reasonable transformation.  For an underived ctype<char> facet, the
1061        *  argument will be returned unchanged.
1062        *
1063        *  do_widen() is a hook for a derived facet to change the behavior of
1064        *  widening.  do_widen() must always return the same result for the
1065        *  same input.
1066        *
1067        *  Note: this is not what you want for codepage conversions.  See
1068        *  codecvt for that.
1069        *
1070        *  @param c  The char to convert.
1071        *  @return  The converted character.
1072       */
1073       virtual char_type
1074       do_widen(char __c) const
1075       { return __c; }
1076
1077       /**
1078        *  @brief  Widen char array
1079        *
1080        *  This function converts each char in the range [lo,hi) to char using
1081        *  the simplest reasonable transformation.  For an underived
1082        *  ctype<char> facet, the argument will be copied unchanged.
1083        *
1084        *  do_widen() is a hook for a derived facet to change the behavior of
1085        *  widening.  do_widen() must always return the same result for the
1086        *  same input.
1087        *
1088        *  Note: this is not what you want for codepage conversions.  See
1089        *  codecvt for that.
1090        *
1091        *  @param lo  Pointer to start of range.
1092        *  @param hi  Pointer to end of range.
1093        *  @param to  Pointer to the destination array.
1094        *  @return  @a hi.
1095       */
1096       virtual const char*
1097       do_widen(const char* __lo, const char* __hi, char_type* __dest) const
1098       {
1099         memcpy(__dest, __lo, __hi - __lo);
1100         return __hi;
1101       }
1102
1103       /**
1104        *  @brief  Narrow char
1105        *
1106        *  This virtual function converts the char to char using the simplest
1107        *  reasonable transformation.  If the conversion fails, dfault is
1108        *  returned instead.  For an underived ctype<char> facet, @a c will be
1109        *  returned unchanged.
1110        *
1111        *  do_narrow() is a hook for a derived facet to change the behavior of
1112        *  narrowing.  do_narrow() must always return the same result for the
1113        *  same input.
1114        *
1115        *  Note: this is not what you want for codepage conversions.  See
1116        *  codecvt for that.
1117        *
1118        *  @param c  The char to convert.
1119        *  @param dfault  Char to return if conversion fails.
1120        *  @return  The converted char.
1121       */
1122       virtual char
1123       do_narrow(char_type __c, char) const
1124       { return __c; }
1125
1126       /**
1127        *  @brief  Narrow char array to char array
1128        *
1129        *  This virtual function converts each char in the range [lo,hi) to
1130        *  char using the simplest reasonable transformation and writes the
1131        *  results to the destination array.  For any char in the input that
1132        *  cannot be converted, @a dfault is used instead.  For an underived
1133        *  ctype<char> facet, the argument will be copied unchanged.
1134        *
1135        *  do_narrow() is a hook for a derived facet to change the behavior of
1136        *  narrowing.  do_narrow() must always return the same result for the
1137        *  same input.
1138        *
1139        *  Note: this is not what you want for codepage conversions.  See
1140        *  codecvt for that.
1141        *
1142        *  @param lo  Pointer to start of range.
1143        *  @param hi  Pointer to end of range.
1144        *  @param dfault  Char to use if conversion fails.
1145        *  @param to  Pointer to the destination array.
1146        *  @return  @a hi.
1147       */
1148       virtual const char_type*
1149       do_narrow(const char_type* __lo, const char_type* __hi,
1150                 char, char* __dest) const
1151       {
1152         memcpy(__dest, __lo, __hi - __lo);
1153         return __hi;
1154       }
1155
1156     private:
1157
1158       void _M_widen_init() const
1159       {
1160         char __tmp[sizeof(_M_widen)];
1161         for (size_t __i = 0; __i < sizeof(_M_widen); ++__i)
1162           __tmp[__i] = __i;
1163         do_widen(__tmp, __tmp + sizeof(__tmp), _M_widen);
1164
1165         _M_widen_ok = 1;
1166         // Set _M_widen_ok to 2 if memcpy can't be used.
1167         if (memcmp(__tmp, _M_widen, sizeof(_M_widen)))
1168           _M_widen_ok = 2;
1169       }
1170
1171       // Fill in the narrowing cache and flag whether all values are
1172       // valid or not.  _M_narrow_ok is set to 2 if memcpy can't
1173       // be used.
1174       void _M_narrow_init() const
1175       {
1176         char __tmp[sizeof(_M_narrow)];
1177         for (size_t __i = 0; __i < sizeof(_M_narrow); ++__i)
1178           __tmp[__i] = __i;
1179         do_narrow(__tmp, __tmp + sizeof(__tmp), 0, _M_narrow);
1180
1181         _M_narrow_ok = 1;
1182         if (memcmp(__tmp, _M_narrow, sizeof(_M_narrow)))
1183           _M_narrow_ok = 2;
1184         else
1185           {
1186             // Deal with the special case of zero: renarrow with a
1187             // different default and compare.
1188             char __c;
1189             do_narrow(__tmp, __tmp + 1, 1, &__c);
1190             if (__c == 1)
1191               _M_narrow_ok = 2;
1192           }
1193       }
1194     };
1195
1196   template<>
1197     const ctype<char>&
1198     use_facet<ctype<char> >(const locale& __loc);
1199
1200 #ifdef _GLIBCXX_USE_WCHAR_T
1201   // 22.2.1.3  ctype<wchar_t> specialization
1202   /**
1203    *  @brief  The ctype<wchar_t> specialization.
1204    *
1205    *  This class defines classification and conversion functions for the
1206    *  wchar_t type.  It gets used by wchar_t streams for many I/O operations.
1207    *  The wchar_t specialization provides a number of optimizations as well.
1208    *
1209    *  ctype<wchar_t> inherits its public methods from
1210    *  __ctype_abstract_base<wchar_t>.
1211   */
1212   template<>
1213     class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
1214     {
1215     public:
1216       // Types:
1217       /// Typedef for the template parameter wchar_t.
1218       typedef wchar_t           char_type;
1219       typedef wctype_t          __wmask_type;
1220
1221     protected:
1222       __c_locale                _M_c_locale_ctype;
1223
1224       // Pre-computed narrowed and widened chars.
1225       bool                      _M_narrow_ok;
1226       char                      _M_narrow[128];
1227       wint_t                    _M_widen[1 + static_cast<unsigned char>(-1)];
1228
1229       // Pre-computed elements for do_is.
1230       mask                      _M_bit[16];
1231       __wmask_type              _M_wmask[16];
1232
1233     public:
1234       // Data Members:
1235       /// The facet id for ctype<wchar_t>
1236       static locale::id         id;
1237
1238       /**
1239        *  @brief  Constructor performs initialization.
1240        *
1241        *  This is the constructor provided by the standard.
1242        *
1243        *  @param refs  Passed to the base facet class.
1244       */
1245       explicit
1246       ctype(size_t __refs = 0);
1247
1248       /**
1249        *  @brief  Constructor performs static initialization.
1250        *
1251        *  This constructor is used to construct the initial C locale facet.
1252        *
1253        *  @param cloc  Handle to C locale data.
1254        *  @param refs  Passed to the base facet class.
1255       */
1256       explicit
1257       ctype(__c_locale __cloc, size_t __refs = 0);
1258
1259     protected:
1260       __wmask_type
1261       _M_convert_to_wmask(const mask __m) const;
1262
1263       /// Destructor
1264       virtual
1265       ~ctype();
1266
1267       /**
1268        *  @brief  Test wchar_t classification.
1269        *
1270        *  This function finds a mask M for @a c and compares it to mask @a m.
1271        *
1272        *  do_is() is a hook for a derived facet to change the behavior of
1273        *  classifying.  do_is() must always return the same result for the
1274        *  same input.
1275        *
1276        *  @param c  The wchar_t to find the mask of.
1277        *  @param m  The mask to compare against.
1278        *  @return  (M & m) != 0.
1279       */
1280       virtual bool
1281       do_is(mask __m, char_type __c) const;
1282
1283       /**
1284        *  @brief  Return a mask array.
1285        *
1286        *  This function finds the mask for each wchar_t in the range [lo,hi)
1287        *  and successively writes it to vec.  vec must have as many elements
1288        *  as the input.
1289        *
1290        *  do_is() is a hook for a derived facet to change the behavior of
1291        *  classifying.  do_is() must always return the same result for the
1292        *  same input.
1293        *
1294        *  @param lo  Pointer to start of range.
1295        *  @param hi  Pointer to end of range.
1296        *  @param vec  Pointer to an array of mask storage.
1297        *  @return  @a hi.
1298       */
1299       virtual const char_type*
1300       do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
1301
1302       /**
1303        *  @brief  Find wchar_t matching mask
1304        *
1305        *  This function searches for and returns the first wchar_t c in
1306        *  [lo,hi) for which is(m,c) is true.
1307        *
1308        *  do_scan_is() is a hook for a derived facet to change the behavior of
1309        *  match searching.  do_is() must always return the same result for the
1310        *  same input.
1311        *
1312        *  @param m  The mask to compare against.
1313        *  @param lo  Pointer to start of range.
1314        *  @param hi  Pointer to end of range.
1315        *  @return  Pointer to a matching wchar_t if found, else @a hi.
1316       */
1317       virtual const char_type*
1318       do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
1319
1320       /**
1321        *  @brief  Find wchar_t not matching mask
1322        *
1323        *  This function searches for and returns a pointer to the first
1324        *  wchar_t c of [lo,hi) for which is(m,c) is false.
1325        *
1326        *  do_scan_is() is a hook for a derived facet to change the behavior of
1327        *  match searching.  do_is() must always return the same result for the
1328        *  same input.
1329        *
1330        *  @param m  The mask to compare against.
1331        *  @param lo  Pointer to start of range.
1332        *  @param hi  Pointer to end of range.
1333        *  @return  Pointer to a non-matching wchar_t if found, else @a hi.
1334       */
1335       virtual const char_type*
1336       do_scan_not(mask __m, const char_type* __lo,
1337                   const char_type* __hi) const;
1338
1339       /**
1340        *  @brief  Convert to uppercase.
1341        *
1342        *  This virtual function converts the wchar_t argument to uppercase if
1343        *  possible.  If not possible (for example, '2'), returns the argument.
1344        *
1345        *  do_toupper() is a hook for a derived facet to change the behavior of
1346        *  uppercasing.  do_toupper() must always return the same result for
1347        *  the same input.
1348        *
1349        *  @param c  The wchar_t to convert.
1350        *  @return  The uppercase wchar_t if convertible, else @a c.
1351       */
1352       virtual char_type
1353       do_toupper(char_type) const;
1354
1355       /**
1356        *  @brief  Convert array to uppercase.
1357        *
1358        *  This virtual function converts each wchar_t in the range [lo,hi) to
1359        *  uppercase if possible.  Other elements remain untouched.
1360        *
1361        *  do_toupper() is a hook for a derived facet to change the behavior of
1362        *  uppercasing.  do_toupper() must always return the same result for
1363        *  the same input.
1364        *
1365        *  @param lo  Pointer to start of range.
1366        *  @param hi  Pointer to end of range.
1367        *  @return  @a hi.
1368       */
1369       virtual const char_type*
1370       do_toupper(char_type* __lo, const char_type* __hi) const;
1371
1372       /**
1373        *  @brief  Convert to lowercase.
1374        *
1375        *  This virtual function converts the argument to lowercase if
1376        *  possible.  If not possible (for example, '2'), returns the argument.
1377        *
1378        *  do_tolower() is a hook for a derived facet to change the behavior of
1379        *  lowercasing.  do_tolower() must always return the same result for
1380        *  the same input.
1381        *
1382        *  @param c  The wchar_t to convert.
1383        *  @return  The lowercase wchar_t if convertible, else @a c.
1384       */
1385       virtual char_type
1386       do_tolower(char_type) const;
1387
1388       /**
1389        *  @brief  Convert array to lowercase.
1390        *
1391        *  This virtual function converts each wchar_t in the range [lo,hi) to
1392        *  lowercase if possible.  Other elements remain untouched.
1393        *
1394        *  do_tolower() is a hook for a derived facet to change the behavior of
1395        *  lowercasing.  do_tolower() must always return the same result for
1396        *  the same input.
1397        *
1398        *  @param lo  Pointer to start of range.
1399        *  @param hi  Pointer to end of range.
1400        *  @return  @a hi.
1401       */
1402       virtual const char_type*
1403       do_tolower(char_type* __lo, const char_type* __hi) const;
1404
1405       /**
1406        *  @brief  Widen char to wchar_t
1407        *
1408        *  This virtual function converts the char to wchar_t using the
1409        *  simplest reasonable transformation.  For an underived ctype<wchar_t>
1410        *  facet, the argument will be cast to wchar_t.
1411        *
1412        *  do_widen() is a hook for a derived facet to change the behavior of
1413        *  widening.  do_widen() must always return the same result for the
1414        *  same input.
1415        *
1416        *  Note: this is not what you want for codepage conversions.  See
1417        *  codecvt for that.
1418        *
1419        *  @param c  The char to convert.
1420        *  @return  The converted wchar_t.
1421       */
1422       virtual char_type
1423       do_widen(char) const;
1424
1425       /**
1426        *  @brief  Widen char array to wchar_t array
1427        *
1428        *  This function converts each char in the input to wchar_t using the
1429        *  simplest reasonable transformation.  For an underived ctype<wchar_t>
1430        *  facet, the argument will be copied, casting each element to wchar_t.
1431        *
1432        *  do_widen() is a hook for a derived facet to change the behavior of
1433        *  widening.  do_widen() must always return the same result for the
1434        *  same input.
1435        *
1436        *  Note: this is not what you want for codepage conversions.  See
1437        *  codecvt for that.
1438        *
1439        *  @param lo  Pointer to start range.
1440        *  @param hi  Pointer to end of range.
1441        *  @param to  Pointer to the destination array.
1442        *  @return  @a hi.
1443       */
1444       virtual const char*
1445       do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
1446
1447       /**
1448        *  @brief  Narrow wchar_t to char
1449        *
1450        *  This virtual function converts the argument to char using
1451        *  the simplest reasonable transformation.  If the conversion
1452        *  fails, dfault is returned instead.  For an underived
1453        *  ctype<wchar_t> facet, @a c will be cast to char and
1454        *  returned.
1455        *
1456        *  do_narrow() is a hook for a derived facet to change the
1457        *  behavior of narrowing.  do_narrow() must always return the
1458        *  same result for the same input.
1459        *
1460        *  Note: this is not what you want for codepage conversions.  See
1461        *  codecvt for that.
1462        *
1463        *  @param c  The wchar_t to convert.
1464        *  @param dfault  Char to return if conversion fails.
1465        *  @return  The converted char.
1466       */
1467       virtual char
1468       do_narrow(char_type, char __dfault) const;
1469
1470       /**
1471        *  @brief  Narrow wchar_t array to char array
1472        *
1473        *  This virtual function converts each wchar_t in the range [lo,hi) to
1474        *  char using the simplest reasonable transformation and writes the
1475        *  results to the destination array.  For any wchar_t in the input that
1476        *  cannot be converted, @a dfault is used instead.  For an underived
1477        *  ctype<wchar_t> facet, the argument will be copied, casting each
1478        *  element to char.
1479        *
1480        *  do_narrow() is a hook for a derived facet to change the behavior of
1481        *  narrowing.  do_narrow() must always return the same result for the
1482        *  same input.
1483        *
1484        *  Note: this is not what you want for codepage conversions.  See
1485        *  codecvt for that.
1486        *
1487        *  @param lo  Pointer to start of range.
1488        *  @param hi  Pointer to end of range.
1489        *  @param dfault  Char to use if conversion fails.
1490        *  @param to  Pointer to the destination array.
1491        *  @return  @a hi.
1492       */
1493       virtual const char_type*
1494       do_narrow(const char_type* __lo, const char_type* __hi,
1495                 char __dfault, char* __dest) const;
1496
1497       // For use at construction time only.
1498       void
1499       _M_initialize_ctype();
1500     };
1501
1502   template<>
1503     const ctype<wchar_t>&
1504     use_facet<ctype<wchar_t> >(const locale& __loc);
1505 #endif //_GLIBCXX_USE_WCHAR_T
1506
1507   // Include host and configuration specific ctype inlines.
1508   #include <bits/ctype_inline.h>
1509
1510   /// @brief  class ctype_byname [22.2.1.2].
1511   template<typename _CharT>
1512     class ctype_byname : public ctype<_CharT>
1513     {
1514     public:
1515       typedef _CharT            char_type;
1516
1517       explicit
1518       ctype_byname(const char* __s, size_t __refs = 0);
1519
1520     protected:
1521       virtual
1522       ~ctype_byname() { };
1523     };
1524
1525   /// 22.2.1.4  Class ctype_byname specializations.
1526   template<>
1527     ctype_byname<char>::ctype_byname(const char*, size_t refs);
1528
1529   template<>
1530     ctype_byname<wchar_t>::ctype_byname(const char*, size_t refs);
1531
1532   // 22.2.1.5  Template class codecvt
1533   #include <bits/codecvt.h>
1534
1535   // 22.2.2  The numeric category.
1536   class __num_base
1537   {
1538   public:
1539     // NB: Code depends on the order of _S_atoms_out elements.
1540     // Below are the indices into _S_atoms_out.
1541     enum
1542       {
1543         _S_ominus,
1544         _S_oplus,
1545         _S_ox,
1546         _S_oX,
1547         _S_odigits,
1548         _S_odigits_end = _S_odigits + 16,
1549         _S_oudigits = _S_odigits_end,
1550         _S_oudigits_end = _S_oudigits + 16,
1551         _S_oe = _S_odigits + 14,  // For scientific notation, 'e'
1552         _S_oE = _S_oudigits + 14, // For scientific notation, 'E'
1553         _S_oend = _S_oudigits_end
1554       };
1555
1556     // A list of valid numeric literals for output.  This array
1557     // contains chars that will be passed through the current locale's
1558     // ctype<_CharT>.widen() and then used to render numbers.
1559     // For the standard "C" locale, this is
1560     // "-+xX0123456789abcdef0123456789ABCDEF".
1561     static const char* _S_atoms_out;
1562
1563     // String literal of acceptable (narrow) input, for num_get.
1564     // "-+xX0123456789abcdefABCDEF"
1565     static const char* _S_atoms_in;
1566
1567     enum
1568     {
1569       _S_iminus,
1570       _S_iplus,
1571       _S_ix,
1572       _S_iX,
1573       _S_izero,
1574       _S_ie = _S_izero + 14,
1575       _S_iE = _S_izero + 20,
1576       _S_iend = 26
1577     };
1578
1579     // num_put
1580     // Construct and return valid scanf format for floating point types.
1581     static void
1582     _S_format_float(const ios_base& __io, char* __fptr, char __mod);
1583   };
1584
1585   template<typename _CharT>
1586     struct __numpunct_cache : public locale::facet
1587     {
1588       const char*                       _M_grouping;
1589       size_t                            _M_grouping_size;
1590       bool                              _M_use_grouping;
1591       const _CharT*                     _M_truename;
1592       size_t                            _M_truename_size;
1593       const _CharT*                     _M_falsename;
1594       size_t                            _M_falsename_size;
1595       _CharT                            _M_decimal_point;
1596       _CharT                            _M_thousands_sep;
1597
1598       // A list of valid numeric literals for output: in the standard
1599       // "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF".
1600       // This array contains the chars after having been passed
1601       // through the current locale's ctype<_CharT>.widen().
1602       _CharT                            _M_atoms_out[__num_base::_S_oend];
1603
1604       // A list of valid numeric literals for input: in the standard
1605       // "C" locale, this is "-+xX0123456789abcdefABCDEF"
1606       // This array contains the chars after having been passed
1607       // through the current locale's ctype<_CharT>.widen().
1608       _CharT                            _M_atoms_in[__num_base::_S_iend];
1609
1610       bool                              _M_allocated;
1611
1612       __numpunct_cache(size_t __refs = 0) : facet(__refs),
1613       _M_grouping(NULL), _M_grouping_size(0), _M_use_grouping(false),
1614       _M_truename(NULL), _M_truename_size(0), _M_falsename(NULL),
1615       _M_falsename_size(0), _M_decimal_point(_CharT()),
1616       _M_thousands_sep(_CharT()), _M_allocated(false)
1617       { }
1618
1619       ~__numpunct_cache();
1620
1621       void
1622       _M_cache(const locale& __loc);
1623
1624     private:
1625       __numpunct_cache&
1626       operator=(const __numpunct_cache&);
1627       
1628       explicit
1629       __numpunct_cache(const __numpunct_cache&);
1630     };
1631
1632   template<typename _CharT>
1633     __numpunct_cache<_CharT>::~__numpunct_cache()
1634     {
1635       if (_M_allocated)
1636         {
1637           delete [] _M_grouping;
1638           delete [] _M_truename;
1639           delete [] _M_falsename;
1640         }
1641     }
1642
1643   /**
1644    *  @brief  Numpunct facet.
1645    *
1646    *  This facet stores several pieces of information related to printing and
1647    *  scanning numbers, such as the decimal point character.  It takes a
1648    *  template parameter specifying the char type.  The numpunct facet is
1649    *  used by streams for many I/O operations involving numbers.
1650    *
1651    *  The numpunct template uses protected virtual functions to provide the
1652    *  actual results.  The public accessors forward the call to the virtual
1653    *  functions.  These virtual functions are hooks for developers to
1654    *  implement the behavior they require from a numpunct facet.
1655   */
1656   template<typename _CharT>
1657     class numpunct : public locale::facet
1658     {
1659     public:
1660       // Types:
1661       //@{
1662       /// Public typedefs
1663       typedef _CharT                    char_type;
1664       typedef basic_string<_CharT>      string_type;
1665       //@}
1666       typedef __numpunct_cache<_CharT>  __cache_type;
1667
1668     protected:
1669       __cache_type*                     _M_data;
1670
1671     public:
1672       /// Numpunct facet id.
1673       static locale::id                 id;
1674
1675       /**
1676        *  @brief  Numpunct constructor.
1677        *
1678        *  @param  refs  Refcount to pass to the base class.
1679        */
1680       explicit
1681       numpunct(size_t __refs = 0) : facet(__refs), _M_data(NULL)
1682       { _M_initialize_numpunct(); }
1683
1684       /**
1685        *  @brief  Internal constructor.  Not for general use.
1686        *
1687        *  This is a constructor for use by the library itself to set up the
1688        *  predefined locale facets.
1689        *
1690        *  @param  cache  __numpunct_cache object.
1691        *  @param  refs  Refcount to pass to the base class.
1692        */
1693       explicit
1694       numpunct(__cache_type* __cache, size_t __refs = 0)
1695       : facet(__refs), _M_data(__cache)
1696       { _M_initialize_numpunct(); }
1697
1698       /**
1699        *  @brief  Internal constructor.  Not for general use.
1700        *
1701        *  This is a constructor for use by the library itself to set up new
1702        *  locales.
1703        *
1704        *  @param  cloc  The "C" locale.
1705        *  @param  refs  Refcount to pass to the base class.
1706        */
1707       explicit
1708       numpunct(__c_locale __cloc, size_t __refs = 0)
1709       : facet(__refs), _M_data(NULL)
1710       { _M_initialize_numpunct(__cloc); }
1711
1712       /**
1713        *  @brief  Return decimal point character.
1714        *
1715        *  This function returns a char_type to use as a decimal point.  It
1716        *  does so by returning returning
1717        *  numpunct<char_type>::do_decimal_point().
1718        *
1719        *  @return  @a char_type representing a decimal point.
1720       */
1721       char_type
1722       decimal_point() const
1723       { return this->do_decimal_point(); }
1724
1725       /**
1726        *  @brief  Return thousands separator character.
1727        *
1728        *  This function returns a char_type to use as a thousands
1729        *  separator.  It does so by returning returning
1730        *  numpunct<char_type>::do_thousands_sep().
1731        *
1732        *  @return  char_type representing a thousands separator.
1733       */
1734       char_type
1735       thousands_sep() const
1736       { return this->do_thousands_sep(); }
1737
1738       /**
1739        *  @brief  Return grouping specification.
1740        *
1741        *  This function returns a string representing groupings for the
1742        *  integer part of a number.  Groupings indicate where thousands
1743        *  separators should be inserted in the integer part of a number.
1744        *
1745        *  Each char in the return string is interpret as an integer
1746        *  rather than a character.  These numbers represent the number
1747        *  of digits in a group.  The first char in the string
1748        *  represents the number of digits in the least significant
1749        *  group.  If a char is negative, it indicates an unlimited
1750        *  number of digits for the group.  If more chars from the
1751        *  string are required to group a number, the last char is used
1752        *  repeatedly.
1753        *
1754        *  For example, if the grouping() returns "\003\002" and is
1755        *  applied to the number 123456789, this corresponds to
1756        *  12,34,56,789.  Note that if the string was "32", this would
1757        *  put more than 50 digits into the least significant group if
1758        *  the character set is ASCII.
1759        *
1760        *  The string is returned by calling
1761        *  numpunct<char_type>::do_grouping().
1762        *
1763        *  @return  string representing grouping specification.
1764       */
1765       string
1766       grouping() const
1767       { return this->do_grouping(); }
1768
1769       /**
1770        *  @brief  Return string representation of bool true.
1771        *
1772        *  This function returns a string_type containing the text
1773        *  representation for true bool variables.  It does so by calling
1774        *  numpunct<char_type>::do_truename().
1775        *
1776        *  @return  string_type representing printed form of true.
1777       */
1778       string_type
1779       truename() const
1780       { return this->do_truename(); }
1781
1782       /**
1783        *  @brief  Return string representation of bool false.
1784        *
1785        *  This function returns a string_type containing the text
1786        *  representation for false bool variables.  It does so by calling
1787        *  numpunct<char_type>::do_falsename().
1788        *
1789        *  @return  string_type representing printed form of false.
1790       */
1791       string_type
1792       falsename() const
1793       { return this->do_falsename(); }
1794
1795     protected:
1796       /// Destructor.
1797       virtual
1798       ~numpunct();
1799
1800       /**
1801        *  @brief  Return decimal point character.
1802        *
1803        *  Returns a char_type to use as a decimal point.  This function is a
1804        *  hook for derived classes to change the value returned.
1805        *
1806        *  @return  @a char_type representing a decimal point.
1807       */
1808       virtual char_type
1809       do_decimal_point() const
1810       { return _M_data->_M_decimal_point; }
1811
1812       /**
1813        *  @brief  Return thousands separator character.
1814        *
1815        *  Returns a char_type to use as a thousands separator.  This function
1816        *  is a hook for derived classes to change the value returned.
1817        *
1818        *  @return  @a char_type representing a thousands separator.
1819       */
1820       virtual char_type
1821       do_thousands_sep() const
1822       { return _M_data->_M_thousands_sep; }
1823
1824       /**
1825        *  @brief  Return grouping specification.
1826        *
1827        *  Returns a string representing groupings for the integer part of a
1828        *  number.  This function is a hook for derived classes to change the
1829        *  value returned.  @see grouping() for details.
1830        *
1831        *  @return  String representing grouping specification.
1832       */
1833       virtual string
1834       do_grouping() const
1835       { return _M_data->_M_grouping; }
1836
1837       /**
1838        *  @brief  Return string representation of bool true.
1839        *
1840        *  Returns a string_type containing the text representation for true
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 true.
1845       */
1846       virtual string_type
1847       do_truename() const
1848       { return _M_data->_M_truename; }
1849
1850       /**
1851        *  @brief  Return string representation of bool false.
1852        *
1853        *  Returns a string_type containing the text representation for false
1854        *  bool variables.  This function is a hook for derived classes to
1855        *  change the value returned.
1856        *
1857        *  @return  string_type representing printed form of false.
1858       */
1859       virtual string_type
1860       do_falsename() const
1861       { return _M_data->_M_falsename; }
1862
1863       // For use at construction time only.
1864       void
1865       _M_initialize_numpunct(__c_locale __cloc = NULL);
1866     };
1867
1868   template<typename _CharT>
1869     locale::id numpunct<_CharT>::id;
1870
1871   template<>
1872     numpunct<char>::~numpunct();
1873
1874   template<>
1875     void
1876     numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
1877
1878 #ifdef _GLIBCXX_USE_WCHAR_T
1879   template<>
1880     numpunct<wchar_t>::~numpunct();
1881
1882   template<>
1883     void
1884     numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
1885 #endif
1886
1887   /// @brief  class numpunct_byname [22.2.3.2].
1888   template<typename _CharT>
1889     class numpunct_byname : public numpunct<_CharT>
1890     {
1891     public:
1892       typedef _CharT                    char_type;
1893       typedef basic_string<_CharT>      string_type;
1894
1895       explicit
1896       numpunct_byname(const char* __s, size_t __refs = 0)
1897       : numpunct<_CharT>(__refs)
1898       {
1899         if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
1900           {
1901             __c_locale __tmp;
1902             this->_S_create_c_locale(__tmp, __s);
1903             this->_M_initialize_numpunct(__tmp);
1904             this->_S_destroy_c_locale(__tmp);
1905           }
1906       }
1907
1908     protected:
1909       virtual
1910       ~numpunct_byname() { }
1911     };
1912
1913   /**
1914    *  @brief  Facet for parsing number strings.
1915    *
1916    *  This facet encapsulates the code to parse and return a number
1917    *  from a string.  It is used by the istream numeric extraction
1918    *  operators.
1919    *
1920    *  The num_get template uses protected virtual functions to provide the
1921    *  actual results.  The public accessors forward the call to the virtual
1922    *  functions.  These virtual functions are hooks for developers to
1923    *  implement the behavior they require from the num_get facet.
1924   */
1925   template<typename _CharT, typename _InIter>
1926     class num_get : public locale::facet
1927     {
1928     public:
1929       // Types:
1930       //@{
1931       /// Public typedefs
1932       typedef _CharT                    char_type;
1933       typedef _InIter                   iter_type;
1934       //@}
1935
1936       /// Numpunct facet id.
1937       static locale::id                 id;
1938
1939       /**
1940        *  @brief  Constructor performs initialization.
1941        *
1942        *  This is the constructor provided by the standard.
1943        *
1944        *  @param refs  Passed to the base facet class.
1945       */
1946       explicit
1947       num_get(size_t __refs = 0) : facet(__refs) { }
1948
1949       /**
1950        *  @brief  Numeric parsing.
1951        *
1952        *  Parses the input stream into the bool @a v.  It does so by calling
1953        *  num_get::do_get().
1954        *
1955        *  If ios_base::boolalpha is set, attempts to read
1956        *  ctype<CharT>::truename() or ctype<CharT>::falsename().  Sets
1957        *  @a v to true or false if successful.  Sets err to
1958        *  ios_base::failbit if reading the string fails.  Sets err to
1959        *  ios_base::eofbit if the stream is emptied.
1960        *
1961        *  If ios_base::boolalpha is not set, proceeds as with reading a long,
1962        *  except if the value is 1, sets @a v to true, if the value is 0, sets
1963        *  @a v to false, and otherwise set err to ios_base::failbit.
1964        *
1965        *  @param  in  Start of input stream.
1966        *  @param  end  End of input stream.
1967        *  @param  io  Source of locale and flags.
1968        *  @param  err  Error flags to set.
1969        *  @param  v  Value to format and insert.
1970        *  @return  Iterator after reading.
1971       */
1972       iter_type
1973       get(iter_type __in, iter_type __end, ios_base& __io,
1974           ios_base::iostate& __err, bool& __v) const
1975       { return this->do_get(__in, __end, __io, __err, __v); }
1976
1977       //@{
1978       /**
1979        *  @brief  Numeric parsing.
1980        *
1981        *  Parses the input stream into the integral variable @a v.  It does so
1982        *  by calling num_get::do_get().
1983        *
1984        *  Parsing is affected by the flag settings in @a io.
1985        *
1986        *  The basic parse is affected by the value of io.flags() &
1987        *  ios_base::basefield.  If equal to ios_base::oct, parses like the
1988        *  scanf %o specifier.  Else if equal to ios_base::hex, parses like %X
1989        *  specifier.  Else if basefield equal to 0, parses like the %i
1990        *  specifier.  Otherwise, parses like %d for signed and %u for unsigned
1991        *  types.  The matching type length modifier is also used.
1992        *
1993        *  Digit grouping is intrepreted according to numpunct::grouping() and
1994        *  numpunct::thousands_sep().  If the pattern of digit groups isn't
1995        *  consistent, sets err to ios_base::failbit.
1996        *
1997        *  If parsing the string yields a valid value for @a v, @a v is set.
1998        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
1999        *  Sets err to ios_base::eofbit if the stream is emptied.
2000        *
2001        *  @param  in  Start of input stream.
2002        *  @param  end  End of input stream.
2003        *  @param  io  Source of locale and flags.
2004        *  @param  err  Error flags to set.
2005        *  @param  v  Value to format and insert.
2006        *  @return  Iterator after reading.
2007       */
2008       iter_type
2009       get(iter_type __in, iter_type __end, ios_base& __io,
2010           ios_base::iostate& __err, long& __v) const
2011       { return this->do_get(__in, __end, __io, __err, __v); }
2012
2013       iter_type
2014       get(iter_type __in, iter_type __end, ios_base& __io,
2015           ios_base::iostate& __err, unsigned short& __v) const
2016       { return this->do_get(__in, __end, __io, __err, __v); }
2017
2018       iter_type
2019       get(iter_type __in, iter_type __end, ios_base& __io,
2020           ios_base::iostate& __err, unsigned int& __v)   const
2021       { return this->do_get(__in, __end, __io, __err, __v); }
2022
2023       iter_type
2024       get(iter_type __in, iter_type __end, ios_base& __io,
2025           ios_base::iostate& __err, unsigned long& __v)  const
2026       { return this->do_get(__in, __end, __io, __err, __v); }
2027
2028 #ifdef _GLIBCXX_USE_LONG_LONG
2029       iter_type
2030       get(iter_type __in, iter_type __end, ios_base& __io,
2031           ios_base::iostate& __err, long long& __v) const
2032       { return this->do_get(__in, __end, __io, __err, __v); }
2033
2034       iter_type
2035       get(iter_type __in, iter_type __end, ios_base& __io,
2036           ios_base::iostate& __err, unsigned long long& __v)  const
2037       { return this->do_get(__in, __end, __io, __err, __v); }
2038 #endif
2039       //@}
2040
2041       //@{
2042       /**
2043        *  @brief  Numeric parsing.
2044        *
2045        *  Parses the input stream into the integral variable @a v.  It does so
2046        *  by calling num_get::do_get().
2047        *
2048        *  The input characters are parsed like the scanf %g specifier.  The
2049        *  matching type length modifier is also used.
2050        *
2051        *  The decimal point character used is numpunct::decimal_point().
2052        *  Digit grouping is intrepreted according to numpunct::grouping() and
2053        *  numpunct::thousands_sep().  If the pattern of digit groups isn't
2054        *  consistent, sets err to ios_base::failbit.
2055        *
2056        *  If parsing the string yields a valid value for @a v, @a v is set.
2057        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2058        *  Sets err to ios_base::eofbit if the stream is emptied.
2059        *
2060        *  @param  in  Start of input stream.
2061        *  @param  end  End of input stream.
2062        *  @param  io  Source of locale and flags.
2063        *  @param  err  Error flags to set.
2064        *  @param  v  Value to format and insert.
2065        *  @return  Iterator after reading.
2066       */
2067       iter_type
2068       get(iter_type __in, iter_type __end, ios_base& __io,
2069           ios_base::iostate& __err, float& __v) const
2070       { return this->do_get(__in, __end, __io, __err, __v); }
2071
2072       iter_type
2073       get(iter_type __in, iter_type __end, ios_base& __io,
2074           ios_base::iostate& __err, double& __v) const
2075       { return this->do_get(__in, __end, __io, __err, __v); }
2076
2077       iter_type
2078       get(iter_type __in, iter_type __end, ios_base& __io,
2079           ios_base::iostate& __err, long double& __v) const
2080       { return this->do_get(__in, __end, __io, __err, __v); }
2081       //@}
2082
2083       /**
2084        *  @brief  Numeric parsing.
2085        *
2086        *  Parses the input stream into the pointer variable @a v.  It does so
2087        *  by calling num_get::do_get().
2088        *
2089        *  The input characters are parsed like the scanf %p specifier.
2090        *
2091        *  Digit grouping is intrepreted according to numpunct::grouping() and
2092        *  numpunct::thousands_sep().  If the pattern of digit groups isn't
2093        *  consistent, sets err to ios_base::failbit.
2094        *
2095        *  Note that the digit grouping effect for pointers is a bit ambiguous
2096        *  in the standard and shouldn't be relied on.  See DR 344.
2097        *
2098        *  If parsing the string yields a valid value for @a v, @a v is set.
2099        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2100        *  Sets err to ios_base::eofbit if the stream is emptied.
2101        *
2102        *  @param  in  Start of input stream.
2103        *  @param  end  End of input stream.
2104        *  @param  io  Source of locale and flags.
2105        *  @param  err  Error flags to set.
2106        *  @param  v  Value to format and insert.
2107        *  @return  Iterator after reading.
2108       */
2109       iter_type
2110       get(iter_type __in, iter_type __end, ios_base& __io,
2111           ios_base::iostate& __err, void*& __v) const
2112       { return this->do_get(__in, __end, __io, __err, __v); }
2113
2114     protected:
2115       /// Destructor.
2116       virtual ~num_get() { }
2117
2118       iter_type
2119       _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
2120                        string& __xtrc) const;
2121
2122       template<typename _ValueT>
2123         iter_type
2124         _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
2125                        _ValueT& __v) const;
2126
2127       //@{
2128       /**
2129        *  @brief  Numeric parsing.
2130        *
2131        *  Parses the input stream into the variable @a v.  This function is a
2132        *  hook for derived classes to change the value returned.  @see get()
2133        *  for more details.
2134        *
2135        *  @param  in  Start of input stream.
2136        *  @param  end  End of input stream.
2137        *  @param  io  Source of locale and flags.
2138        *  @param  err  Error flags to set.
2139        *  @param  v  Value to format and insert.
2140        *  @return  Iterator after reading.
2141       */
2142       virtual iter_type
2143       do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
2144
2145
2146       virtual iter_type
2147       do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const;
2148
2149       virtual iter_type
2150       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2151               unsigned short&) const;
2152
2153       virtual iter_type
2154       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2155              unsigned int&) const;
2156
2157       virtual iter_type
2158       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2159              unsigned long&) const;
2160
2161 #ifdef _GLIBCXX_USE_LONG_LONG
2162       virtual iter_type
2163       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2164              long long&) const;
2165
2166       virtual iter_type
2167       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2168              unsigned long long&) const;
2169 #endif
2170
2171       virtual iter_type
2172       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2173              float&) const;
2174
2175       virtual iter_type
2176       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2177              double&) const;
2178
2179       virtual iter_type
2180       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2181              long double&) const;
2182
2183       virtual iter_type
2184       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2185              void*&) const;
2186       //@}
2187     };
2188
2189   template<typename _CharT, typename _InIter>
2190     locale::id num_get<_CharT, _InIter>::id;
2191
2192
2193   /**
2194    *  @brief  Facet for converting numbers to strings.
2195    *
2196    *  This facet encapsulates the code to convert a number to a string.  It is
2197    *  used by the ostream numeric insertion operators.
2198    *
2199    *  The num_put template uses protected virtual functions to provide the
2200    *  actual results.  The public accessors forward the call to the virtual
2201    *  functions.  These virtual functions are hooks for developers to
2202    *  implement the behavior they require from the num_put facet.
2203   */
2204   template<typename _CharT, typename _OutIter>
2205     class num_put : public locale::facet
2206     {
2207     public:
2208       // Types:
2209       //@{
2210       /// Public typedefs
2211       typedef _CharT            char_type;
2212       typedef _OutIter          iter_type;
2213       //@}
2214
2215       /// Numpunct facet id.
2216       static locale::id         id;
2217
2218       /**
2219        *  @brief  Constructor performs initialization.
2220        *
2221        *  This is the constructor provided by the standard.
2222        *
2223        *  @param refs  Passed to the base facet class.
2224       */
2225       explicit
2226       num_put(size_t __refs = 0) : facet(__refs) { }
2227
2228       /**
2229        *  @brief  Numeric formatting.
2230        *
2231        *  Formats the boolean @a v and inserts it into a stream.  It does so
2232        *  by calling num_put::do_put().
2233        *
2234        *  If ios_base::boolalpha is set, writes ctype<CharT>::truename() or
2235        *  ctype<CharT>::falsename().  Otherwise formats @a v as an int.
2236        *
2237        *  @param  s  Stream to write to.
2238        *  @param  io  Source of locale and flags.
2239        *  @param  fill  Char_type to use for filling.
2240        *  @param  v  Value to format and insert.
2241        *  @return  Iterator after writing.
2242       */
2243       iter_type
2244       put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
2245       { return this->do_put(__s, __f, __fill, __v); }
2246
2247       //@{
2248       /**
2249        *  @brief  Numeric formatting.
2250        *
2251        *  Formats the integral value @a v and inserts it into a
2252        *  stream.  It does so by calling num_put::do_put().
2253        *
2254        *  Formatting is affected by the flag settings in @a io.
2255        *
2256        *  The basic format is affected by the value of io.flags() &
2257        *  ios_base::basefield.  If equal to ios_base::oct, formats like the
2258        *  printf %o specifier.  Else if equal to ios_base::hex, formats like
2259        *  %x or %X with ios_base::uppercase unset or set respectively.
2260        *  Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu
2261        *  for unsigned values.  Note that if both oct and hex are set, neither
2262        *  will take effect.
2263        *
2264        *  If ios_base::showpos is set, '+' is output before positive values.
2265        *  If ios_base::showbase is set, '0' precedes octal values (except 0)
2266        *  and '0[xX]' precedes hex values.
2267        *
2268        *  Thousands separators are inserted according to numpunct::grouping()
2269        *  and numpunct::thousands_sep().  The decimal point character used is
2270        *  numpunct::decimal_point().
2271        *
2272        *  If io.width() is non-zero, enough @a fill characters are inserted to
2273        *  make the result at least that wide.  If
2274        *  (io.flags() & ios_base::adjustfield) == ios_base::left, result is
2275        *  padded at the end.  If ios_base::internal, then padding occurs
2276        *  immediately after either a '+' or '-' or after '0x' or '0X'.
2277        *  Otherwise, padding occurs at the beginning.
2278        *
2279        *  @param  s  Stream to write to.
2280        *  @param  io  Source of locale and flags.
2281        *  @param  fill  Char_type to use for filling.
2282        *  @param  v  Value to format and insert.
2283        *  @return  Iterator after writing.
2284       */
2285       iter_type
2286       put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
2287       { return this->do_put(__s, __f, __fill, __v); }
2288
2289       iter_type
2290       put(iter_type __s, ios_base& __f, char_type __fill,
2291           unsigned long __v) const
2292       { return this->do_put(__s, __f, __fill, __v); }
2293
2294 #ifdef _GLIBCXX_USE_LONG_LONG
2295       iter_type
2296       put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
2297       { return this->do_put(__s, __f, __fill, __v); }
2298
2299       iter_type
2300       put(iter_type __s, ios_base& __f, char_type __fill,
2301           unsigned long long __v) const
2302       { return this->do_put(__s, __f, __fill, __v); }
2303 #endif
2304       //@}
2305
2306       //@{
2307       /**
2308        *  @brief  Numeric formatting.
2309        *
2310        *  Formats the floating point value @a v and inserts it into a stream.
2311        *  It does so by calling num_put::do_put().
2312        *
2313        *  Formatting is affected by the flag settings in @a io.
2314        *
2315        *  The basic format is affected by the value of io.flags() &
2316        *  ios_base::floatfield.  If equal to ios_base::fixed, formats like the
2317        *  printf %f specifier.  Else if equal to ios_base::scientific, formats
2318        *  like %e or %E with ios_base::uppercase unset or set respectively.
2319        *  Otherwise, formats like %g or %G depending on uppercase.  Note that
2320        *  if both fixed and scientific are set, the effect will also be like
2321        *  %g or %G.
2322        *
2323        *  The output precision is given by io.precision().  This precision is
2324        *  capped at numeric_limits::digits10 + 2 (different for double and
2325        *  long double).  The default precision is 6.
2326        *
2327        *  If ios_base::showpos is set, '+' is output before positive values.
2328        *  If ios_base::showpoint is set, a decimal point will always be
2329        *  output.
2330        *
2331        *  Thousands separators are inserted according to numpunct::grouping()
2332        *  and numpunct::thousands_sep().  The decimal point character used is
2333        *  numpunct::decimal_point().
2334        *
2335        *  If io.width() is non-zero, enough @a fill characters are inserted to
2336        *  make the result at least that wide.  If
2337        *  (io.flags() & ios_base::adjustfield) == ios_base::left, result is
2338        *  padded at the end.  If ios_base::internal, then padding occurs
2339        *  immediately after either a '+' or '-' or after '0x' or '0X'.
2340        *  Otherwise, padding occurs at the beginning.
2341        *
2342        *  @param  s  Stream to write to.
2343        *  @param  io  Source of locale and flags.
2344        *  @param  fill  Char_type to use for filling.
2345        *  @param  v  Value to format and insert.
2346        *  @return  Iterator after writing.
2347       */
2348       iter_type
2349       put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
2350       { return this->do_put(__s, __f, __fill, __v); }
2351
2352       iter_type
2353       put(iter_type __s, ios_base& __f, char_type __fill,
2354           long double __v) const
2355       { return this->do_put(__s, __f, __fill, __v); }
2356       //@}
2357
2358       /**
2359        *  @brief  Numeric formatting.
2360        *
2361        *  Formats the pointer value @a v and inserts it into a stream.  It
2362        *  does so by calling num_put::do_put().
2363        *
2364        *  This function formats @a v as an unsigned long with ios_base::hex
2365        *  and ios_base::showbase set.
2366        *
2367        *  @param  s  Stream to write to.
2368        *  @param  io  Source of locale and flags.
2369        *  @param  fill  Char_type to use for filling.
2370        *  @param  v  Value to format and insert.
2371        *  @return  Iterator after writing.
2372       */
2373       iter_type
2374       put(iter_type __s, ios_base& __f, char_type __fill,
2375           const void* __v) const
2376       { return this->do_put(__s, __f, __fill, __v); }
2377
2378     protected:
2379       template<typename _ValueT>
2380         iter_type
2381         _M_insert_float(iter_type, ios_base& __io, char_type __fill,
2382                         char __mod, _ValueT __v) const;
2383
2384       void
2385       _M_group_float(const char* __grouping, size_t __grouping_size,
2386                      char_type __sep, const char_type* __p, char_type* __new,
2387                      char_type* __cs, int& __len) const;
2388
2389       template<typename _ValueT>
2390         iter_type
2391         _M_insert_int(iter_type, ios_base& __io, char_type __fill,
2392                       _ValueT __v) const;
2393
2394       void
2395       _M_group_int(const char* __grouping, size_t __grouping_size,
2396                    char_type __sep, ios_base& __io, char_type* __new,
2397                    char_type* __cs, int& __len) const;
2398
2399       void
2400       _M_pad(char_type __fill, streamsize __w, ios_base& __io,
2401              char_type* __new, const char_type* __cs, int& __len) const;
2402
2403       /// Destructor.
2404       virtual
2405       ~num_put() { };
2406
2407       //@{
2408       /**
2409        *  @brief  Numeric formatting.
2410        *
2411        *  These functions do the work of formatting numeric values and
2412        *  inserting them into a stream. This function is a hook for derived
2413        *  classes to change the value returned.
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       virtual iter_type
2422       do_put(iter_type, ios_base&, char_type __fill, bool __v) const;
2423
2424       virtual iter_type
2425       do_put(iter_type, ios_base&, char_type __fill, long __v) const;
2426
2427       virtual iter_type
2428       do_put(iter_type, ios_base&, char_type __fill, unsigned long) const;
2429
2430 #ifdef _GLIBCXX_USE_LONG_LONG
2431       virtual iter_type
2432       do_put(iter_type, ios_base&, char_type __fill, long long __v) const;
2433
2434       virtual iter_type
2435       do_put(iter_type, ios_base&, char_type __fill, unsigned long long) const;
2436 #endif
2437
2438       virtual iter_type
2439       do_put(iter_type, ios_base&, char_type __fill, double __v) const;
2440
2441       virtual iter_type
2442       do_put(iter_type, ios_base&, char_type __fill, long double __v) const;
2443
2444       virtual iter_type
2445       do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
2446       //@}
2447     };
2448
2449   template <typename _CharT, typename _OutIter>
2450     locale::id num_put<_CharT, _OutIter>::id;
2451
2452
2453   /**
2454    *  @brief  Facet for localized string comparison.
2455    *
2456    *  This facet encapsulates the code to compare strings in a localized
2457    *  manner.
2458    *
2459    *  The collate template uses protected virtual functions to provide
2460    *  the actual results.  The public accessors forward the call to
2461    *  the virtual functions.  These virtual functions are hooks for
2462    *  developers to implement the behavior they require from the
2463    *  collate facet.
2464   */
2465   template<typename _CharT>
2466     class collate : public locale::facet
2467     {
2468     public:
2469       // Types:
2470       //@{
2471       /// Public typedefs
2472       typedef _CharT                    char_type;
2473       typedef basic_string<_CharT>      string_type;
2474       //@}
2475
2476     protected:
2477       // Underlying "C" library locale information saved from
2478       // initialization, needed by collate_byname as well.
2479       __c_locale                        _M_c_locale_collate;
2480
2481     public:
2482       /// Numpunct facet id.
2483       static locale::id                 id;
2484
2485       /**
2486        *  @brief  Constructor performs initialization.
2487        *
2488        *  This is the constructor provided by the standard.
2489        *
2490        *  @param refs  Passed to the base facet class.
2491       */
2492       explicit
2493       collate(size_t __refs = 0)
2494       : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
2495       { }
2496
2497       /**
2498        *  @brief  Internal constructor. Not for general use.
2499        *
2500        *  This is a constructor for use by the library itself to set up new
2501        *  locales.
2502        *
2503        *  @param cloc  The "C" locale.
2504        *  @param refs  Passed to the base facet class.
2505       */
2506       explicit
2507       collate(__c_locale __cloc, size_t __refs = 0)
2508       : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
2509       { }
2510
2511       /**
2512        *  @brief  Compare two strings.
2513        *
2514        *  This function compares two strings and returns the result by calling
2515        *  collate::do_compare().
2516        *
2517        *  @param lo1  Start of string 1.
2518        *  @param hi1  End of string 1.
2519        *  @param lo2  Start of string 2.
2520        *  @param hi2  End of string 2.
2521        *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
2522       */
2523       int
2524       compare(const _CharT* __lo1, const _CharT* __hi1,
2525               const _CharT* __lo2, const _CharT* __hi2) const
2526       { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
2527
2528       /**
2529        *  @brief  Transform string to comparable form.
2530        *
2531        *  This function is a wrapper for strxfrm functionality.  It takes the
2532        *  input string and returns a modified string that can be directly
2533        *  compared to other transformed strings.  In the "C" locale, this
2534        *  function just returns a copy of the input string.  In some other
2535        *  locales, it may replace two chars with one, change a char for
2536        *  another, etc.  It does so by returning collate::do_transform().
2537        *
2538        *  @param lo  Start of string.
2539        *  @param hi  End of string.
2540        *  @return  Transformed string_type.
2541       */
2542       string_type
2543       transform(const _CharT* __lo, const _CharT* __hi) const
2544       { return this->do_transform(__lo, __hi); }
2545
2546       /**
2547        *  @brief  Return hash of a string.
2548        *
2549        *  This function computes and returns a hash on the input string.  It
2550        *  does so by returning collate::do_hash().
2551        *
2552        *  @param lo  Start of string.
2553        *  @param hi  End of string.
2554        *  @return  Hash value.
2555       */
2556       long
2557       hash(const _CharT* __lo, const _CharT* __hi) const
2558       { return this->do_hash(__lo, __hi); }
2559
2560       // Used to abstract out _CharT bits in virtual member functions, below.
2561       int
2562       _M_compare(const _CharT*, const _CharT*) const;
2563
2564       size_t
2565       _M_transform(_CharT*, const _CharT*, size_t) const;
2566
2567   protected:
2568       /// Destructor.
2569       virtual
2570       ~collate()
2571       { _S_destroy_c_locale(_M_c_locale_collate); }
2572
2573       /**
2574        *  @brief  Compare two strings.
2575        *
2576        *  This function is a hook for derived classes to change the value
2577        *  returned.  @see compare().
2578        *
2579        *  @param lo1  Start of string 1.
2580        *  @param hi1  End of string 1.
2581        *  @param lo2  Start of string 2.
2582        *  @param hi2  End of string 2.
2583        *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
2584       */
2585       virtual int
2586       do_compare(const _CharT* __lo1, const _CharT* __hi1,
2587                  const _CharT* __lo2, const _CharT* __hi2) const;
2588
2589       /**
2590        *  @brief  Transform string to comparable form.
2591        *
2592        *  This function is a hook for derived classes to change the value
2593        *  returned.
2594        *
2595        *  @param lo1  Start of string 1.
2596        *  @param hi1  End of string 1.
2597        *  @param lo2  Start of string 2.
2598        *  @param hi2  End of string 2.
2599        *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
2600       */
2601       virtual string_type
2602       do_transform(const _CharT* __lo, const _CharT* __hi) const;
2603
2604       /**
2605        *  @brief  Return hash of a string.
2606        *
2607        *  This function computes and returns a hash on the input string.  This
2608        *  function is a hook for derived classes to change the value returned.
2609        *
2610        *  @param lo  Start of string.
2611        *  @param hi  End of string.
2612        *  @return  Hash value.
2613       */
2614       virtual long
2615       do_hash(const _CharT* __lo, const _CharT* __hi) const;
2616     };
2617
2618   template<typename _CharT>
2619     locale::id collate<_CharT>::id;
2620
2621   // Specializations.
2622   template<>
2623     int
2624     collate<char>::_M_compare(const char*, const char*) const;
2625
2626   template<>
2627     size_t
2628     collate<char>::_M_transform(char*, const char*, size_t) const;
2629
2630 #ifdef _GLIBCXX_USE_WCHAR_T
2631   template<>
2632     int
2633     collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const;
2634
2635   template<>
2636     size_t
2637     collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const;
2638 #endif
2639
2640   /// @brief  class collate_byname [22.2.4.2].
2641   template<typename _CharT>
2642     class collate_byname : public collate<_CharT>
2643     {
2644     public:
2645       //@{
2646       /// Public typedefs
2647       typedef _CharT               char_type;
2648       typedef basic_string<_CharT> string_type;
2649       //@}
2650
2651       explicit
2652       collate_byname(const char* __s, size_t __refs = 0)
2653       : collate<_CharT>(__refs)
2654       {
2655         if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
2656           {
2657             this->_S_destroy_c_locale(this->_M_c_locale_collate);
2658             this->_S_create_c_locale(this->_M_c_locale_collate, __s);
2659           }
2660       }
2661
2662     protected:
2663       virtual
2664       ~collate_byname() { }
2665     };
2666
2667
2668   /**
2669    *  @brief  Time format ordering data.
2670    *
2671    *  This class provides an enum representing different orderings of day,
2672    *  month, and year.
2673   */
2674   class time_base
2675   {
2676   public:
2677     enum dateorder { no_order, dmy, mdy, ymd, ydm };
2678   };
2679
2680   template<typename _CharT>
2681     struct __timepunct_cache : public locale::facet
2682     {
2683       // List of all known timezones, with GMT first.
2684       static const _CharT*              _S_timezones[14];
2685
2686       const _CharT*                     _M_date_format;
2687       const _CharT*                     _M_date_era_format;
2688       const _CharT*                     _M_time_format;
2689       const _CharT*                     _M_time_era_format;
2690       const _CharT*                     _M_date_time_format;
2691       const _CharT*                     _M_date_time_era_format;
2692       const _CharT*                     _M_am;
2693       const _CharT*                     _M_pm;
2694       const _CharT*                     _M_am_pm_format;
2695
2696       // Day names, starting with "C"'s Sunday.
2697       const _CharT*                     _M_day1;
2698       const _CharT*                     _M_day2;
2699       const _CharT*                     _M_day3;
2700       const _CharT*                     _M_day4;
2701       const _CharT*                     _M_day5;
2702       const _CharT*                     _M_day6;
2703       const _CharT*                     _M_day7;
2704
2705       // Abbreviated day names, starting with "C"'s Sun.
2706       const _CharT*                     _M_aday1;
2707       const _CharT*                     _M_aday2;
2708       const _CharT*                     _M_aday3;
2709       const _CharT*                     _M_aday4;
2710       const _CharT*                     _M_aday5;
2711       const _CharT*                     _M_aday6;
2712       const _CharT*                     _M_aday7;
2713
2714       // Month names, starting with "C"'s January.
2715       const _CharT*                     _M_month01;
2716       const _CharT*                     _M_month02;
2717       const _CharT*                     _M_month03;
2718       const _CharT*                     _M_month04;
2719       const _CharT*                     _M_month05;
2720       const _CharT*                     _M_month06;
2721       const _CharT*                     _M_month07;
2722       const _CharT*                     _M_month08;
2723       const _CharT*                     _M_month09;
2724       const _CharT*                     _M_month10;
2725       const _CharT*                     _M_month11;
2726       const _CharT*                     _M_month12;
2727
2728       // Abbreviated month names, starting with "C"'s Jan.
2729       const _CharT*                     _M_amonth01;
2730       const _CharT*                     _M_amonth02;
2731       const _CharT*                     _M_amonth03;
2732       const _CharT*                     _M_amonth04;
2733       const _CharT*                     _M_amonth05;
2734       const _CharT*                     _M_amonth06;
2735       const _CharT*                     _M_amonth07;
2736       const _CharT*                     _M_amonth08;
2737       const _CharT*                     _M_amonth09;
2738       const _CharT*                     _M_amonth10;
2739       const _CharT*                     _M_amonth11;
2740       const _CharT*                     _M_amonth12;
2741
2742       bool                              _M_allocated;
2743
2744       __timepunct_cache(size_t __refs = 0) : facet(__refs),
2745       _M_date_format(NULL), _M_date_era_format(NULL), _M_time_format(NULL),
2746       _M_time_era_format(NULL), _M_date_time_format(NULL),
2747       _M_date_time_era_format(NULL), _M_am(NULL), _M_pm(NULL),
2748       _M_am_pm_format(NULL), _M_day1(NULL), _M_day2(NULL), _M_day3(NULL),
2749       _M_day4(NULL), _M_day5(NULL), _M_day6(NULL), _M_day7(NULL),
2750       _M_aday1(NULL), _M_aday2(NULL), _M_aday3(NULL), _M_aday4(NULL),
2751       _M_aday5(NULL), _M_aday6(NULL), _M_aday7(NULL), _M_month01(NULL),
2752       _M_month02(NULL), _M_month03(NULL), _M_month04(NULL), _M_month05(NULL),
2753       _M_month06(NULL), _M_month07(NULL), _M_month08(NULL), _M_month09(NULL),
2754       _M_month10(NULL), _M_month11(NULL), _M_month12(NULL), _M_amonth01(NULL),
2755       _M_amonth02(NULL), _M_amonth03(NULL), _M_amonth04(NULL),
2756       _M_amonth05(NULL), _M_amonth06(NULL), _M_amonth07(NULL),
2757       _M_amonth08(NULL), _M_amonth09(NULL), _M_amonth10(NULL),
2758       _M_amonth11(NULL), _M_amonth12(NULL), _M_allocated(false)
2759       { }
2760
2761       ~__timepunct_cache();
2762
2763       void
2764       _M_cache(const locale& __loc);
2765
2766     private:
2767       __timepunct_cache&
2768       operator=(const __timepunct_cache&);
2769       
2770       explicit
2771       __timepunct_cache(const __timepunct_cache&);
2772     };
2773
2774   template<typename _CharT>
2775     __timepunct_cache<_CharT>::~__timepunct_cache()
2776     {
2777       if (_M_allocated)
2778         {
2779           // Unused.
2780         }
2781     }
2782
2783   // Specializations.
2784   template<>
2785     const char*
2786     __timepunct_cache<char>::_S_timezones[14];
2787
2788 #ifdef _GLIBCXX_USE_WCHAR_T
2789   template<>
2790     const wchar_t*
2791     __timepunct_cache<wchar_t>::_S_timezones[14];
2792 #endif
2793
2794   // Generic.
2795   template<typename _CharT>
2796     const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
2797
2798   template<typename _CharT>
2799     class __timepunct : public locale::facet
2800     {
2801     public:
2802       // Types:
2803       typedef _CharT                    __char_type;
2804       typedef basic_string<_CharT>      __string_type;
2805       typedef __timepunct_cache<_CharT> __cache_type;
2806
2807     protected:
2808       __cache_type*                     _M_data;
2809       __c_locale                        _M_c_locale_timepunct;
2810       const char*                       _M_name_timepunct;
2811
2812     public:
2813       /// Numpunct facet id.
2814       static locale::id                 id;
2815
2816       explicit
2817       __timepunct(size_t __refs = 0);
2818
2819       explicit
2820       __timepunct(__cache_type* __cache, size_t __refs = 0);
2821
2822       /**
2823        *  @brief  Internal constructor. Not for general use.
2824        *
2825        *  This is a constructor for use by the library itself to set up new
2826        *  locales.
2827        *
2828        *  @param cloc  The "C" locale.
2829        *  @param s  The name of a locale.
2830        *  @param refs  Passed to the base facet class.
2831       */
2832       explicit
2833       __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);
2834
2835       // FIXME: for error checking purposes _M_put should return the return
2836       // value of strftime/wcsftime.
2837       void
2838       _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
2839              const tm* __tm) const;
2840
2841       void
2842       _M_date_formats(const _CharT** __date) const
2843       {
2844         // Always have default first.
2845         __date[0] = _M_data->_M_date_format;
2846         __date[1] = _M_data->_M_date_era_format;
2847       }
2848
2849       void
2850       _M_time_formats(const _CharT** __time) const
2851       {
2852         // Always have default first.
2853         __time[0] = _M_data->_M_time_format;
2854         __time[1] = _M_data->_M_time_era_format;
2855       }
2856
2857       void
2858       _M_date_time_formats(const _CharT** __dt) const
2859       {
2860         // Always have default first.
2861         __dt[0] = _M_data->_M_date_time_format;
2862         __dt[1] = _M_data->_M_date_time_era_format;
2863       }
2864
2865       void
2866       _M_am_pm_format(const _CharT* __ampm) const
2867       { __ampm = _M_data->_M_am_pm_format; }
2868
2869       void
2870       _M_am_pm(const _CharT** __ampm) const
2871       {
2872         __ampm[0] = _M_data->_M_am;
2873         __ampm[1] = _M_data->_M_pm;
2874       }
2875
2876       void
2877       _M_days(const _CharT** __days) const
2878       {
2879         __days[0] = _M_data->_M_day1;
2880         __days[1] = _M_data->_M_day2;
2881         __days[2] = _M_data->_M_day3;
2882         __days[3] = _M_data->_M_day4;
2883         __days[4] = _M_data->_M_day5;
2884         __days[5] = _M_data->_M_day6;
2885         __days[6] = _M_data->_M_day7;
2886       }
2887
2888       void
2889       _M_days_abbreviated(const _CharT** __days) const
2890       {
2891         __days[0] = _M_data->_M_aday1;
2892         __days[1] = _M_data->_M_aday2;
2893         __days[2] = _M_data->_M_aday3;
2894         __days[3] = _M_data->_M_aday4;
2895         __days[4] = _M_data->_M_aday5;
2896         __days[5] = _M_data->_M_aday6;
2897         __days[6] = _M_data->_M_aday7;
2898       }
2899
2900       void
2901       _M_months(const _CharT** __months) const
2902       {
2903         __months[0] = _M_data->_M_month01;
2904         __months[1] = _M_data->_M_month02;
2905         __months[2] = _M_data->_M_month03;
2906         __months[3] = _M_data->_M_month04;
2907         __months[4] = _M_data->_M_month05;
2908         __months[5] = _M_data->_M_month06;
2909         __months[6] = _M_data->_M_month07;
2910         __months[7] = _M_data->_M_month08;
2911         __months[8] = _M_data->_M_month09;
2912         __months[9] = _M_data->_M_month10;
2913         __months[10] = _M_data->_M_month11;
2914         __months[11] = _M_data->_M_month12;
2915       }
2916
2917       void
2918       _M_months_abbreviated(const _CharT** __months) const
2919       {
2920         __months[0] = _M_data->_M_amonth01;
2921         __months[1] = _M_data->_M_amonth02;
2922         __months[2] = _M_data->_M_amonth03;
2923         __months[3] = _M_data->_M_amonth04;
2924         __months[4] = _M_data->_M_amonth05;
2925         __months[5] = _M_data->_M_amonth06;
2926         __months[6] = _M_data->_M_amonth07;
2927         __months[7] = _M_data->_M_amonth08;
2928         __months[8] = _M_data->_M_amonth09;
2929         __months[9] = _M_data->_M_amonth10;
2930         __months[10] = _M_data->_M_amonth11;
2931         __months[11] = _M_data->_M_amonth12;
2932       }
2933
2934     protected:
2935       virtual
2936       ~__timepunct();
2937
2938       // For use at construction time only.
2939       void
2940       _M_initialize_timepunct(__c_locale __cloc = NULL);
2941     };
2942
2943   template<typename _CharT>
2944     locale::id __timepunct<_CharT>::id;
2945
2946   // Specializations.
2947   template<>
2948     void
2949     __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
2950
2951   template<>
2952     void
2953     __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const;
2954
2955 #ifdef _GLIBCXX_USE_WCHAR_T
2956   template<>
2957     void
2958     __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
2959
2960   template<>
2961     void
2962     __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
2963                                  const tm*) const;
2964 #endif
2965
2966   // Include host and configuration specific timepunct functions.
2967   #include <bits/time_members.h>
2968
2969   /**
2970    *  @brief  Facet for parsing dates and times.
2971    *
2972    *  This facet encapsulates the code to parse and return a date or
2973    *  time from a string.  It is used by the istream numeric
2974    *  extraction operators.
2975    *
2976    *  The time_get template uses protected virtual functions to provide the
2977    *  actual results.  The public accessors forward the call to the virtual
2978    *  functions.  These virtual functions are hooks for developers to
2979    *  implement the behavior they require from the time_get facet.
2980   */
2981   template<typename _CharT, typename _InIter>
2982     class time_get : public locale::facet, public time_base
2983     {
2984     public:
2985       // Types:
2986       //@{
2987       /// Public typedefs
2988       typedef _CharT                    char_type;
2989       typedef _InIter                   iter_type;
2990       //@}
2991       typedef basic_string<_CharT>      __string_type;
2992
2993       /// Numpunct facet id.
2994       static locale::id                 id;
2995
2996       /**
2997        *  @brief  Constructor performs initialization.
2998        *
2999        *  This is the constructor provided by the standard.
3000        *
3001        *  @param refs  Passed to the base facet class.
3002       */
3003       explicit
3004       time_get(size_t __refs = 0)
3005       : facet (__refs) { }
3006
3007       /**
3008        *  @brief  Return preferred order of month, day, and year.
3009        *
3010        *  This function returns an enum from timebase::dateorder giving the
3011        *  preferred ordering if the format "x" given to time_put::put() only
3012        *  uses month, day, and year.  If the format "x" for the associated
3013        *  locale uses other fields, this function returns
3014        *  timebase::dateorder::noorder.
3015        *
3016        *  NOTE: The library always returns noorder at the moment.
3017        *
3018        *  @return  A member of timebase::dateorder.
3019       */
3020       dateorder
3021       date_order()  const
3022       { return this->do_date_order(); }
3023
3024       /**
3025        *  @brief  Parse input time string.
3026        *
3027        *  This function parses a time according to the format "x" and puts the
3028        *  results into a user-supplied struct tm.  The result is returned by
3029        *  calling time_get::do_get_time().
3030        *
3031        *  If there is a valid time string according to format "x", @a tm will
3032        *  be filled in accordingly and the returned iterator will point to the
3033        *  first character beyond the time string.  If an error occurs before
3034        *  the end, err |= ios_base::failbit.  If parsing reads all the
3035        *  characters, err |= ios_base::eofbit.
3036        *
3037        *  @param  beg  Start of string to parse.
3038        *  @param  end  End of string to parse.
3039        *  @param  io  Source of the locale.
3040        *  @param  err  Error flags to set.
3041        *  @param  tm  Pointer to struct tm to fill in.
3042        *  @return  Iterator to first char beyond time string.
3043       */
3044       iter_type
3045       get_time(iter_type __beg, iter_type __end, ios_base& __io,
3046                ios_base::iostate& __err, tm* __tm)  const
3047       { return this->do_get_time(__beg, __end, __io, __err, __tm); }
3048
3049       /**
3050        *  @brief  Parse input date string.
3051        *
3052        *  This function parses a date according to the format "X" and puts the
3053        *  results into a user-supplied struct tm.  The result is returned by
3054        *  calling time_get::do_get_date().
3055        *
3056        *  If there is a valid date string according to format "X", @a tm will
3057        *  be filled in accordingly and the returned iterator will point to the
3058        *  first character beyond the date string.  If an error occurs before
3059        *  the end, err |= ios_base::failbit.  If parsing reads all the
3060        *  characters, err |= ios_base::eofbit.
3061        *
3062        *  @param  beg  Start of string to parse.
3063        *  @param  end  End of string to parse.
3064        *  @param  io  Source of the locale.
3065        *  @param  err  Error flags to set.
3066        *  @param  tm  Pointer to struct tm to fill in.
3067        *  @return  Iterator to first char beyond date string.
3068       */
3069       iter_type
3070       get_date(iter_type __beg, iter_type __end, ios_base& __io,
3071                ios_base::iostate& __err, tm* __tm)  const
3072       { return this->do_get_date(__beg, __end, __io, __err, __tm); }
3073
3074       /**
3075        *  @brief  Parse input weekday string.
3076        *
3077        *  This function parses a weekday name and puts the results into a
3078        *  user-supplied struct tm.  The result is returned by calling
3079        *  time_get::do_get_weekday().
3080        *
3081        *  Parsing starts by parsing an abbreviated weekday name.  If a valid
3082        *  abbreviation is followed by a character that would lead to the full
3083        *  weekday name, parsing continues until the full name is found or an
3084        *  error occurs.  Otherwise parsing finishes at the end of the
3085        *  abbreviated name.
3086        *
3087        *  If an error occurs before the end, err |= ios_base::failbit.  If
3088        *  parsing reads all the characters, err |= ios_base::eofbit.
3089        *
3090        *  @param  beg  Start of string to parse.
3091        *  @param  end  End of string to parse.
3092        *  @param  io  Source of the locale.
3093        *  @param  err  Error flags to set.
3094        *  @param  tm  Pointer to struct tm to fill in.
3095      &nb