OSDN Git Service

cd725f52ad16c5ea96a4c97e4ae65ab5fa00f8c2
[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
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 non-consecutive
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) return _M_widen[static_cast<unsigned char>(__c)];
869         this->_M_widen_init();
870         return this->do_widen(__c);
871       }
872
873       /**
874        *  @brief  Widen char array
875        *
876        *  This function converts each char in the input to char using the
877        *  simplest reasonable transformation.  For an underived ctype<char>
878        *  facet, the argument will be copied unchanged.
879        *
880        *  This function works as if it returns ctype<char>::do_widen(c).
881        *  do_widen() must always return the same result for the same input.
882        *
883        *  Note: this is not what you want for codepage conversions.  See
884        *  codecvt for that.
885        *
886        *  @param lo  Pointer to first char in range.
887        *  @param hi  Pointer to end of range.
888        *  @param to  Pointer to the destination array.
889        *  @return  @a hi.
890       */
891       const char*
892       widen(const char* __lo, const char* __hi, char_type* __to) const
893       {
894         if (_M_widen_ok == 1)
895           {
896             memcpy(__to, __lo, __hi - __lo);
897             return __hi;
898           }
899         if (!_M_widen_ok) _M_widen_init();
900         return this->do_widen(__lo, __hi, __to);
901       }
902
903       /**
904        *  @brief  Narrow char
905        *
906        *  This function converts the char to char using the simplest
907        *  reasonable transformation.  If the conversion fails, dfault is
908        *  returned instead.  For an underived ctype<char> facet, @a c
909        *  will be returned unchanged.
910        *
911        *  This function works as if it returns ctype<char>::do_narrow(c).
912        *  do_narrow() must always return the same result for the same input.
913        *
914        *  Note: this is not what you want for codepage conversions.  See
915        *  codecvt for that.
916        *
917        *  @param c  The char to convert.
918        *  @param dfault  Char to return if conversion fails.
919        *  @return  The converted character.
920       */
921       char
922       narrow(char_type __c, char __dfault) const
923       {
924         if (_M_narrow[static_cast<unsigned char>(__c)])
925           return _M_narrow[static_cast<unsigned char>(__c)];
926         const char __t = do_narrow(__c, __dfault);
927         if (__t != __dfault) _M_narrow[static_cast<unsigned char>(__c)] = __t;
928         return __t;
929       }
930
931       /**
932        *  @brief  Narrow char array
933        *
934        *  This function converts each char in the input to char using the
935        *  simplest reasonable transformation and writes the results to the
936        *  destination array.  For any char in the input that cannot be
937        *  converted, @a dfault is used instead.  For an underived ctype<char>
938        *  facet, the argument will be copied unchanged.
939        *
940        *  This function works as if it returns ctype<char>::do_narrow(lo, hi,
941        *  dfault, to).  do_narrow() must always return the same result for the
942        *  same input.
943        *
944        *  Note: this is not what you want for codepage conversions.  See
945        *  codecvt for that.
946        *
947        *  @param lo  Pointer to start of range.
948        *  @param hi  Pointer to end of range.
949        *  @param dfault  Char to use if conversion fails.
950        *  @param to  Pointer to the destination array.
951        *  @return  @a hi.
952       */
953       const char_type*
954       narrow(const char_type* __lo, const char_type* __hi,
955              char __dfault, char *__to) const
956       {
957         if (__builtin_expect(_M_narrow_ok == 1,true))
958           {
959             memcpy(__to, __lo, __hi - __lo);
960             return __hi;
961           }
962         if (!_M_narrow_ok)
963           _M_narrow_init();
964         return this->do_narrow(__lo, __hi, __dfault, __to);
965       }
966
967     protected:
968       /// Returns a pointer to the mask table provided to the constructor, or
969       /// the default from classic_table() if none was provided.
970       const mask*
971       table() const throw()
972       { return _M_table; }
973
974       /// Returns a pointer to the C locale mask table.
975       static const mask*
976       classic_table() throw();
977
978       /**
979        *  @brief  Destructor.
980        *
981        *  This function deletes table() if @a del was true in the
982        *  constructor.
983       */
984       virtual
985       ~ctype();
986
987       /**
988        *  @brief  Convert to uppercase.
989        *
990        *  This virtual function converts the char argument to uppercase if
991        *  possible.  If not possible (for example, '2'), returns the argument.
992        *
993        *  do_toupper() is a hook for a derived facet to change the behavior of
994        *  uppercasing.  do_toupper() must always return the same result for
995        *  the same input.
996        *
997        *  @param c  The char to convert.
998        *  @return  The uppercase char if convertible, else @a c.
999       */
1000       virtual char_type
1001       do_toupper(char_type) const;
1002
1003       /**
1004        *  @brief  Convert array to uppercase.
1005        *
1006        *  This virtual function converts each char in the range [lo,hi) to
1007        *  uppercase if possible.  Other chars remain untouched.
1008        *
1009        *  do_toupper() is a hook for a derived facet to change the behavior of
1010        *  uppercasing.  do_toupper() must always return the same result for
1011        *  the same input.
1012        *
1013        *  @param lo  Pointer to start of range.
1014        *  @param hi  Pointer to end of range.
1015        *  @return  @a hi.
1016       */
1017       virtual const char_type*
1018       do_toupper(char_type* __lo, const char_type* __hi) const;
1019
1020       /**
1021        *  @brief  Convert to lowercase.
1022        *
1023        *  This virtual function converts the char argument to lowercase if
1024        *  possible.  If not possible (for example, '2'), returns the argument.
1025        *
1026        *  do_tolower() is a hook for a derived facet to change the behavior of
1027        *  lowercasing.  do_tolower() must always return the same result for
1028        *  the same input.
1029        *
1030        *  @param c  The char to convert.
1031        *  @return  The lowercase char if convertible, else @a c.
1032       */
1033       virtual char_type
1034       do_tolower(char_type) const;
1035
1036       /**
1037        *  @brief  Convert array to lowercase.
1038        *
1039        *  This virtual function converts each char in the range [lo,hi) to
1040        *  lowercase if possible.  Other chars remain untouched.
1041        *
1042        *  do_tolower() is a hook for a derived facet to change the behavior of
1043        *  lowercasing.  do_tolower() must always return the same result for
1044        *  the same input.
1045        *
1046        *  @param lo  Pointer to first char in range.
1047        *  @param hi  Pointer to end of range.
1048        *  @return  @a hi.
1049       */
1050       virtual const char_type*
1051       do_tolower(char_type* __lo, const char_type* __hi) const;
1052
1053       /**
1054        *  @brief  Widen char
1055        *
1056        *  This virtual function converts the char to char using the simplest
1057        *  reasonable transformation.  For an underived ctype<char> facet, the
1058        *  argument will be returned unchanged.
1059        *
1060        *  do_widen() is a hook for a derived facet to change the behavior of
1061        *  widening.  do_widen() must always return the same result for the
1062        *  same input.
1063        *
1064        *  Note: this is not what you want for codepage conversions.  See
1065        *  codecvt for that.
1066        *
1067        *  @param c  The char to convert.
1068        *  @return  The converted character.
1069       */
1070       virtual char_type
1071       do_widen(char __c) const
1072       { return __c; }
1073
1074       /**
1075        *  @brief  Widen char array
1076        *
1077        *  This function converts each char in the range [lo,hi) to char using
1078        *  the simplest reasonable transformation.  For an underived
1079        *  ctype<char> facet, the argument will be copied unchanged.
1080        *
1081        *  do_widen() is a hook for a derived facet to change the behavior of
1082        *  widening.  do_widen() must always return the same result for the
1083        *  same input.
1084        *
1085        *  Note: this is not what you want for codepage conversions.  See
1086        *  codecvt for that.
1087        *
1088        *  @param lo  Pointer to start of range.
1089        *  @param hi  Pointer to end of range.
1090        *  @param to  Pointer to the destination array.
1091        *  @return  @a hi.
1092       */
1093       virtual const char*
1094       do_widen(const char* __lo, const char* __hi, char_type* __dest) const
1095       {
1096         memcpy(__dest, __lo, __hi - __lo);
1097         return __hi;
1098       }
1099
1100       /**
1101        *  @brief  Narrow char
1102        *
1103        *  This virtual function converts the char to char using the simplest
1104        *  reasonable transformation.  If the conversion fails, dfault is
1105        *  returned instead.  For an underived ctype<char> facet, @a c will be
1106        *  returned unchanged.
1107        *
1108        *  do_narrow() is a hook for a derived facet to change the behavior of
1109        *  narrowing.  do_narrow() must always return the same result for the
1110        *  same input.
1111        *
1112        *  Note: this is not what you want for codepage conversions.  See
1113        *  codecvt for that.
1114        *
1115        *  @param c  The char to convert.
1116        *  @param dfault  Char to return if conversion fails.
1117        *  @return  The converted char.
1118       */
1119       virtual char
1120       do_narrow(char_type __c, char) const
1121       { return __c; }
1122
1123       /**
1124        *  @brief  Narrow char array to char array
1125        *
1126        *  This virtual function converts each char in the range [lo,hi) to
1127        *  char using the simplest reasonable transformation and writes the
1128        *  results to the destination array.  For any char in the input that
1129        *  cannot be converted, @a dfault is used instead.  For an underived
1130        *  ctype<char> facet, the argument will be copied unchanged.
1131        *
1132        *  do_narrow() is a hook for a derived facet to change the behavior of
1133        *  narrowing.  do_narrow() must always return the same result for the
1134        *  same input.
1135        *
1136        *  Note: this is not what you want for codepage conversions.  See
1137        *  codecvt for that.
1138        *
1139        *  @param lo  Pointer to start of range.
1140        *  @param hi  Pointer to end of range.
1141        *  @param dfault  Char to use if conversion fails.
1142        *  @param to  Pointer to the destination array.
1143        *  @return  @a hi.
1144       */
1145       virtual const char_type*
1146       do_narrow(const char_type* __lo, const char_type* __hi,
1147                 char, char* __dest) const
1148       {
1149         memcpy(__dest, __lo, __hi - __lo);
1150         return __hi;
1151       }
1152
1153     private:
1154
1155       void _M_widen_init() const
1156       {
1157         char __tmp[sizeof(_M_widen)];
1158         for (size_t __i = 0; __i < sizeof(_M_widen); ++__i)
1159           __tmp[__i] = __i;
1160         do_widen(__tmp, __tmp + sizeof(__tmp), _M_widen);
1161
1162         _M_widen_ok = 1;
1163         // Set _M_widen_ok to 2 if memcpy can't be used.
1164         for (size_t __i = 0; __i < sizeof(_M_widen); ++__i)
1165           if (__tmp[__i] != _M_widen[__i])
1166             {
1167               _M_widen_ok = 2;
1168               break;
1169             }
1170       }
1171
1172       // Fill in the narrowing cache and flag whether all values are
1173       // valid or not.  _M_narrow_ok is set to 1 if the whole table is
1174       // narrowed, 2 if only some values could be narrowed.
1175       void _M_narrow_init() const
1176       {
1177         char __tmp[sizeof(_M_narrow)];
1178         for (size_t __i = 0; __i < sizeof(_M_narrow); ++__i)
1179           __tmp[__i] = __i;
1180         do_narrow(__tmp, __tmp + sizeof(__tmp), 0, _M_narrow);
1181
1182         // Check if any default values were created.  Do this by
1183         // renarrowing with a different default value and comparing.
1184         bool __consecutive = true;
1185         for (size_t __i = 0; __i < sizeof(_M_narrow); ++__i)
1186           if (!_M_narrow[__i])
1187             {
1188               char __c;
1189               do_narrow(__tmp + __i, __tmp + __i + 1, 1, &__c);
1190               if (__c == 1)
1191                 {
1192                   __consecutive = false;
1193                   break;
1194                 }
1195             }
1196         _M_narrow_ok = __consecutive ? 1 : 2;
1197       }
1198     };
1199
1200   template<>
1201     const ctype<char>&
1202     use_facet<ctype<char> >(const locale& __loc);
1203
1204 #ifdef _GLIBCXX_USE_WCHAR_T
1205   // 22.2.1.3  ctype<wchar_t> specialization
1206   /**
1207    *  @brief  The ctype<wchar_t> specialization.
1208    *
1209    *  This class defines classification and conversion functions for the
1210    *  wchar_t type.  It gets used by wchar_t streams for many I/O operations.
1211    *  The wchar_t specialization provides a number of optimizations as well.
1212    *
1213    *  ctype<wchar_t> inherits its public methods from
1214    *  __ctype_abstract_base<wchar_t>.
1215   */
1216   template<>
1217     class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
1218     {
1219     public:
1220       // Types:
1221       /// Typedef for the template parameter wchar_t.
1222       typedef wchar_t           char_type;
1223       typedef wctype_t          __wmask_type;
1224
1225     protected:
1226       __c_locale                _M_c_locale_ctype;
1227
1228       // Pre-computed narrowed and widened chars.
1229       bool                      _M_narrow_ok;
1230       char                      _M_narrow[128];
1231       wint_t                    _M_widen[1 + static_cast<unsigned char>(-1)];
1232
1233       // Pre-computed elements for do_is.
1234       mask                      _M_bit[16];
1235       __wmask_type              _M_wmask[16];
1236
1237     public:
1238       // Data Members:
1239       /// The facet id for ctype<wchar_t>
1240       static locale::id         id;
1241
1242       /**
1243        *  @brief  Constructor performs initialization.
1244        *
1245        *  This is the constructor provided by the standard.
1246        *
1247        *  @param refs  Passed to the base facet class.
1248       */
1249       explicit
1250       ctype(size_t __refs = 0);
1251
1252       /**
1253        *  @brief  Constructor performs static initialization.
1254        *
1255        *  This constructor is used to construct the initial C locale facet.
1256        *
1257        *  @param cloc  Handle to C locale data.
1258        *  @param refs  Passed to the base facet class.
1259       */
1260       explicit
1261       ctype(__c_locale __cloc, size_t __refs = 0);
1262
1263     protected:
1264       __wmask_type
1265       _M_convert_to_wmask(const mask __m) const;
1266
1267       /// Destructor
1268       virtual
1269       ~ctype();
1270
1271       /**
1272        *  @brief  Test wchar_t classification.
1273        *
1274        *  This function finds a mask M for @a c and compares it to mask @a m.
1275        *
1276        *  do_is() is a hook for a derived facet to change the behavior of
1277        *  classifying.  do_is() must always return the same result for the
1278        *  same input.
1279        *
1280        *  @param c  The wchar_t to find the mask of.
1281        *  @param m  The mask to compare against.
1282        *  @return  (M & m) != 0.
1283       */
1284       virtual bool
1285       do_is(mask __m, char_type __c) const;
1286
1287       /**
1288        *  @brief  Return a mask array.
1289        *
1290        *  This function finds the mask for each wchar_t in the range [lo,hi)
1291        *  and successively writes it to vec.  vec must have as many elements
1292        *  as the input.
1293        *
1294        *  do_is() is a hook for a derived facet to change the behavior of
1295        *  classifying.  do_is() must always return the same result for the
1296        *  same input.
1297        *
1298        *  @param lo  Pointer to start of range.
1299        *  @param hi  Pointer to end of range.
1300        *  @param vec  Pointer to an array of mask storage.
1301        *  @return  @a hi.
1302       */
1303       virtual const char_type*
1304       do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
1305
1306       /**
1307        *  @brief  Find wchar_t matching mask
1308        *
1309        *  This function searches for and returns the first wchar_t c in
1310        *  [lo,hi) for which is(m,c) is true.
1311        *
1312        *  do_scan_is() is a hook for a derived facet to change the behavior of
1313        *  match searching.  do_is() must always return the same result for the
1314        *  same input.
1315        *
1316        *  @param m  The mask to compare against.
1317        *  @param lo  Pointer to start of range.
1318        *  @param hi  Pointer to end of range.
1319        *  @return  Pointer to a matching wchar_t if found, else @a hi.
1320       */
1321       virtual const char_type*
1322       do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
1323
1324       /**
1325        *  @brief  Find wchar_t not matching mask
1326        *
1327        *  This function searches for and returns a pointer to the first
1328        *  wchar_t c of [lo,hi) for which is(m,c) is false.
1329        *
1330        *  do_scan_is() is a hook for a derived facet to change the behavior of
1331        *  match searching.  do_is() must always return the same result for the
1332        *  same input.
1333        *
1334        *  @param m  The mask to compare against.
1335        *  @param lo  Pointer to start of range.
1336        *  @param hi  Pointer to end of range.
1337        *  @return  Pointer to a non-matching wchar_t if found, else @a hi.
1338       */
1339       virtual const char_type*
1340       do_scan_not(mask __m, const char_type* __lo,
1341                   const char_type* __hi) const;
1342
1343       /**
1344        *  @brief  Convert to uppercase.
1345        *
1346        *  This virtual function converts the wchar_t argument to uppercase if
1347        *  possible.  If not possible (for example, '2'), returns the argument.
1348        *
1349        *  do_toupper() is a hook for a derived facet to change the behavior of
1350        *  uppercasing.  do_toupper() must always return the same result for
1351        *  the same input.
1352        *
1353        *  @param c  The wchar_t to convert.
1354        *  @return  The uppercase wchar_t if convertible, else @a c.
1355       */
1356       virtual char_type
1357       do_toupper(char_type) const;
1358
1359       /**
1360        *  @brief  Convert array to uppercase.
1361        *
1362        *  This virtual function converts each wchar_t in the range [lo,hi) to
1363        *  uppercase if possible.  Other elements remain untouched.
1364        *
1365        *  do_toupper() is a hook for a derived facet to change the behavior of
1366        *  uppercasing.  do_toupper() must always return the same result for
1367        *  the same input.
1368        *
1369        *  @param lo  Pointer to start of range.
1370        *  @param hi  Pointer to end of range.
1371        *  @return  @a hi.
1372       */
1373       virtual const char_type*
1374       do_toupper(char_type* __lo, const char_type* __hi) const;
1375
1376       /**
1377        *  @brief  Convert to lowercase.
1378        *
1379        *  This virtual function converts the argument to lowercase if
1380        *  possible.  If not possible (for example, '2'), returns the argument.
1381        *
1382        *  do_tolower() is a hook for a derived facet to change the behavior of
1383        *  lowercasing.  do_tolower() must always return the same result for
1384        *  the same input.
1385        *
1386        *  @param c  The wchar_t to convert.
1387        *  @return  The lowercase wchar_t if convertible, else @a c.
1388       */
1389       virtual char_type
1390       do_tolower(char_type) const;
1391
1392       /**
1393        *  @brief  Convert array to lowercase.
1394        *
1395        *  This virtual function converts each wchar_t in the range [lo,hi) to
1396        *  lowercase if possible.  Other elements remain untouched.
1397        *
1398        *  do_tolower() is a hook for a derived facet to change the behavior of
1399        *  lowercasing.  do_tolower() must always return the same result for
1400        *  the same input.
1401        *
1402        *  @param lo  Pointer to start of range.
1403        *  @param hi  Pointer to end of range.
1404        *  @return  @a hi.
1405       */
1406       virtual const char_type*
1407       do_tolower(char_type* __lo, const char_type* __hi) const;
1408
1409       /**
1410        *  @brief  Widen char to wchar_t
1411        *
1412        *  This virtual function converts the char to wchar_t using the
1413        *  simplest reasonable transformation.  For an underived ctype<wchar_t>
1414        *  facet, the argument will be cast to wchar_t.
1415        *
1416        *  do_widen() is a hook for a derived facet to change the behavior of
1417        *  widening.  do_widen() must always return the same result for the
1418        *  same input.
1419        *
1420        *  Note: this is not what you want for codepage conversions.  See
1421        *  codecvt for that.
1422        *
1423        *  @param c  The char to convert.
1424        *  @return  The converted wchar_t.
1425       */
1426       virtual char_type
1427       do_widen(char) const;
1428
1429       /**
1430        *  @brief  Widen char array to wchar_t array
1431        *
1432        *  This function converts each char in the input to wchar_t using the
1433        *  simplest reasonable transformation.  For an underived ctype<wchar_t>
1434        *  facet, the argument will be copied, casting each element to wchar_t.
1435        *
1436        *  do_widen() is a hook for a derived facet to change the behavior of
1437        *  widening.  do_widen() must always return the same result for the
1438        *  same input.
1439        *
1440        *  Note: this is not what you want for codepage conversions.  See
1441        *  codecvt for that.
1442        *
1443        *  @param lo  Pointer to start range.
1444        *  @param hi  Pointer to end of range.
1445        *  @param to  Pointer to the destination array.
1446        *  @return  @a hi.
1447       */
1448       virtual const char*
1449       do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
1450
1451       /**
1452        *  @brief  Narrow wchar_t to char
1453        *
1454        *  This virtual function converts the argument to char using the
1455        *  simplest reasonable transformation.  If the conversion fails, dfault
1456        *  is returned instead.  For an underived ctype<wchar_t> facet, @a c will
1457        *  be cast to char and returned.
1458        *
1459        *  do_narrow() is a hook for a derived facet to change the behavior of
1460        *  narrowing.  do_narrow() must always return the same result for the
1461        *  same input.
1462        *
1463        *  Note: this is not what you want for codepage conversions.  See
1464        *  codecvt for that.
1465        *
1466        *  @param c  The wchar_t to convert.
1467        *  @param dfault  Char to return if conversion fails.
1468        *  @return  The converted char.
1469       */
1470       virtual char
1471       do_narrow(char_type, char __dfault) const;
1472
1473       /**
1474        *  @brief  Narrow wchar_t array to char array
1475        *
1476        *  This virtual function converts each wchar_t in the range [lo,hi) to
1477        *  char using the simplest reasonable transformation and writes the
1478        *  results to the destination array.  For any wchar_t in the input that
1479        *  cannot be converted, @a dfault is used instead.  For an underived
1480        *  ctype<wchar_t> facet, the argument will be copied, casting each
1481        *  element to char.
1482        *
1483        *  do_narrow() is a hook for a derived facet to change the behavior of
1484        *  narrowing.  do_narrow() must always return the same result for the
1485        *  same input.
1486        *
1487        *  Note: this is not what you want for codepage conversions.  See
1488        *  codecvt for that.
1489        *
1490        *  @param lo  Pointer to start of range.
1491        *  @param hi  Pointer to end of range.
1492        *  @param dfault  Char to use if conversion fails.
1493        *  @param to  Pointer to the destination array.
1494        *  @return  @a hi.
1495       */
1496       virtual const char_type*
1497       do_narrow(const char_type* __lo, const char_type* __hi,
1498                 char __dfault, char* __dest) const;
1499
1500       // For use at construction time only.
1501       void
1502       _M_initialize_ctype();
1503     };
1504
1505   template<>
1506     const ctype<wchar_t>&
1507     use_facet<ctype<wchar_t> >(const locale& __loc);
1508 #endif //_GLIBCXX_USE_WCHAR_T
1509
1510   // Include host and configuration specific ctype inlines.
1511   #include <bits/ctype_inline.h>
1512
1513   // 22.2.1.2  Template class ctype_byname
1514   template<typename _CharT>
1515     class ctype_byname : public ctype<_CharT>
1516     {
1517     public:
1518       typedef _CharT            char_type;
1519
1520       explicit
1521       ctype_byname(const char* __s, size_t __refs = 0);
1522
1523     protected:
1524       virtual
1525       ~ctype_byname() { };
1526     };
1527
1528   // 22.2.1.4  Class ctype_byname specializations.
1529   template<>
1530     ctype_byname<char>::ctype_byname(const char*, size_t refs);
1531
1532   template<>
1533     ctype_byname<wchar_t>::ctype_byname(const char*, size_t refs);
1534
1535   // 22.2.1.5  Template class codecvt
1536   #include <bits/codecvt.h>
1537
1538   // 22.2.2  The numeric category.
1539   class __num_base
1540   {
1541   public:
1542     // NB: Code depends on the order of _S_atoms_out elements.
1543     // Below are the indices into _S_atoms_out.
1544     enum
1545       {
1546         _S_ominus,
1547         _S_oplus,
1548         _S_ox,
1549         _S_oX,
1550         _S_odigits,
1551         _S_odigits_end = _S_odigits + 16,
1552         _S_oudigits = _S_odigits_end,
1553         _S_oudigits_end = _S_oudigits + 16,
1554         _S_oe = _S_odigits + 14,  // For scientific notation, 'e'
1555         _S_oE = _S_oudigits + 14, // For scientific notation, 'E'
1556         _S_oend = _S_oudigits_end
1557       };
1558
1559     // A list of valid numeric literals for output.  This array
1560     // contains chars that will be passed through the current locale's
1561     // ctype<_CharT>.widen() and then used to render numbers.
1562     // For the standard "C" locale, this is
1563     // "-+xX0123456789abcdef0123456789ABCDEF".
1564     static const char* _S_atoms_out;
1565
1566     // String literal of acceptable (narrow) input, for num_get.
1567     // "-+xX0123456789abcdefABCDEF"
1568     static const char* _S_atoms_in;
1569
1570     enum
1571     {
1572       _S_iminus,
1573       _S_iplus,
1574       _S_ix,
1575       _S_iX,
1576       _S_izero,
1577       _S_ie = _S_izero + 14,
1578       _S_iE = _S_izero + 20,
1579       _S_iend = 26
1580     };
1581
1582     // num_put
1583     // Construct and return valid scanf format for floating point types.
1584     static void
1585     _S_format_float(const ios_base& __io, char* __fptr, char __mod);
1586   };
1587
1588   template<typename _CharT>
1589     struct __numpunct_cache : public locale::facet
1590     {
1591       const char*                       _M_grouping;
1592       size_t                            _M_grouping_size;
1593       bool                              _M_use_grouping;
1594       const _CharT*                     _M_truename;
1595       size_t                            _M_truename_size;
1596       const _CharT*                     _M_falsename;
1597       size_t                            _M_falsename_size;
1598       _CharT                            _M_decimal_point;
1599       _CharT                            _M_thousands_sep;
1600
1601       // A list of valid numeric literals for output: in the standard
1602       // "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF".
1603       // This array contains the chars after having been passed
1604       // through the current locale's ctype<_CharT>.widen().
1605       _CharT                            _M_atoms_out[__num_base::_S_oend];
1606
1607       // A list of valid numeric literals for input: in the standard
1608       // "C" locale, this is "-+xX0123456789abcdefABCDEF"
1609       // This array contains the chars after having been passed
1610       // through the current locale's ctype<_CharT>.widen().
1611       _CharT                            _M_atoms_in[__num_base::_S_iend];
1612
1613       bool                              _M_allocated;
1614
1615       __numpunct_cache(size_t __refs = 0) : facet(__refs),
1616       _M_grouping(NULL), _M_grouping_size(0), _M_use_grouping(false),
1617       _M_truename(NULL), _M_truename_size(0), _M_falsename(NULL),
1618       _M_falsename_size(0), _M_decimal_point(_CharT()),
1619       _M_thousands_sep(_CharT()), _M_allocated(false)
1620       { }
1621
1622       ~__numpunct_cache();
1623
1624       void
1625       _M_cache(const locale& __loc);
1626     };
1627
1628   template<typename _CharT>
1629     void
1630     __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
1631     {
1632       _M_allocated = true;
1633
1634       const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
1635
1636       _M_grouping_size = __np.grouping().size();
1637       char* __grouping = new char[_M_grouping_size];
1638       __np.grouping().copy(__grouping, _M_grouping_size);
1639       _M_grouping = __grouping;
1640       _M_use_grouping = _M_grouping_size && __np.grouping()[0] != 0;
1641
1642       _M_truename_size = __np.truename().size();
1643       _CharT* __truename = new _CharT[_M_truename_size];
1644       __np.truename().copy(__truename, _M_truename_size);
1645       _M_truename = __truename;
1646
1647       _M_falsename_size = __np.falsename().size();
1648       _CharT* __falsename = new _CharT[_M_falsename_size];
1649       __np.falsename().copy(__falsename, _M_falsename_size);
1650       _M_falsename = __falsename;
1651
1652       _M_decimal_point = __np.decimal_point();
1653       _M_thousands_sep = __np.thousands_sep();
1654
1655       const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
1656       __ct.widen(__num_base::_S_atoms_out,
1657                  __num_base::_S_atoms_out + __num_base::_S_oend, _M_atoms_out);
1658       __ct.widen(__num_base::_S_atoms_in,
1659                  __num_base::_S_atoms_in + __num_base::_S_iend, _M_atoms_in);
1660     }
1661
1662   template<typename _CharT>
1663     __numpunct_cache<_CharT>::~__numpunct_cache()
1664     {
1665       if (_M_allocated)
1666         {
1667           delete [] _M_grouping;
1668           delete [] _M_truename;
1669           delete [] _M_falsename;
1670         }
1671     }
1672
1673   /**
1674    *  @brief  Numpunct facet.
1675    *
1676    *  This facet stores several pieces of information related to printing and
1677    *  scanning numbers, such as the decimal point character.  It takes a
1678    *  template parameter specifying the char type.  The numpunct facet is
1679    *  used by streams for many I/O operations involving numbers.
1680    *
1681    *  The numpunct template uses protected virtual functions to provide the
1682    *  actual results.  The public accessors forward the call to the virtual
1683    *  functions.  These virtual functions are hooks for developers to
1684    *  implement the behavior they require from a numpunct facet.
1685   */
1686   template<typename _CharT>
1687     class numpunct : public locale::facet
1688     {
1689     public:
1690       // Types:
1691       //@{
1692       /// Public typedefs
1693       typedef _CharT                    char_type;
1694       typedef basic_string<_CharT>      string_type;
1695       //@}
1696       typedef __numpunct_cache<_CharT>  __cache_type;
1697
1698     protected:
1699       __cache_type*                     _M_data;
1700
1701     public:
1702       /// Numpunct facet id.
1703       static locale::id                 id;
1704
1705       /**
1706        *  @brief  Numpunct constructor.
1707        *
1708        *  @param  refs  Refcount to pass to the base class.
1709        */
1710       explicit
1711       numpunct(size_t __refs = 0) : facet(__refs), _M_data(NULL)
1712       { _M_initialize_numpunct(); }
1713
1714       /**
1715        *  @brief  Internal constructor.  Not for general use.
1716        *
1717        *  This is a constructor for use by the library itself to set up the
1718        *  predefined locale facets.
1719        *
1720        *  @param  cache  __numpunct_cache object.
1721        *  @param  refs  Refcount to pass to the base class.
1722        */
1723       explicit
1724       numpunct(__cache_type* __cache, size_t __refs = 0)
1725       : facet(__refs), _M_data(__cache)
1726       { _M_initialize_numpunct(); }
1727
1728       /**
1729        *  @brief  Internal constructor.  Not for general use.
1730        *
1731        *  This is a constructor for use by the library itself to set up new
1732        *  locales.
1733        *
1734        *  @param  cloc  The "C" locale.
1735        *  @param  refs  Refcount to pass to the base class.
1736        */
1737       explicit
1738       numpunct(__c_locale __cloc, size_t __refs = 0)
1739       : facet(__refs), _M_data(NULL)
1740       { _M_initialize_numpunct(__cloc); }
1741
1742       /**
1743        *  @brief  Return decimal point character.
1744        *
1745        *  This function returns a char_type to use as a decimal point.  It
1746        *  does so by returning returning
1747        *  numpunct<char_type>::do_decimal_point().
1748        *
1749        *  @return  @a char_type representing a decimal point.
1750       */
1751       char_type
1752       decimal_point() const
1753       { return this->do_decimal_point(); }
1754
1755       /**
1756        *  @brief  Return thousands separator character.
1757        *
1758        *  This function returns a char_type to use as a thousands separator.  It
1759        *  does so by returning returning
1760        *  numpunct<char_type>::do_thousands_sep().
1761        *
1762        *  @return  char_type representing a thousands separator.
1763       */
1764       char_type
1765       thousands_sep() const
1766       { return this->do_thousands_sep(); }
1767
1768       /**
1769        *  @brief  Return grouping specification.
1770        *
1771        *  This function returns a string representing groupings for the
1772        *  integer part of a number.  Groupings indicate where thousands
1773        *  separators should be inserted in the integer part of a number.
1774        *
1775        *  Each char in the return string is interpret as an integer rather
1776        *  than a character.  These numbers represent the number of digits in a
1777        *  group.  The first char in the string represents the number of digits
1778        *  in the least significant group.  If a char is negative, it indicates
1779        *  an unlimited number of digits for the group.  If more chars from the
1780        *  string are required to group a number, the last char is used
1781        *  repeatedly.
1782        *
1783        *  For example, if the grouping() returns "\003\002" and is applied to
1784        *  the number 123456789, this corresponds to 12,34,56,789.  Note that
1785        *  if the string was "32", this would put more than 50 digits into the
1786        *  least significant group if the character set is ASCII.
1787        *
1788        *  The string is returned by calling
1789        *  numpunct<char_type>::do_grouping().
1790        *
1791        *  @return  string representing grouping specification.
1792       */
1793       string
1794       grouping() const
1795       { return this->do_grouping(); }
1796
1797       /**
1798        *  @brief  Return string representation of bool true.
1799        *
1800        *  This function returns a string_type containing the text
1801        *  representation for true bool variables.  It does so by calling
1802        *  numpunct<char_type>::do_truename().
1803        *
1804        *  @return  string_type representing printed form of true.
1805       */
1806       string_type
1807       truename() const
1808       { return this->do_truename(); }
1809
1810       /**
1811        *  @brief  Return string representation of bool false.
1812        *
1813        *  This function returns a string_type containing the text
1814        *  representation for false bool variables.  It does so by calling
1815        *  numpunct<char_type>::do_falsename().
1816        *
1817        *  @return  string_type representing printed form of false.
1818       */
1819       string_type
1820       falsename() const
1821       { return this->do_falsename(); }
1822
1823     protected:
1824       /// Destructor.
1825       virtual
1826       ~numpunct();
1827
1828       /**
1829        *  @brief  Return decimal point character.
1830        *
1831        *  Returns a char_type to use as a decimal point.  This function is a
1832        *  hook for derived classes to change the value returned.
1833        *
1834        *  @return  @a char_type representing a decimal point.
1835       */
1836       virtual char_type
1837       do_decimal_point() const
1838       { return _M_data->_M_decimal_point; }
1839
1840       /**
1841        *  @brief  Return thousands separator character.
1842        *
1843        *  Returns a char_type to use as a thousands separator.  This function
1844        *  is a hook for derived classes to change the value returned.
1845        *
1846        *  @return  @a char_type representing a thousands separator.
1847       */
1848       virtual char_type
1849       do_thousands_sep() const
1850       { return _M_data->_M_thousands_sep; }
1851
1852       /**
1853        *  @brief  Return grouping specification.
1854        *
1855        *  Returns a string representing groupings for the integer part of a
1856        *  number.  This function is a hook for derived classes to change the
1857        *  value returned.  @see grouping() for details.
1858        *
1859        *  @return  String representing grouping specification.
1860       */
1861       virtual string
1862       do_grouping() const
1863       { return _M_data->_M_grouping; }
1864
1865       /**
1866        *  @brief  Return string representation of bool true.
1867        *
1868        *  Returns a string_type containing the text representation for true
1869        *  bool variables.  This function is a hook for derived classes to
1870        *  change the value returned.
1871        *
1872        *  @return  string_type representing printed form of true.
1873       */
1874       virtual string_type
1875       do_truename() const
1876       { return _M_data->_M_truename; }
1877
1878       /**
1879        *  @brief  Return string representation of bool false.
1880        *
1881        *  Returns a string_type containing the text representation for false
1882        *  bool variables.  This function is a hook for derived classes to
1883        *  change the value returned.
1884        *
1885        *  @return  string_type representing printed form of false.
1886       */
1887       virtual string_type
1888       do_falsename() const
1889       { return _M_data->_M_falsename; }
1890
1891       // For use at construction time only.
1892       void
1893       _M_initialize_numpunct(__c_locale __cloc = NULL);
1894     };
1895
1896   template<typename _CharT>
1897     locale::id numpunct<_CharT>::id;
1898
1899   template<>
1900     numpunct<char>::~numpunct();
1901
1902   template<>
1903     void
1904     numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
1905
1906 #ifdef _GLIBCXX_USE_WCHAR_T
1907   template<>
1908     numpunct<wchar_t>::~numpunct();
1909
1910   template<>
1911     void
1912     numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
1913 #endif
1914
1915   template<typename _CharT>
1916     class numpunct_byname : public numpunct<_CharT>
1917     {
1918     public:
1919       typedef _CharT                    char_type;
1920       typedef basic_string<_CharT>      string_type;
1921
1922       explicit
1923       numpunct_byname(const char* __s, size_t __refs = 0)
1924       : numpunct<_CharT>(__refs)
1925       {
1926         if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
1927           {
1928             __c_locale __tmp;
1929             this->_S_create_c_locale(__tmp, __s);
1930             this->_M_initialize_numpunct(__tmp);
1931             this->_S_destroy_c_locale(__tmp);
1932           }
1933       }
1934
1935     protected:
1936       virtual
1937       ~numpunct_byname() { }
1938     };
1939
1940   /**
1941    *  @brief  Facet for parsing number strings.
1942    *
1943    *  This facet encapsulates the code to parse and return a number
1944    *  from a string.  It is used by the istream numeric extraction
1945    *  operators.
1946    *
1947    *  The num_get template uses protected virtual functions to provide the
1948    *  actual results.  The public accessors forward the call to the virtual
1949    *  functions.  These virtual functions are hooks for developers to
1950    *  implement the behavior they require from the num_get facet.
1951   */
1952   template<typename _CharT, typename _InIter>
1953     class num_get : public locale::facet, public __num_base
1954     {
1955     public:
1956       // Types:
1957       //@{
1958       /// Public typedefs
1959       typedef _CharT                    char_type;
1960       typedef _InIter                   iter_type;
1961       //@}
1962
1963       /// Numpunct facet id.
1964       static locale::id                 id;
1965
1966       /**
1967        *  @brief  Constructor performs initialization.
1968        *
1969        *  This is the constructor provided by the standard.
1970        *
1971        *  @param refs  Passed to the base facet class.
1972       */
1973       explicit
1974       num_get(size_t __refs = 0) : facet(__refs) { }
1975
1976       /**
1977        *  @brief  Numeric parsing.
1978        *
1979        *  Parses the input stream into the bool @a v.  It does so by calling
1980        *  num_put::do_put().
1981        *
1982        *  If ios_base::boolalpha is set, attempts to read ctype<CharT>::truename() or
1983        *  ctype<CharT>::falsename().  Sets @a v to true or false if
1984        *  successful.  Sets err to ios_base::failbit if reading the string
1985        *  fails.  Sets err to ios_base::eofbit if the stream is emptied.
1986        *
1987        *  If ios_base::boolalpha is not set, proceeds as with reading a long,
1988        *  except if the value is 1, sets @a v to true, if the value is 0, sets
1989        *  @a v to false, and otherwise set err to ios_base::failbit.
1990        *
1991        *  @param  in  Start of input stream.
1992        *  @param  end  End of input stream.
1993        *  @param  io  Source of locale and flags.
1994        *  @param  err  Error flags to set.
1995        *  @param  v  Value to format and insert.
1996        *  @return  Iterator after reading.
1997       */
1998       iter_type
1999       get(iter_type __in, iter_type __end, ios_base& __io,
2000           ios_base::iostate& __err, bool& __v) const
2001       { return this->do_get(__in, __end, __io, __err, __v); }
2002
2003       //@{
2004       /**
2005        *  @brief  Numeric parsing.
2006        *
2007        *  Parses the input stream into the integral variable @a v.  It does so
2008        *  by calling num_put::do_put().
2009        *
2010        *  Parsing is affected by the flag settings in @a io.
2011        *
2012        *  The basic parse is affected by the value of io.flags() &
2013        *  ios_base::basefield.  If equal to ios_base::oct, parses like the
2014        *  scanf %o specifier.  Else if equal to ios_base::hex, parses like %X
2015        *  specifier.  Else if basefield equal to 0, parses like the %i
2016        *  specifier.  Otherwise, parses like %d for signed and %u for unsigned
2017        *  types.  The matching type length modifier is also used.
2018        *
2019        *  Digit grouping is intrepreted according to numpunct::grouping() and
2020        *  numpunct::thousands_sep().  If the pattern of digit groups isn't
2021        *  consistent, sets err to ios_base::failbit.
2022        *
2023        *  If parsing the string yields a valid value for @a v, @a v is set.
2024        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2025        *  Sets err to ios_base::eofbit if the stream is emptied.
2026        *
2027        *  @param  in  Start of input stream.
2028        *  @param  end  End of input stream.
2029        *  @param  io  Source of locale and flags.
2030        *  @param  err  Error flags to set.
2031        *  @param  v  Value to format and insert.
2032        *  @return  Iterator after reading.
2033       */
2034       iter_type
2035       get(iter_type __in, iter_type __end, ios_base& __io,
2036           ios_base::iostate& __err, long& __v) const
2037       { return this->do_get(__in, __end, __io, __err, __v); }
2038
2039       iter_type
2040       get(iter_type __in, iter_type __end, ios_base& __io,
2041           ios_base::iostate& __err, unsigned short& __v) const
2042       { return this->do_get(__in, __end, __io, __err, __v); }
2043
2044       iter_type
2045       get(iter_type __in, iter_type __end, ios_base& __io,
2046           ios_base::iostate& __err, unsigned int& __v)   const
2047       { return this->do_get(__in, __end, __io, __err, __v); }
2048
2049       iter_type
2050       get(iter_type __in, iter_type __end, ios_base& __io,
2051           ios_base::iostate& __err, unsigned long& __v)  const
2052       { return this->do_get(__in, __end, __io, __err, __v); }
2053
2054 #ifdef _GLIBCXX_USE_LONG_LONG
2055       iter_type
2056       get(iter_type __in, iter_type __end, ios_base& __io,
2057           ios_base::iostate& __err, long long& __v) const
2058       { return this->do_get(__in, __end, __io, __err, __v); }
2059
2060       iter_type
2061       get(iter_type __in, iter_type __end, ios_base& __io,
2062           ios_base::iostate& __err, unsigned long long& __v)  const
2063       { return this->do_get(__in, __end, __io, __err, __v); }
2064 #endif
2065       //@}
2066
2067       //@{
2068       /**
2069        *  @brief  Numeric parsing.
2070        *
2071        *  Parses the input stream into the integral variable @a v.  It does so
2072        *  by calling num_put::do_put().
2073        *
2074        *  The input characters are parsed like the scanf %g specifier.  The
2075        *  matching type length modifier is also used.
2076        *
2077        *  The decimal point character used is numpunct::decimal_point().
2078        *  Digit grouping is intrepreted according to numpunct::grouping() and
2079        *  numpunct::thousands_sep().  If the pattern of digit groups isn't
2080        *  consistent, sets err to ios_base::failbit.
2081        *
2082        *  If parsing the string yields a valid value for @a v, @a v is set.
2083        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2084        *  Sets err to ios_base::eofbit if the stream is emptied.
2085        *
2086        *  @param  in  Start of input stream.
2087        *  @param  end  End of input stream.
2088        *  @param  io  Source of locale and flags.
2089        *  @param  err  Error flags to set.
2090        *  @param  v  Value to format and insert.
2091        *  @return  Iterator after reading.
2092       */
2093       iter_type
2094       get(iter_type __in, iter_type __end, ios_base& __io,
2095           ios_base::iostate& __err, float& __v) const
2096       { return this->do_get(__in, __end, __io, __err, __v); }
2097
2098       iter_type
2099       get(iter_type __in, iter_type __end, ios_base& __io,
2100           ios_base::iostate& __err, double& __v) const
2101       { return this->do_get(__in, __end, __io, __err, __v); }
2102
2103       iter_type
2104       get(iter_type __in, iter_type __end, ios_base& __io,
2105           ios_base::iostate& __err, long double& __v) const
2106       { return this->do_get(__in, __end, __io, __err, __v); }
2107       //@}
2108
2109       /**
2110        *  @brief  Numeric parsing.
2111        *
2112        *  Parses the input stream into the pointer variable @a v.  It does so
2113        *  by calling num_put::do_put().
2114        *
2115        *  The input characters are parsed like the scanf %p specifier.
2116        *
2117        *  Digit grouping is intrepreted according to numpunct::grouping() and
2118        *  numpunct::thousands_sep().  If the pattern of digit groups isn't
2119        *  consistent, sets err to ios_base::failbit.
2120        *
2121        *  Note that the digit grouping effect for pointers is a bit ambiguous
2122        *  in the standard and shouldn't be relied on.  See DR 344.
2123        *
2124        *  If parsing the string yields a valid value for @a v, @a v is set.
2125        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2126        *  Sets err to ios_base::eofbit if the stream is emptied.
2127        *
2128        *  @param  in  Start of input stream.
2129        *  @param  end  End of input stream.
2130        *  @param  io  Source of locale and flags.
2131        *  @param  err  Error flags to set.
2132        *  @param  v  Value to format and insert.
2133        *  @return  Iterator after reading.
2134       */
2135       iter_type
2136       get(iter_type __in, iter_type __end, ios_base& __io,
2137           ios_base::iostate& __err, void*& __v) const
2138       { return this->do_get(__in, __end, __io, __err, __v); }
2139
2140     protected:
2141       /// Destructor.
2142       virtual ~num_get() { }
2143
2144       iter_type
2145       _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
2146                        string& __xtrc) const;
2147
2148       template<typename _ValueT>
2149         iter_type
2150         _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
2151                        _ValueT& __v) const;
2152
2153       //@{
2154       /**
2155        *  @brief  Numeric parsing.
2156        *
2157        *  Parses the input stream into the variable @a v.  This function is a
2158        *  hook for derived classes to change the value returned.  @see get()
2159        *  for more details.
2160        *
2161        *  @param  in  Start of input stream.
2162        *  @param  end  End of input stream.
2163        *  @param  io  Source of locale and flags.
2164        *  @param  err  Error flags to set.
2165        *  @param  v  Value to format and insert.
2166        *  @return  Iterator after reading.
2167       */
2168       virtual iter_type
2169       do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
2170
2171
2172       virtual iter_type
2173       do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const;
2174
2175       virtual iter_type
2176       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2177               unsigned short&) const;
2178
2179       virtual iter_type
2180       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2181              unsigned int&) const;
2182
2183       virtual iter_type
2184       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2185              unsigned long&) const;
2186
2187 #ifdef _GLIBCXX_USE_LONG_LONG
2188       virtual iter_type
2189       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2190              long long&) const;
2191
2192       virtual iter_type
2193       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2194              unsigned long long&) const;
2195 #endif
2196
2197       virtual iter_type
2198       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2199              float&) const;
2200
2201       virtual iter_type
2202       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2203              double&) const;
2204
2205       virtual iter_type
2206       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2207              long double&) const;
2208
2209       virtual iter_type
2210       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2211              void*&) const;
2212       //@}
2213     };
2214
2215   template<typename _CharT, typename _InIter>
2216     locale::id num_get<_CharT, _InIter>::id;
2217
2218
2219   /**
2220    *  @brief  Facet for converting numbers to strings.
2221    *
2222    *  This facet encapsulates the code to convert a number to a string.  It is
2223    *  used by the ostream numeric insertion operators.
2224    *
2225    *  The num_put template uses protected virtual functions to provide the
2226    *  actual results.  The public accessors forward the call to the virtual
2227    *  functions.  These virtual functions are hooks for developers to
2228    *  implement the behavior they require from the num_put facet.
2229   */
2230   template<typename _CharT, typename _OutIter>
2231     class num_put : public locale::facet, public __num_base
2232     {
2233     public:
2234       // Types:
2235       //@{
2236       /// Public typedefs
2237       typedef _CharT            char_type;
2238       typedef _OutIter          iter_type;
2239       //@}
2240
2241       /// Numpunct facet id.
2242       static locale::id         id;
2243
2244       /**
2245        *  @brief  Constructor performs initialization.
2246        *
2247        *  This is the constructor provided by the standard.
2248        *
2249        *  @param refs  Passed to the base facet class.
2250       */
2251       explicit
2252       num_put(size_t __refs = 0) : facet(__refs) { }
2253
2254       /**
2255        *  @brief  Numeric formatting.
2256        *
2257        *  Formats the boolean @a v and inserts it into a stream.  It does so
2258        *  by calling num_put::do_put().
2259        *
2260        *  If ios_base::boolalpha is set, writes ctype<CharT>::truename() or
2261        *  ctype<CharT>::falsename().  Otherwise formats @a v as an int.
2262        *
2263        *  @param  s  Stream to write to.
2264        *  @param  io  Source of locale and flags.
2265        *  @param  fill  Char_type to use for filling.
2266        *  @param  v  Value to format and insert.
2267        *  @return  Iterator after writing.
2268       */
2269       iter_type
2270       put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
2271       { return this->do_put(__s, __f, __fill, __v); }
2272
2273       //@{
2274       /**
2275        *  @brief  Numeric formatting.
2276        *
2277        *  Formats the integral value @a v and inserts it into a stream.  It does so
2278        *  by calling num_put::do_put().
2279        *
2280        *  Formatting is affected by the flag settings in @a io.
2281        *
2282        *  The basic format is affected by the value of io.flags() &
2283        *  ios_base::basefield.  If equal to ios_base::oct, formats like the
2284        *  printf %o specifier.  Else if equal to ios_base::hex, formats like
2285        *  %x or %X with ios_base::uppercase unset or set respectively.
2286        *  Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu
2287        *  for unsigned values.  Note that if both oct and hex are set, neither
2288        *  will take effect.
2289        *
2290        *  If ios_base::showpos is set, '+' is output before positive values.
2291        *  If ios_base::showbase is set, '0' precedes octal values (except 0)
2292        *  and '0[xX]' precedes hex values.
2293        *
2294        *  Thousands separators are inserted according to numpunct::grouping()
2295        *  and numpunct::thousands_sep().  The decimal point character used is
2296        *  numpunct::decimal_point().
2297        *
2298        *  If io.width() is non-zero, enough @a fill characters are inserted to
2299        *  make the result at least that wide.  If
2300        *  (io.flags() & ios_base::adjustfield) == ios_base::left, result is
2301        *  padded at the end.  If ios_base::internal, then padding occurs
2302        *  immediately after either a '+' or '-' or after '0x' or '0X'.
2303        *  Otherwise, padding occurs at the beginning.
2304        *
2305        *  @param  s  Stream to write to.
2306        *  @param  io  Source of locale and flags.
2307        *  @param  fill  Char_type to use for filling.
2308        *  @param  v  Value to format and insert.
2309        *  @return  Iterator after writing.
2310       */
2311       iter_type
2312       put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
2313       { return this->do_put(__s, __f, __fill, __v); }
2314
2315       iter_type
2316       put(iter_type __s, ios_base& __f, char_type __fill,
2317           unsigned long __v) const
2318       { return this->do_put(__s, __f, __fill, __v); }
2319
2320 #ifdef _GLIBCXX_USE_LONG_LONG
2321       iter_type
2322       put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
2323       { return this->do_put(__s, __f, __fill, __v); }
2324
2325       iter_type
2326       put(iter_type __s, ios_base& __f, char_type __fill,
2327           unsigned long long __v) const
2328       { return this->do_put(__s, __f, __fill, __v); }
2329 #endif
2330       //@}
2331
2332       //@{
2333       /**
2334        *  @brief  Numeric formatting.
2335        *
2336        *  Formats the floating point value @a v and inserts it into a stream.
2337        *  It does so by calling num_put::do_put().
2338        *
2339        *  Formatting is affected by the flag settings in @a io.
2340        *
2341        *  The basic format is affected by the value of io.flags() &
2342        *  ios_base::floatfield.  If equal to ios_base::fixed, formats like the
2343        *  printf %f specifier.  Else if equal to ios_base::scientific, formats
2344        *  like %e or %E with ios_base::uppercase unset or set respectively.
2345        *  Otherwise, formats like %g or %G depending on uppercase.  Note that
2346        *  if both fixed and scientific are set, the effect will also be like
2347        *  %g or %G.
2348        *
2349        *  The output precision is given by io.precision().  This precision is
2350        *  capped at numeric_limits::digits10 + 2 (different for double and
2351        *  long double).  The default precision is 6.
2352        *
2353        *  If ios_base::showpos is set, '+' is output before positive values.
2354        *  If ios_base::showpoint is set, a decimal point will always be
2355        *  output.
2356        *
2357        *  Thousands separators are inserted according to numpunct::grouping()
2358        *  and numpunct::thousands_sep().  The decimal point character used is
2359        *  numpunct::decimal_point().
2360        *
2361        *  If io.width() is non-zero, enough @a fill characters are inserted to
2362        *  make the result at least that wide.  If
2363        *  (io.flags() & ios_base::adjustfield) == ios_base::left, result is
2364        *  padded at the end.  If ios_base::internal, then padding occurs
2365        *  immediately after either a '+' or '-' or after '0x' or '0X'.
2366        *  Otherwise, padding occurs at the beginning.
2367        *
2368        *  @param  s  Stream to write to.
2369        *  @param  io  Source of locale and flags.
2370        *  @param  fill  Char_type to use for filling.
2371        *  @param  v  Value to format and insert.
2372        *  @return  Iterator after writing.
2373       */
2374       iter_type
2375       put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
2376       { return this->do_put(__s, __f, __fill, __v); }
2377
2378       iter_type
2379       put(iter_type __s, ios_base& __f, char_type __fill,
2380           long double __v) const
2381       { return this->do_put(__s, __f, __fill, __v); }
2382       //@}
2383
2384       /**
2385        *  @brief  Numeric formatting.
2386        *
2387        *  Formats the pointer value @a v and inserts it into a stream.  It
2388        *  does so by calling num_put::do_put().
2389        *
2390        *  This function formats @a v as an unsigned long with ios_base::hex
2391        *  and ios_base::showbase set.
2392        *
2393        *  @param  s  Stream to write to.
2394        *  @param  io  Source of locale and flags.
2395        *  @param  fill  Char_type to use for filling.
2396        *  @param  v  Value to format and insert.
2397        *  @return  Iterator after writing.
2398       */
2399       iter_type
2400       put(iter_type __s, ios_base& __f, char_type __fill,
2401           const void* __v) const
2402       { return this->do_put(__s, __f, __fill, __v); }
2403
2404     protected:
2405       template<typename _ValueT>
2406         iter_type
2407         _M_insert_float(iter_type, ios_base& __io, char_type __fill,
2408                         char __mod, _ValueT __v) const;
2409
2410       void
2411       _M_group_float(const char* __grouping, size_t __grouping_size,
2412                      char_type __sep, const char_type* __p, char_type* __new,
2413                      char_type* __cs, int& __len) const;
2414
2415       template<typename _ValueT>
2416         iter_type
2417         _M_insert_int(iter_type, ios_base& __io, char_type __fill,
2418                       _ValueT __v) const;
2419
2420       void
2421       _M_group_int(const char* __grouping, size_t __grouping_size,
2422                    char_type __sep, ios_base& __io, char_type* __new,
2423                    char_type* __cs, int& __len) const;
2424
2425       void
2426       _M_pad(char_type __fill, streamsize __w, ios_base& __io,
2427              char_type* __new, const char_type* __cs, int& __len) const;
2428
2429       /// Destructor.
2430       virtual
2431       ~num_put() { };
2432
2433       //@{
2434       /**
2435        *  @brief  Numeric formatting.
2436        *
2437        *  These functions do the work of formatting numeric values and
2438        *  inserting them into a stream. This function is a hook for derived
2439        *  classes to change the value returned.
2440        *
2441        *  @param  s  Stream to write to.
2442        *  @param  io  Source of locale and flags.
2443        *  @param  fill  Char_type to use for filling.
2444        *  @param  v  Value to format and insert.
2445        *  @return  Iterator after writing.
2446       */
2447       virtual iter_type
2448       do_put(iter_type, ios_base&, char_type __fill, bool __v) const;
2449
2450       virtual iter_type
2451       do_put(iter_type, ios_base&, char_type __fill, long __v) const;
2452
2453       virtual iter_type
2454       do_put(iter_type, ios_base&, char_type __fill, unsigned long) const;
2455
2456 #ifdef _GLIBCXX_USE_LONG_LONG
2457       virtual iter_type
2458       do_put(iter_type, ios_base&, char_type __fill, long long __v) const;
2459
2460       virtual iter_type
2461       do_put(iter_type, ios_base&, char_type __fill, unsigned long long) const;
2462 #endif
2463
2464       virtual iter_type
2465       do_put(iter_type, ios_base&, char_type __fill, double __v) const;
2466
2467       virtual iter_type
2468       do_put(iter_type, ios_base&, char_type __fill, long double __v) const;
2469
2470       virtual iter_type
2471       do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
2472       //@}
2473     };
2474
2475   template <typename _CharT, typename _OutIter>
2476     locale::id num_put<_CharT, _OutIter>::id;
2477
2478
2479   /**
2480    *  @brief  Facet for localized string comparison.
2481    *
2482    *  This facet encapsulates the code to compare strings in a localized
2483    *  manner.
2484    *
2485    *  The collate template uses protected virtual functions to provide
2486    *  the actual results.  The public accessors forward the call to
2487    *  the virtual functions.  These virtual functions are hooks for
2488    *  developers to implement the behavior they require from the
2489    *  collate facet.
2490   */
2491   template<typename _CharT>
2492     class collate : public locale::facet
2493     {
2494     public:
2495       // Types:
2496       //@{
2497       /// Public typedefs
2498       typedef _CharT                    char_type;
2499       typedef basic_string<_CharT>      string_type;
2500       //@}
2501
2502     protected:
2503       // Underlying "C" library locale information saved from
2504       // initialization, needed by collate_byname as well.
2505       __c_locale                        _M_c_locale_collate;
2506
2507     public:
2508       /// Numpunct facet id.
2509       static locale::id                 id;
2510
2511       /**
2512        *  @brief  Constructor performs initialization.
2513        *
2514        *  This is the constructor provided by the standard.
2515        *
2516        *  @param refs  Passed to the base facet class.
2517       */
2518       explicit
2519       collate(size_t __refs = 0)
2520       : facet(__refs)
2521       { _M_c_locale_collate = _S_get_c_locale(); }
2522
2523       /**
2524        *  @brief  Internal constructor. Not for general use.
2525        *
2526        *  This is a constructor for use by the library itself to set up new
2527        *  locales.
2528        *
2529        *  @param cloc  The "C" locale.
2530        *  @param refs  Passed to the base facet class.
2531       */
2532       explicit
2533       collate(__c_locale __cloc, size_t __refs = 0)
2534       : facet(__refs)
2535       { _M_c_locale_collate = _S_clone_c_locale(__cloc); }
2536
2537       /**
2538        *  @brief  Compare two strings.
2539        *
2540        *  This function compares two strings and returns the result by calling
2541        *  collate::do_compare().
2542        *
2543        *  @param lo1  Start of string 1.
2544        *  @param hi1  End of string 1.
2545        *  @param lo2  Start of string 2.
2546        *  @param hi2  End of string 2.
2547        *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
2548       */
2549       int
2550       compare(const _CharT* __lo1, const _CharT* __hi1,
2551               const _CharT* __lo2, const _CharT* __hi2) const
2552       { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
2553
2554       /**
2555        *  @brief  Transform string to comparable form.
2556        *
2557        *  This function is a wrapper for strxfrm functionality.  It takes the
2558        *  input string and returns a modified string that can be directly
2559        *  compared to other transformed strings.  In the "C" locale, this
2560        *  function just returns a copy of the input string.  In some other
2561        *  locales, it may replace two chars with one, change a char for
2562        *  another, etc.  It does so by returning collate::do_transform().
2563        *
2564        *  @param lo  Start of string.
2565        *  @param hi  End of string.
2566        *  @return  Transformed string_type.
2567       */
2568       string_type
2569       transform(const _CharT* __lo, const _CharT* __hi) const
2570       { return this->do_transform(__lo, __hi); }
2571
2572       /**
2573        *  @brief  Return hash of a string.
2574        *
2575        *  This function computes and returns a hash on the input string.  It
2576        *  does so by returning collate::do_hash().
2577        *
2578        *  @param lo  Start of string.
2579        *  @param hi  End of string.
2580        *  @return  Hash value.
2581       */
2582       long
2583       hash(const _CharT* __lo, const _CharT* __hi) const
2584       { return this->do_hash(__lo, __hi); }
2585
2586       // Used to abstract out _CharT bits in virtual member functions, below.
2587       int
2588       _M_compare(const _CharT*, const _CharT*) const;
2589
2590       size_t
2591       _M_transform(_CharT*, const _CharT*, size_t) const;
2592
2593   protected:
2594       /// Destructor.
2595       virtual
2596       ~collate()
2597       { _S_destroy_c_locale(_M_c_locale_collate); }
2598
2599       /**
2600        *  @brief  Compare two strings.
2601        *
2602        *  This function is a hook for derived classes to change the value
2603        *  returned.  @see compare().
2604        *
2605        *  @param lo1  Start of string 1.
2606        *  @param hi1  End of string 1.
2607        *  @param lo2  Start of string 2.
2608        *  @param hi2  End of string 2.
2609        *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
2610       */
2611       virtual int
2612       do_compare(const _CharT* __lo1, const _CharT* __hi1,
2613                  const _CharT* __lo2, const _CharT* __hi2) const;
2614
2615       /**
2616        *  @brief  Transform string to comparable form.
2617        *
2618        *  This function is a hook for derived classes to change the value
2619        *  returned.
2620        *
2621        *  @param lo1  Start of string 1.
2622        *  @param hi1  End of string 1.
2623        *  @param lo2  Start of string 2.
2624        *  @param hi2  End of string 2.
2625        *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
2626       */
2627       virtual string_type
2628       do_transform(const _CharT* __lo, const _CharT* __hi) const;
2629
2630       /**
2631        *  @brief  Return hash of a string.
2632        *
2633        *  This function computes and returns a hash on the input string.  This
2634        *  function is a hook for derived classes to change the value returned.
2635        *
2636        *  @param lo  Start of string.
2637        *  @param hi  End of string.
2638        *  @return  Hash value.
2639       */
2640       virtual long
2641       do_hash(const _CharT* __lo, const _CharT* __hi) const;
2642     };
2643
2644   template<typename _CharT>
2645     locale::id collate<_CharT>::id;
2646
2647   // Specializations.
2648   template<>
2649     int
2650     collate<char>::_M_compare(const char*, const char*) const;
2651
2652   template<>
2653     size_t
2654     collate<char>::_M_transform(char*, const char*, size_t) const;
2655
2656 #ifdef _GLIBCXX_USE_WCHAR_T
2657   template<>
2658     int
2659     collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const;
2660
2661   template<>
2662     size_t
2663     collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const;
2664 #endif
2665
2666   template<typename _CharT>
2667     class collate_byname : public collate<_CharT>
2668     {
2669     public:
2670       //@{
2671       /// Public typedefs
2672       typedef _CharT               char_type;
2673       typedef basic_string<_CharT> string_type;
2674       //@}
2675
2676       explicit
2677       collate_byname(const char* __s, size_t __refs = 0)
2678       : collate<_CharT>(__refs)
2679       {
2680         if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
2681           {
2682             this->_S_destroy_c_locale(this->_M_c_locale_collate);
2683             this->_S_create_c_locale(this->_M_c_locale_collate, __s);
2684           }
2685       }
2686
2687     protected:
2688       virtual
2689       ~collate_byname() { }
2690     };
2691
2692
2693   /**
2694    *  @brief  Time format ordering data.
2695    *
2696    *  This class provides an enum representing different orderings of day,
2697    *  month, and year.
2698   */
2699   class time_base
2700   {
2701   public:
2702     enum dateorder { no_order, dmy, mdy, ymd, ydm };
2703   };
2704
2705   template<typename _CharT>
2706     struct __timepunct_cache : public locale::facet
2707     {
2708       // List of all known timezones, with GMT first.
2709       static const _CharT*              _S_timezones[14];
2710
2711       const _CharT*                     _M_date_format;
2712       const _CharT*                     _M_date_era_format;
2713       const _CharT*                     _M_time_format;
2714       const _CharT*                     _M_time_era_format;
2715       const _CharT*                     _M_date_time_format;
2716       const _CharT*                     _M_date_time_era_format;
2717       const _CharT*                     _M_am;
2718       const _CharT*                     _M_pm;
2719       const _CharT*                     _M_am_pm_format;
2720
2721       // Day names, starting with "C"'s Sunday.
2722       const _CharT*                     _M_day1;
2723       const _CharT*                     _M_day2;
2724       const _CharT*                     _M_day3;
2725       const _CharT*                     _M_day4;
2726       const _CharT*                     _M_day5;
2727       const _CharT*                     _M_day6;
2728       const _CharT*                     _M_day7;
2729
2730       // Abbreviated day names, starting with "C"'s Sun.
2731       const _CharT*                     _M_aday1;
2732       const _CharT*                     _M_aday2;
2733       const _CharT*                     _M_aday3;
2734       const _CharT*                     _M_aday4;
2735       const _CharT*                     _M_aday5;
2736       const _CharT*                     _M_aday6;
2737       const _CharT*                     _M_aday7;
2738
2739       // Month names, starting with "C"'s January.
2740       const _CharT*                     _M_month01;
2741       const _CharT*                     _M_month02;
2742       const _CharT*                     _M_month03;
2743       const _CharT*                     _M_month04;
2744       const _CharT*                     _M_month05;
2745       const _CharT*                     _M_month06;
2746       const _CharT*                     _M_month07;
2747       const _CharT*                     _M_month08;
2748       const _CharT*                     _M_month09;
2749       const _CharT*                     _M_month10;
2750       const _CharT*                     _M_month11;
2751       const _CharT*                     _M_month12;
2752
2753       // Abbreviated month names, starting with "C"'s Jan.
2754       const _CharT*                     _M_amonth01;
2755       const _CharT*                     _M_amonth02;
2756       const _CharT*                     _M_amonth03;
2757       const _CharT*                     _M_amonth04;
2758       const _CharT*                     _M_amonth05;
2759       const _CharT*                     _M_amonth06;
2760       const _CharT*                     _M_amonth07;
2761       const _CharT*                     _M_amonth08;
2762       const _CharT*                     _M_amonth09;
2763       const _CharT*                     _M_amonth10;
2764       const _CharT*                     _M_amonth11;
2765       const _CharT*                     _M_amonth12;
2766
2767       bool                              _M_allocated;
2768
2769       __timepunct_cache(size_t __refs = 0) : facet(__refs),
2770       _M_date_format(NULL), _M_date_era_format(NULL), _M_time_format(NULL),
2771       _M_time_era_format(NULL), _M_date_time_format(NULL),
2772       _M_date_time_era_format(NULL), _M_am(NULL), _M_pm(NULL),
2773       _M_am_pm_format(NULL), _M_day1(NULL), _M_day2(NULL), _M_day3(NULL),
2774       _M_day4(NULL), _M_day5(NULL), _M_day6(NULL), _M_day7(NULL),
2775       _M_aday1(NULL), _M_aday2(NULL), _M_aday3(NULL), _M_aday4(NULL),
2776       _M_aday5(NULL), _M_aday6(NULL), _M_aday7(NULL), _M_month01(NULL),
2777       _M_month02(NULL), _M_month03(NULL), _M_month04(NULL), _M_month05(NULL),
2778       _M_month06(NULL), _M_month07(NULL), _M_month08(NULL), _M_month09(NULL),
2779       _M_month10(NULL), _M_month11(NULL), _M_month12(NULL), _M_amonth01(NULL),
2780       _M_amonth02(NULL), _M_amonth03(NULL), _M_amonth04(NULL),
2781       _M_amonth05(NULL), _M_amonth06(NULL), _M_amonth07(NULL),
2782       _M_amonth08(NULL), _M_amonth09(NULL), _M_amonth10(NULL),
2783       _M_amonth11(NULL), _M_amonth12(NULL), _M_allocated(false)
2784       { }
2785
2786       ~__timepunct_cache();
2787
2788       void
2789       _M_cache(const locale& __loc);
2790     };
2791
2792   template<typename _CharT>
2793     __timepunct_cache<_CharT>::~__timepunct_cache()
2794     {
2795       if (_M_allocated)
2796         {
2797           // XXX.
2798         }
2799     }
2800
2801   // Specializations.
2802   template<>
2803     const char*
2804     __timepunct_cache<char>::_S_timezones[14];
2805
2806 #ifdef _GLIBCXX_USE_WCHAR_T
2807   template<>
2808     const wchar_t*
2809     __timepunct_cache<wchar_t>::_S_timezones[14];
2810 #endif
2811
2812   // Generic.
2813   template<typename _CharT>
2814     const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
2815
2816   template<typename _CharT>
2817     class __timepunct : public locale::facet
2818     {
2819     public:
2820       // Types:
2821       typedef _CharT                    __char_type;
2822       typedef basic_string<_CharT>      __string_type;
2823       typedef __timepunct_cache<_CharT> __cache_type;
2824
2825     protected:
2826       __cache_type*                     _M_data;
2827       __c_locale                        _M_c_locale_timepunct;
2828       const char*                       _M_name_timepunct;
2829
2830     public:
2831       /// Numpunct facet id.
2832       static locale::id                 id;
2833
2834       explicit
2835       __timepunct(size_t __refs = 0);
2836
2837       explicit
2838       __timepunct(__cache_type* __cache, size_t __refs = 0);
2839
2840       /**
2841        *  @brief  Internal constructor. Not for general use.
2842        *
2843        *  This is a constructor for use by the library itself to set up new
2844        *  locales.
2845        *
2846        *  @param cloc  The "C" locale.
2847        *  @param s  The name of a locale.
2848        *  @param refs  Passed to the base facet class.
2849       */
2850       explicit
2851       __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);
2852
2853       void
2854       _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
2855              const tm* __tm) const;
2856
2857       void
2858       _M_date_formats(const _CharT** __date) const
2859       {
2860         // Always have default first.
2861         __date[0] = _M_data->_M_date_format;
2862         __date[1] = _M_data->_M_date_era_format;
2863       }
2864
2865       void
2866       _M_time_formats(const _CharT** __time) const
2867       {
2868         // Always have default first.
2869         __time[0] = _M_data->_M_time_format;
2870         __time[1] = _M_data->_M_time_era_format;
2871       }
2872
2873       void
2874       _M_ampm(const _CharT** __ampm) const
2875       {
2876         __ampm[0] = _M_data->_M_am;
2877         __ampm[1] = _M_data->_M_pm;
2878       }
2879
2880       void
2881       _M_date_time_formats(const _CharT** __dt) const
2882       {
2883         // Always have default first.
2884         __dt[0] = _M_data->_M_date_time_format;
2885         __dt[1] = _M_data->_M_date_time_era_format;
2886       }
2887
2888       void
2889       _M_days(const _CharT** __days) const
2890       {
2891         __days[0] = _M_data->_M_day1;
2892         __days[1] = _M_data->_M_day2;
2893         __days[2] = _M_data->_M_day3;
2894         __days[3] = _M_data->_M_day4;
2895         __days[4] = _M_data->_M_day5;
2896         __days[5] = _M_data->_M_day6;
2897         __days[6] = _M_data->_M_day7;
2898       }
2899
2900       void
2901       _M_days_abbreviated(const _CharT** __days) const
2902       {
2903         __days[0] = _M_data->_M_aday1;
2904         __days[1] = _M_data->_M_aday2;
2905         __days[2] = _M_data->_M_aday3;
2906         __days[3] = _M_data->_M_aday4;
2907         __days[4] = _M_data->_M_aday5;
2908         __days[5] = _M_data->_M_aday6;
2909         __days[6] = _M_data->_M_aday7;
2910       }
2911
2912       void
2913       _M_months(const _CharT** __months) const
2914       {
2915         __months[0] = _M_data->_M_month01;
2916         __months[1] = _M_data->_M_month02;
2917         __months[2] = _M_data->_M_month03;
2918         __months[3] = _M_data->_M_month04;
2919         __months[4] = _M_data->_M_month05;
2920         __months[5] = _M_data->_M_month06;
2921         __months[6] = _M_data->_M_month07;
2922         __months[7] = _M_data->_M_month08;
2923         __months[8] = _M_data->_M_month09;
2924         __months[9] = _M_data->_M_month10;
2925         __months[10] = _M_data->_M_month11;
2926         __months[11] = _M_data->_M_month12;
2927       }
2928
2929       void
2930       _M_months_abbreviated(const _CharT** __months) const
2931       {
2932         __months[0] = _M_data->_M_amonth01;
2933         __months[1] = _M_data->_M_amonth02;
2934         __months[2] = _M_data->_M_amonth03;
2935         __months[3] = _M_data->_M_amonth04;
2936         __months[4] = _M_data->_M_amonth05;
2937         __months[5] = _M_data->_M_amonth06;
2938         __months[6] = _M_data->_M_amonth07;
2939         __months[7] = _M_data->_M_amonth08;
2940         __months[8] = _M_data->_M_amonth09;
2941         __months[9] = _M_data->_M_amonth10;
2942         __months[10] = _M_data->_M_amonth11;
2943         __months[11] = _M_data->_M_amonth12;
2944       }
2945
2946     protected:
2947       virtual
2948       ~__timepunct();
2949
2950       // For use at construction time only.
2951       void
2952       _M_initialize_timepunct(__c_locale __cloc = NULL);
2953     };
2954
2955   template<typename _CharT>
2956     locale::id __timepunct<_CharT>::id;
2957
2958   // Specializations.
2959   template<>
2960     void
2961     __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
2962
2963   template<>
2964     void
2965     __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const;
2966
2967 #ifdef _GLIBCXX_USE_WCHAR_T
2968   template<>
2969     void
2970     __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
2971
2972   template<>
2973     void
2974     __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
2975                                  const tm*) const;
2976 #endif
2977
2978   // Include host and configuration specific timepunct functions.
2979   #include <bits/time_members.h>
2980
2981   /**
2982    *  @brief  Facet for parsing dates and times.
2983    *
2984    *  This facet encapsulates the code to parse and return a date or
2985    *  time from a string.  It is used by the istream numeric
2986    *  extraction operators.
2987    *
2988    *  The time_get template uses protected virtual functions to provide the
2989    *  actual results.  The public accessors forward the call to the virtual
2990    *  functions.  These virtual functions are hooks for developers to
2991    *  implement the behavior they require from the time_get facet.
2992   */
2993   template<typename _CharT, typename _InIter>
2994     class time_get : public locale::facet, public time_base
2995     {
2996     public:
2997       // Types:
2998       //@{
2999       /// Public typedefs
3000       typedef _CharT                    char_type;
3001       typedef _InIter                   iter_type;
3002       //@}
3003       typedef basic_string<_CharT>      __string_type;
3004
3005       /// Numpunct facet id.
3006       static locale::id                 id;
3007
3008       /**
3009        *  @brief  Constructor performs initialization.
3010        *
3011        *  This is the constructor provided by the standard.
3012        *
3013        *  @param refs  Passed to the base facet class.
3014       */
3015       explicit
3016       time_get(size_t __refs = 0)
3017       : facet (__refs) { }
3018
3019       /**
3020        *  @brief  Return preferred order of month, day, and year.
3021        *
3022        *  This function returns an enum from timebase::dateorder giving the
3023        *  preferred ordering if the format "x" given to time_put::put() only
3024        *  uses month, day, and year.  If the format "x" for the associated
3025        *  locale uses other fields, this function returns
3026        *  timebase::dateorder::noorder.
3027        *
3028        *  NOTE: The library always returns noorder at the moment.
3029        *
3030        *  @return  A member of timebase::dateorder.
3031       */
3032       dateorder
3033       date_order()  const
3034       { return this->do_date_order(); }
3035
3036       /**
3037        *  @brief  Parse input time string.
3038        *
3039        *  This function parses a time according to the format "x" and puts the
3040        *  results into a user-supplied struct tm.  The result is returned by
3041        *  calling time_get::do_get_time().
3042        *
3043        *  If there is a valid time string according to format "x", @a tm will
3044        *  be filled in accordingly and the returned iterator will point to the
3045        *  first character beyond the time string.  If an error occurs before
3046        *  the end, err |= ios_base::failbit.  If parsing reads all the
3047        *  characters, err |= ios_base::eofbit.
3048        *
3049        *  @param  beg  Start of string to parse.
3050        *  @param  end  End of string to parse.
3051        *  @param  io  Source of the locale.
3052        *  @param  err  Error flags to set.
3053        *  @param  tm  Pointer to struct tm to fill in.
3054        *  @return  Iterator to first char beyond time string.
3055       */
3056       iter_type
3057       get_time(iter_type __beg, iter_type __end, ios_base& __io,
3058                ios_base::iostate& __err, tm* __tm)  const
3059       { return this->do_get_time(__beg, __end, __io, __err, __tm); }
3060
3061       /**
3062        *  @brief  Parse input date string.
3063        *
3064        *  This function parses a date according to the format "X" and puts the
3065        *  results into a user-supplied struct tm.  The result is returned by
3066        *  calling time_get::do_get_date().
3067        *
3068        *  If there is a valid date string according to format "X", @a tm will
3069        *  be filled in accordingly and the returned iterator will point to the
3070        *  first character beyond the date string.  If an error occurs before
3071        *  the end, err |= ios_base::failbit.  If parsing reads all the
3072        *  characters, err |= ios_base::eofbit.
3073        *
3074        *  @param  beg  Start of string to parse.
3075        *  @param  end  End of string to parse.
3076        *  @param  io  Source of the locale.
3077        *  @param  err  Error flags to set.
3078        *  @param  tm  Pointer to struct tm to fill in.
3079        *  @return  Iterator to first char beyond date string.
3080       */
3081       iter_type
3082       get_date(iter_type __beg, iter_type __end, ios_base& __io,
3083                ios_base::iostate& __err, tm* __tm)  const
3084       { return this->do_get_date(__beg, __end, __io, __err, __tm); }
3085
3086       /**
3087        *  @brief  Parse input weekday string.
3088        *
3089        *  This function parses a weekday name and puts the results into a
3090        *  user-supplied struct tm.  The result is returned by calling
3091        *  time_get::do_get_weekday().
3092        *
3093        *  Parsing starts by parsing an abbreviated weekday name.  If a valid
3094        *  abbreviation is followed by a character that would lead to the full
3095        *  weekday name, parsing continues until the full name is found or an
3096        *  error occurs.  Otherwise parsing finishes at the end of the
3097        *  abbreviated name.
3098        *
3099        *  If an error occurs before the end, err |= ios_base::failbit.  If
3100        *  parsing reads all the characters, err |= ios_base::eofbit.
3101        *
3102        *  @param  beg  Start of string to parse.
3103        *  @param  end  End of string to parse.
3104        *  @param  io  Source of the locale.
3105        *  @param  err  Error flags to set.
3106        *  @param  tm  Pointer to struct tm to fill in.
3107        *  @return  Iterator to first char beyond weekday name.
3108       */
3109       iter_type
3110       get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
3111                   ios_base::iostate& __err, tm* __tm) const
3112       { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
3113
3114       /**
3115        *  @brief  Parse input month string.
3116        *
3117        *  This function parses a month name and puts the results into a
3118        *  user-supplied struct tm.  The result is returned by calling
3119        *  time_get::do_get_monthname().
3120        *
3121        *  Parsing starts by parsing an abbreviated month name.  If a valid
3122        *  abbreviation is followed by a character that would lead to the full
3123        *  month name, parsing continues until the full name is found or an
3124        *  error occurs.  Otherwise parsing finishes at the end of the
3125        *  abbreviated name.
3126        *
3127        *  If an error occurs before the end, err |= ios_base::failbit.  If
3128        *  parsing reads all the characters, err |=
3129        *  ios_base::eofbit.
3130        *
3131        *  @param  beg  Start of string to parse.
3132        *  @param  end  End of string to parse.
3133        *  @param  io  Source of the locale.
3134        *  @param  err  Error flags to set.
3135        *  @param  tm  Pointer to struct tm to fill in.
3136        *  @return  Iterator to first char beyond month name.
3137       */
3138       iter_type
3139       get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
3140                     ios_base::iostate& __err, tm* __tm) const
3141       { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
3142
3143       /**
3144        *  @brief  Parse input year string.
3145        *
3146        *  This function reads up to 4 characters to parse a year string and
3147        *  puts the results into a user-supplied struct tm.  The result is
3148        *  returned by calling time_get::do_get_year().
3149        *
3150        *  4 consecutive digits are interpreted as a full year.  If there are
3151        *  exactly 2 consecutive digits, the library interprets this as the
3152        *  number of years since 1900.
3153        *
3154        *  If an error occurs before the end, err |= ios_base::failbit.  If
3155        *  parsing reads all the characters, err |= ios_base::eofbit.
3156        *
3157        *  @param  beg  Start of string to parse.
3158        *  @param  end  End of string to parse.
3159        *  @param  io  Source of the locale.
3160        *  @param  err  Error flags to set.
3161        *  @param  tm  Pointer to struct tm to fill in.
3162        *  @return  Iterator to first char beyond year.
3163       */
3164       iter_type
3165       get_year(iter_type __beg, iter_type __end, ios_base& __io,
3166                ios_base::iostate& __err, tm* __tm) const
3167       { return this->do_get_year(__beg, __end, __io, __err, __tm); }
3168
3169     protected:
3170       /// Destructor.
3171       virtual
3172       ~time_get() { }
3173
3174       /**
3175        *  @brief  Return preferred order of month, day, and year.
3176        *
3177        *  This function returns an enum from timebase::dateorder giving the
3178        *  preferred ordering if the format "x" given to time_put::put() only
3179        *  uses month, day, and year.  This function is a hook for derived
3180        *  classes to change the value returned.
3181        *
3182        *  @return  A member of timebase::dateorder.
3183       */
3184       virtual dateorder
3185       do_date_order() const;
3186
3187       /**
3188        *  @brief  Parse input time string.
3189        *
3190        *  This function parses a time according to the format "x" and puts the
3191        *  results into a user-supplied struct tm.  This function is a hook for
3192        *  derived classes to change the value returned.  @see get_time() for
3193        *  details.
3194        *
3195        *  @param  beg  Start of string to parse.
3196        *  @param  end  End of string to parse.
3197        *  @param  io  Source of the locale.
3198        *  @param  err  Error flags to set.
3199        *  @param  tm  Pointer to struct tm to fill in.
3200        *  @return  Iterator to first char beyond time string.
3201       */
3202       virtual iter_type
3203       do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
3204                   ios_base::iostate& __err, tm* __tm) const;
3205
3206       /**
3207        *  @brief  Parse input date string.
3208        *
3209        *  This function parses a date according to the format "X" and puts the
3210        *  results into a user-supplied struct tm.  This function is a hook for
3211        *  derived classes to change the value returned.  @see get_date() for
3212        *  details.
3213        *
3214        *  @param  beg  Start of string to parse.
3215        *  @param  end  End of string to parse.
3216        *  @param  io  Source of the locale.
3217        *  @param  err  Error flags to set.
3218        *  @param  tm  Pointer to struct tm to fill in.
3219        *  @return  Iterator to first char beyond date string.
3220       */
3221       virtual iter_type
3222       do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
3223                   ios_base::iostate& __err, tm* __tm) const;
3224
3225       /**
3226        *  @brief  Parse input weekday string.
3227        *
3228        *  This function parses a weekday name and puts the results into a
3229        *  user-supplied struct tm.  This function is a hook for derived
3230        *  classes to change the value returned.  @see get_weekday() for
3231        *  details.
3232        *
3233        *  @param  beg  Start of string to parse.
3234        *  @param  end  End of string to parse.
3235        *  @param  io  Source of the locale.
3236        *  @param  err  Error flags to set.
3237        *  @param  tm  Pointer to struct tm to fill in.
3238        *  @return  Iterator to first char beyond weekday name.
3239       */
3240       virtual iter_type
3241       do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
3242                      ios_base::iostate& __err, tm* __tm) const;
3243
3244       /**
3245        *  @brief  Parse input month string.
3246        *
3247        *  This function parses a month name and puts the results into a
3248        *  user-supplied struct tm.  This function is a hook for derived
3249        *  classes to change the value returned.  @see get_monthname() for
3250        *  details.
3251        *
3252        *  @param  beg  Start of string to parse.
3253        *  @param  end  End of string to parse.
3254        *  @param  io  Source of the locale.
3255        *  @param  err  Error flags to set.
3256        *  @param  tm  Pointer to struct tm to fill in.
3257        *  @return  Iterator to first char beyond month name.
3258       */
3259       virtual iter_type
3260       do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
3261                        ios_base::iostate& __err, tm* __tm) const;
3262
3263       /**
3264        *  @brief  Parse input year string.
3265        *
3266        *  This function reads up to 4 characters to parse a year string and
3267        *  puts the results into a user-supplied struct tm.  This function is a
3268        *  hook for derived classes to change the value returned.  @see
3269        *  get_year() for details.
3270        *
3271        *  @param  beg  Start of string to parse.
3272        *  @param  end  End of string to parse.
3273        *  @param  io  Source of the locale.
3274        *  @param  err  Error flags to set.
3275        *  @param  tm  Pointer to struct tm to fill in.
3276        *  @return  Iterator to first char beyond year.
3277       */
3278       virtual iter_type
3279       do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
3280                   ios_base::iostate& __err, tm* __tm) const;
3281
3282       // Extract numeric component of length __len.
3283       void
3284       _M_extract_num(iter_type& __beg, iter_type& __end, int& __member,
3285                      int __min, int __max, size_t __len,
3286                      const ctype<_CharT>& __ctype,
3287                      ios_base::iostate& __err) const;
3288
3289       // Extract day or month name, or any unique array of string
3290       // literals in a const _CharT* array.
3291       void
3292       _M_extract_name(iter_type& __beg, iter_type& __end, int& __member,
3293                       const _CharT** __names, size_t __indexlen,
3294                       const ctype<_CharT>& __ctype,
3295                       ios_base::iostate& __err) const;
3296
3297       // Extract on a component-by-component basis, via __format argument.
3298       void
3299       _M_extract_via_format(iter_type& __beg, iter_type& __end, ios_base& __io,
3300                             ios_base::iostate& __err, tm* __tm,
3301                             const _CharT* __format) const;
3302     };
3303
3304   template<typename _CharT, typename _InIter>
3305     locale::id time_get<_CharT, _InIter>::id;
3306
3307   template<typename _CharT, typename _InIter>
3308     class time_get_byname : public time_get<_CharT, _InIter>
3309     {
3310     public:
3311       // Types:
3312       typedef _CharT                    char_type;
3313       typedef _InIter                   iter_type;
3314
3315       explicit
3316       time_get_byname(const char*, size_t __refs = 0)
3317       : time_get<_CharT, _InIter>(__refs) { }
3318
3319     protected:
3320       virtual
3321       ~time_get_byname() { }
3322     };
3323
3324   /**
3325    *  @brief  Facet for outputting dates and times.
3326    *
3327    *  This facet encapsulates the code to format and output dates and times
3328    *  according to formats used by strftime().
3329    *
3330    *  The time_put template uses protected virtual functions to provide the
3331    *  actual results.  The public accessors forward the call to the virtual
3332    *  functions.  These virtual functions are hooks for developers to
3333    *  implement the behavior they require from the time_put facet.
3334   */
3335   template<typename _CharT, typename _OutIter>
3336     class time_put : public locale::facet, public time_base
3337     {
3338     public:
3339       // Types:
3340       //@{
3341       /// Public typedefs
3342       typedef _CharT                    char_type;
3343       typedef _OutIter                  iter_type;
3344       //@}
3345
3346       /// Numpunct facet id.
3347       static locale::id                 id;
3348
3349       /**
3350        *  @brief  Constructor performs initialization.
3351        *
3352        *  This is the constructor provided by the standard.
3353        *
3354        *  @param refs  Passed to the base facet class.
3355       */
3356       explicit
3357       time_put(size_t __refs = 0)
3358       : facet(__refs) { }
3359
3360       /**
3361        *  @brief  Format and output a time or date.
3362        *
3363        *  This function formats the data in struct tm according to the
3364        *  provided format string.  The format string is interpreted as by
3365        *  strftime().
3366        *
3367        *  @param  s  The stream to write to.
3368        *  @param  io  Source of locale.
3369        *  @param  fill  char_type to use for padding.
3370        *  @param  tm  Struct tm with date and time info to format.
3371        *  @param  beg  Start of format string.
3372        *  @param  end  End of format string.
3373        *  @return  Iterator after writing.
3374        */
3375       iter_type
3376       put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
3377           const _CharT* __beg, const _CharT* __end) const;
3378
3379       /**
3380        *  @brief  Format and output a time or date.
3381        *
3382        *  This function formats the data in struct tm according to the
3383        *  provided format char and optional modifier.  The format and modifier
3384        *  are interpreted as by strftime().  It does so by returning
3385        *  time_put::do_put().
3386        *
3387        *  @param  s  The stream to write to.
3388        *  @param  io  Source of locale.
3389        *  @param  fill  char_type to use for padding.
3390        *  @param  tm  Struct tm with date and time info to format.
3391        *  @param  format  Format char.
3392        *  @param  mod  Optional modifier char.
3393        *  @return  Iterator after writing.
3394        */
3395       iter_type
3396       put(iter_type __s, ios_base& __io, char_type __fill,
3397           const tm* __tm, char __format, char __mod = 0) const
3398       { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }
3399
3400     protected:
3401       /// Destructor.
3402       virtual
3403       ~time_put()
3404       { }
3405
3406       /**
3407        *  @brief  Format and output a time or date.
3408        *
3409        *  This function formats the data in struct tm according to the
3410        *  provided format char and optional modifier.  This function is a hook
3411        *  for derived classes to change the value returned.  @see put() for
3412        *  more details.
3413        *
3414        *  @param  s  The stream to write to.
3415        *  @param  io  Source of locale.
3416        *  @param  fill  char_type to use for padding.
3417        *  @param  tm  Struct tm with date and time info to format.
3418        *  @param  format  Format char.
3419        *  @param  mod  Optional modifier char.
3420        *  @return  Iterator after writing.
3421        */
3422       virtual iter_type
3423       do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
3424              char __format, char __mod) const;
3425     };
3426
3427   template<typename _CharT, typename _OutIter>
3428     locale::id time_put<_CharT, _OutIter>::id;
3429
3430   template<typename _CharT, typename _OutIter>
3431     class time_put_byname : public time_put<_CharT, _OutIter>
3432     {
3433     public:
3434       // Types:
3435       typedef _CharT                    char_type;
3436       typedef _OutIter                  iter_type;
3437
3438       explicit
3439       time_put_byname(const char*, size_t __refs = 0)
3440       : time_put<_CharT, _OutIter>(__refs)
3441       { };
3442
3443     protected:
3444       virtual
3445       ~time_put_byname() { }
3446     };
3447
3448
3449   /**
3450    *  @brief  Money format ordering data.
3451    *
3452    *  This class contains an ordered array of 4 fields to represent the
3453    *  pattern for formatting a money amount.  Each field may contain one entry
3454    *  from the part enum.  symbol, sign, and value must be present and the
3455    *  remaining field must contain either none or space.  @see
3456    *  moneypunct::pos_format() and moneypunct::neg_format() for details of how
3457    *  these fields are interpreted.
3458   */
3459   class money_base
3460   {
3461   public:
3462     enum part { none, space, symbol, sign, value };
3463     struct pattern { char field[4]; };
3464
3465     static const pattern _S_default_pattern;
3466
3467     enum
3468     {
3469       _S_minus,
3470       _S_zero,
3471       _S_end = 11
3472     };
3473
3474     // String literal of acceptable (narrow) input/output, for
3475     // money_get/money_put. "-0123456789"
3476     static const char* _S_atoms;
3477
3478     // Construct and return valid pattern consisting of some combination of:
3479     // space none symbol sign value
3480     static pattern
3481     _S_construct_pattern(char __precedes, char __space, char __posn);
3482   };
3483
3484   template<typename _CharT, bool _Intl>
3485     struct __moneypunct_cache : public locale::facet
3486     {
3487       const char*                       _M_grouping;
3488       size_t                            _M_grouping_size;
3489       bool                              _M_use_grouping;
3490       _CharT                            _M_decimal_point;
3491       _CharT                            _M_thousands_sep;
3492       const _CharT*                     _M_curr_symbol;
3493       size_t                            _M_curr_symbol_size;
3494       const _CharT*                     _M_positive_sign;
3495       size_t                            _M_positive_sign_size;
3496       const _CharT*                     _M_negative_sign;
3497       size_t                            _M_negative_sign_size;
3498       int                               _M_frac_digits;
3499       money_base::pattern               _M_pos_format;
3500       money_base::pattern               _M_neg_format;
3501
3502       // A list of valid numeric literals for input and output: in the standard
3503       // "C" locale, this is "-0123456789". This array contains the chars after
3504       // having been passed through the current locale's ctype<_CharT>.widen().
3505       _CharT                            _M_atoms[money_base::_S_end];
3506
3507       bool                              _M_allocated;
3508
3509       __moneypunct_cache(size_t __refs = 0) : facet(__refs),
3510       _M_grouping(NULL), _M_grouping_size(0), _M_use_grouping(false),
3511       _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
3512       _M_curr_symbol(NULL), _M_curr_symbol_size(0),
3513       _M_positive_sign(NULL), _M_positive_sign_size(0),
3514       _M_negative_sign(NULL), _M_negative_sign_size(0),
3515       _M_frac_digits(0),
3516       _M_pos_format(money_base::pattern()),
3517       _M_neg_format(money_base::pattern()), _M_allocated(false)
3518       { }
3519
3520       ~__moneypunct_cache();
3521
3522       void
3523       _M_cache(const locale& __loc);
3524     };
3525
3526   template<typename _CharT, bool _Intl>
3527     __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
3528     {
3529       if (_M_allocated)
3530         {
3531           delete [] _M_grouping;
3532           delete [] _M_curr_symbol;
3533           delete [] _M_positive_sign;
3534           delete [] _M_negative_sign;
3535         }
3536     }
3537
3538   template<typename _CharT, bool _Intl>
3539     void
3540     __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
3541     {
3542       _M_allocated = true;
3543
3544       const moneypunct<_CharT, _Intl>& __mp =
3545         use_facet<moneypunct<_CharT, _Intl> >(__loc);
3546
3547       _M_grouping_size = __mp.grouping().size();
3548       char* __grouping = new char[_M_grouping_size];
3549       __mp.grouping().copy(__grouping, _M_grouping_size);