OSDN Git Service

2004-03-23 Benjamin Kosnik <bkoz@redhat.com>
[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
1455        *  the simplest reasonable transformation.  If the conversion
1456        *  fails, dfault is returned instead.  For an underived
1457        *  ctype<wchar_t> facet, @a c will be cast to char and
1458        *  returned.
1459        *
1460        *  do_narrow() is a hook for a derived facet to change the
1461        *  behavior of narrowing.  do_narrow() must always return the
1462        *  same result for the same input.
1463        *
1464        *  Note: this is not what you want for codepage conversions.  See
1465        *  codecvt for that.
1466        *
1467        *  @param c  The wchar_t to convert.
1468        *  @param dfault  Char to return if conversion fails.
1469        *  @return  The converted char.
1470       */
1471       virtual char
1472       do_narrow(char_type, char __dfault) const;
1473
1474       /**
1475        *  @brief  Narrow wchar_t array to char array
1476        *
1477        *  This virtual function converts each wchar_t in the range [lo,hi) to
1478        *  char using the simplest reasonable transformation and writes the
1479        *  results to the destination array.  For any wchar_t in the input that
1480        *  cannot be converted, @a dfault is used instead.  For an underived
1481        *  ctype<wchar_t> facet, the argument will be copied, casting each
1482        *  element to char.
1483        *
1484        *  do_narrow() is a hook for a derived facet to change the behavior of
1485        *  narrowing.  do_narrow() must always return the same result for the
1486        *  same input.
1487        *
1488        *  Note: this is not what you want for codepage conversions.  See
1489        *  codecvt for that.
1490        *
1491        *  @param lo  Pointer to start of range.
1492        *  @param hi  Pointer to end of range.
1493        *  @param dfault  Char to use if conversion fails.
1494        *  @param to  Pointer to the destination array.
1495        *  @return  @a hi.
1496       */
1497       virtual const char_type*
1498       do_narrow(const char_type* __lo, const char_type* __hi,
1499                 char __dfault, char* __dest) const;
1500
1501       // For use at construction time only.
1502       void
1503       _M_initialize_ctype();
1504     };
1505
1506   template<>
1507     const ctype<wchar_t>&
1508     use_facet<ctype<wchar_t> >(const locale& __loc);
1509 #endif //_GLIBCXX_USE_WCHAR_T
1510
1511   // Include host and configuration specific ctype inlines.
1512   #include <bits/ctype_inline.h>
1513
1514   // 22.2.1.2  Template class ctype_byname
1515   template<typename _CharT>
1516     class ctype_byname : public ctype<_CharT>
1517     {
1518     public:
1519       typedef _CharT            char_type;
1520
1521       explicit
1522       ctype_byname(const char* __s, size_t __refs = 0);
1523
1524     protected:
1525       virtual
1526       ~ctype_byname() { };
1527     };
1528
1529   // 22.2.1.4  Class ctype_byname specializations.
1530   template<>
1531     ctype_byname<char>::ctype_byname(const char*, size_t refs);
1532
1533   template<>
1534     ctype_byname<wchar_t>::ctype_byname(const char*, size_t refs);
1535
1536   // 22.2.1.5  Template class codecvt
1537   #include <bits/codecvt.h>
1538
1539   // 22.2.2  The numeric category.
1540   class __num_base
1541   {
1542   public:
1543     // NB: Code depends on the order of _S_atoms_out elements.
1544     // Below are the indices into _S_atoms_out.
1545     enum
1546       {
1547         _S_ominus,
1548         _S_oplus,
1549         _S_ox,
1550         _S_oX,
1551         _S_odigits,
1552         _S_odigits_end = _S_odigits + 16,
1553         _S_oudigits = _S_odigits_end,
1554         _S_oudigits_end = _S_oudigits + 16,
1555         _S_oe = _S_odigits + 14,  // For scientific notation, 'e'
1556         _S_oE = _S_oudigits + 14, // For scientific notation, 'E'
1557         _S_oend = _S_oudigits_end
1558       };
1559
1560     // A list of valid numeric literals for output.  This array
1561     // contains chars that will be passed through the current locale's
1562     // ctype<_CharT>.widen() and then used to render numbers.
1563     // For the standard "C" locale, this is
1564     // "-+xX0123456789abcdef0123456789ABCDEF".
1565     static const char* _S_atoms_out;
1566
1567     // String literal of acceptable (narrow) input, for num_get.
1568     // "-+xX0123456789abcdefABCDEF"
1569     static const char* _S_atoms_in;
1570
1571     enum
1572     {
1573       _S_iminus,
1574       _S_iplus,
1575       _S_ix,
1576       _S_iX,
1577       _S_izero,
1578       _S_ie = _S_izero + 14,
1579       _S_iE = _S_izero + 20,
1580       _S_iend = 26
1581     };
1582
1583     // num_put
1584     // Construct and return valid scanf format for floating point types.
1585     static void
1586     _S_format_float(const ios_base& __io, char* __fptr, char __mod);
1587   };
1588
1589   template<typename _CharT>
1590     struct __numpunct_cache : public locale::facet
1591     {
1592       const char*                       _M_grouping;
1593       size_t                            _M_grouping_size;
1594       bool                              _M_use_grouping;
1595       const _CharT*                     _M_truename;
1596       size_t                            _M_truename_size;
1597       const _CharT*                     _M_falsename;
1598       size_t                            _M_falsename_size;
1599       _CharT                            _M_decimal_point;
1600       _CharT                            _M_thousands_sep;
1601
1602       // A list of valid numeric literals for output: in the standard
1603       // "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF".
1604       // This array contains the chars after having been passed
1605       // through the current locale's ctype<_CharT>.widen().
1606       _CharT                            _M_atoms_out[__num_base::_S_oend];
1607
1608       // A list of valid numeric literals for input: in the standard
1609       // "C" locale, this is "-+xX0123456789abcdefABCDEF"
1610       // This array contains the chars after having been passed
1611       // through the current locale's ctype<_CharT>.widen().
1612       _CharT                            _M_atoms_in[__num_base::_S_iend];
1613
1614       bool                              _M_allocated;
1615
1616       __numpunct_cache(size_t __refs = 0) : facet(__refs),
1617       _M_grouping(NULL), _M_grouping_size(0), _M_use_grouping(false),
1618       _M_truename(NULL), _M_truename_size(0), _M_falsename(NULL),
1619       _M_falsename_size(0), _M_decimal_point(_CharT()),
1620       _M_thousands_sep(_CharT()), _M_allocated(false)
1621       { }
1622
1623       ~__numpunct_cache();
1624
1625       void
1626       _M_cache(const locale& __loc);
1627     };
1628
1629   template<typename _CharT>
1630     __numpunct_cache<_CharT>::~__numpunct_cache()
1631     {
1632       if (_M_allocated)
1633         {
1634           delete [] _M_grouping;
1635           delete [] _M_truename;
1636           delete [] _M_falsename;
1637         }
1638     }
1639
1640   /**
1641    *  @brief  Numpunct facet.
1642    *
1643    *  This facet stores several pieces of information related to printing and
1644    *  scanning numbers, such as the decimal point character.  It takes a
1645    *  template parameter specifying the char type.  The numpunct facet is
1646    *  used by streams for many I/O operations involving numbers.
1647    *
1648    *  The numpunct template uses protected virtual functions to provide the
1649    *  actual results.  The public accessors forward the call to the virtual
1650    *  functions.  These virtual functions are hooks for developers to
1651    *  implement the behavior they require from a numpunct facet.
1652   */
1653   template<typename _CharT>
1654     class numpunct : public locale::facet
1655     {
1656     public:
1657       // Types:
1658       //@{
1659       /// Public typedefs
1660       typedef _CharT                    char_type;
1661       typedef basic_string<_CharT>      string_type;
1662       //@}
1663       typedef __numpunct_cache<_CharT>  __cache_type;
1664
1665     protected:
1666       __cache_type*                     _M_data;
1667
1668     public:
1669       /// Numpunct facet id.
1670       static locale::id                 id;
1671
1672       /**
1673        *  @brief  Numpunct constructor.
1674        *
1675        *  @param  refs  Refcount to pass to the base class.
1676        */
1677       explicit
1678       numpunct(size_t __refs = 0) : facet(__refs), _M_data(NULL)
1679       { _M_initialize_numpunct(); }
1680
1681       /**
1682        *  @brief  Internal constructor.  Not for general use.
1683        *
1684        *  This is a constructor for use by the library itself to set up the
1685        *  predefined locale facets.
1686        *
1687        *  @param  cache  __numpunct_cache object.
1688        *  @param  refs  Refcount to pass to the base class.
1689        */
1690       explicit
1691       numpunct(__cache_type* __cache, size_t __refs = 0)
1692       : facet(__refs), _M_data(__cache)
1693       { _M_initialize_numpunct(); }
1694
1695       /**
1696        *  @brief  Internal constructor.  Not for general use.
1697        *
1698        *  This is a constructor for use by the library itself to set up new
1699        *  locales.
1700        *
1701        *  @param  cloc  The "C" locale.
1702        *  @param  refs  Refcount to pass to the base class.
1703        */
1704       explicit
1705       numpunct(__c_locale __cloc, size_t __refs = 0)
1706       : facet(__refs), _M_data(NULL)
1707       { _M_initialize_numpunct(__cloc); }
1708
1709       /**
1710        *  @brief  Return decimal point character.
1711        *
1712        *  This function returns a char_type to use as a decimal point.  It
1713        *  does so by returning returning
1714        *  numpunct<char_type>::do_decimal_point().
1715        *
1716        *  @return  @a char_type representing a decimal point.
1717       */
1718       char_type
1719       decimal_point() const
1720       { return this->do_decimal_point(); }
1721
1722       /**
1723        *  @brief  Return thousands separator character.
1724        *
1725        *  This function returns a char_type to use as a thousands
1726        *  separator.  It does so by returning returning
1727        *  numpunct<char_type>::do_thousands_sep().
1728        *
1729        *  @return  char_type representing a thousands separator.
1730       */
1731       char_type
1732       thousands_sep() const
1733       { return this->do_thousands_sep(); }
1734
1735       /**
1736        *  @brief  Return grouping specification.
1737        *
1738        *  This function returns a string representing groupings for the
1739        *  integer part of a number.  Groupings indicate where thousands
1740        *  separators should be inserted in the integer part of a number.
1741        *
1742        *  Each char in the return string is interpret as an integer
1743        *  rather than a character.  These numbers represent the number
1744        *  of digits in a group.  The first char in the string
1745        *  represents the number of digits in the least significant
1746        *  group.  If a char is negative, it indicates an unlimited
1747        *  number of digits for the group.  If more chars from the
1748        *  string are required to group a number, the last char is used
1749        *  repeatedly.
1750        *
1751        *  For example, if the grouping() returns "\003\002" and is
1752        *  applied to the number 123456789, this corresponds to
1753        *  12,34,56,789.  Note that if the string was "32", this would
1754        *  put more than 50 digits into the least significant group if
1755        *  the character set is ASCII.
1756        *
1757        *  The string is returned by calling
1758        *  numpunct<char_type>::do_grouping().
1759        *
1760        *  @return  string representing grouping specification.
1761       */
1762       string
1763       grouping() const
1764       { return this->do_grouping(); }
1765
1766       /**
1767        *  @brief  Return string representation of bool true.
1768        *
1769        *  This function returns a string_type containing the text
1770        *  representation for true bool variables.  It does so by calling
1771        *  numpunct<char_type>::do_truename().
1772        *
1773        *  @return  string_type representing printed form of true.
1774       */
1775       string_type
1776       truename() const
1777       { return this->do_truename(); }
1778
1779       /**
1780        *  @brief  Return string representation of bool false.
1781        *
1782        *  This function returns a string_type containing the text
1783        *  representation for false bool variables.  It does so by calling
1784        *  numpunct<char_type>::do_falsename().
1785        *
1786        *  @return  string_type representing printed form of false.
1787       */
1788       string_type
1789       falsename() const
1790       { return this->do_falsename(); }
1791
1792     protected:
1793       /// Destructor.
1794       virtual
1795       ~numpunct();
1796
1797       /**
1798        *  @brief  Return decimal point character.
1799        *
1800        *  Returns a char_type to use as a decimal point.  This function is a
1801        *  hook for derived classes to change the value returned.
1802        *
1803        *  @return  @a char_type representing a decimal point.
1804       */
1805       virtual char_type
1806       do_decimal_point() const
1807       { return _M_data->_M_decimal_point; }
1808
1809       /**
1810        *  @brief  Return thousands separator character.
1811        *
1812        *  Returns a char_type to use as a thousands separator.  This function
1813        *  is a hook for derived classes to change the value returned.
1814        *
1815        *  @return  @a char_type representing a thousands separator.
1816       */
1817       virtual char_type
1818       do_thousands_sep() const
1819       { return _M_data->_M_thousands_sep; }
1820
1821       /**
1822        *  @brief  Return grouping specification.
1823        *
1824        *  Returns a string representing groupings for the integer part of a
1825        *  number.  This function is a hook for derived classes to change the
1826        *  value returned.  @see grouping() for details.
1827        *
1828        *  @return  String representing grouping specification.
1829       */
1830       virtual string
1831       do_grouping() const
1832       { return _M_data->_M_grouping; }
1833
1834       /**
1835        *  @brief  Return string representation of bool true.
1836        *
1837        *  Returns a string_type containing the text representation for true
1838        *  bool variables.  This function is a hook for derived classes to
1839        *  change the value returned.
1840        *
1841        *  @return  string_type representing printed form of true.
1842       */
1843       virtual string_type
1844       do_truename() const
1845       { return _M_data->_M_truename; }
1846
1847       /**
1848        *  @brief  Return string representation of bool false.
1849        *
1850        *  Returns a string_type containing the text representation for false
1851        *  bool variables.  This function is a hook for derived classes to
1852        *  change the value returned.
1853        *
1854        *  @return  string_type representing printed form of false.
1855       */
1856       virtual string_type
1857       do_falsename() const
1858       { return _M_data->_M_falsename; }
1859
1860       // For use at construction time only.
1861       void
1862       _M_initialize_numpunct(__c_locale __cloc = NULL);
1863     };
1864
1865   template<typename _CharT>
1866     locale::id numpunct<_CharT>::id;
1867
1868   template<>
1869     numpunct<char>::~numpunct();
1870
1871   template<>
1872     void
1873     numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
1874
1875 #ifdef _GLIBCXX_USE_WCHAR_T
1876   template<>
1877     numpunct<wchar_t>::~numpunct();
1878
1879   template<>
1880     void
1881     numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
1882 #endif
1883
1884   template<typename _CharT>
1885     class numpunct_byname : public numpunct<_CharT>
1886     {
1887     public:
1888       typedef _CharT                    char_type;
1889       typedef basic_string<_CharT>      string_type;
1890
1891       explicit
1892       numpunct_byname(const char* __s, size_t __refs = 0)
1893       : numpunct<_CharT>(__refs)
1894       {
1895         if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
1896           {
1897             __c_locale __tmp;
1898             this->_S_create_c_locale(__tmp, __s);
1899             this->_M_initialize_numpunct(__tmp);
1900             this->_S_destroy_c_locale(__tmp);
1901           }
1902       }
1903
1904     protected:
1905       virtual
1906       ~numpunct_byname() { }
1907     };
1908
1909   /**
1910    *  @brief  Facet for parsing number strings.
1911    *
1912    *  This facet encapsulates the code to parse and return a number
1913    *  from a string.  It is used by the istream numeric extraction
1914    *  operators.
1915    *
1916    *  The num_get template uses protected virtual functions to provide the
1917    *  actual results.  The public accessors forward the call to the virtual
1918    *  functions.  These virtual functions are hooks for developers to
1919    *  implement the behavior they require from the num_get facet.
1920   */
1921   template<typename _CharT, typename _InIter>
1922     class num_get : public locale::facet
1923     {
1924     public:
1925       // Types:
1926       //@{
1927       /// Public typedefs
1928       typedef _CharT                    char_type;
1929       typedef _InIter                   iter_type;
1930       //@}
1931
1932       /// Numpunct facet id.
1933       static locale::id                 id;
1934
1935       /**
1936        *  @brief  Constructor performs initialization.
1937        *
1938        *  This is the constructor provided by the standard.
1939        *
1940        *  @param refs  Passed to the base facet class.
1941       */
1942       explicit
1943       num_get(size_t __refs = 0) : facet(__refs) { }
1944
1945       /**
1946        *  @brief  Numeric parsing.
1947        *
1948        *  Parses the input stream into the bool @a v.  It does so by calling
1949        *  num_put::do_put().
1950        *
1951        *  If ios_base::boolalpha is set, attempts to read
1952        *  ctype<CharT>::truename() or ctype<CharT>::falsename().  Sets
1953        *  @a v to true or false if successful.  Sets err to
1954        *  ios_base::failbit if reading the string fails.  Sets err to
1955        *  ios_base::eofbit if the stream is emptied.
1956        *
1957        *  If ios_base::boolalpha is not set, proceeds as with reading a long,
1958        *  except if the value is 1, sets @a v to true, if the value is 0, sets
1959        *  @a v to false, and otherwise set err to ios_base::failbit.
1960        *
1961        *  @param  in  Start of input stream.
1962        *  @param  end  End of input stream.
1963        *  @param  io  Source of locale and flags.
1964        *  @param  err  Error flags to set.
1965        *  @param  v  Value to format and insert.
1966        *  @return  Iterator after reading.
1967       */
1968       iter_type
1969       get(iter_type __in, iter_type __end, ios_base& __io,
1970           ios_base::iostate& __err, bool& __v) const
1971       { return this->do_get(__in, __end, __io, __err, __v); }
1972
1973       //@{
1974       /**
1975        *  @brief  Numeric parsing.
1976        *
1977        *  Parses the input stream into the integral variable @a v.  It does so
1978        *  by calling num_put::do_put().
1979        *
1980        *  Parsing is affected by the flag settings in @a io.
1981        *
1982        *  The basic parse is affected by the value of io.flags() &
1983        *  ios_base::basefield.  If equal to ios_base::oct, parses like the
1984        *  scanf %o specifier.  Else if equal to ios_base::hex, parses like %X
1985        *  specifier.  Else if basefield equal to 0, parses like the %i
1986        *  specifier.  Otherwise, parses like %d for signed and %u for unsigned
1987        *  types.  The matching type length modifier is also used.
1988        *
1989        *  Digit grouping is intrepreted according to numpunct::grouping() and
1990        *  numpunct::thousands_sep().  If the pattern of digit groups isn't
1991        *  consistent, sets err to ios_base::failbit.
1992        *
1993        *  If parsing the string yields a valid value for @a v, @a v is set.
1994        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
1995        *  Sets err to ios_base::eofbit if the stream is emptied.
1996        *
1997        *  @param  in  Start of input stream.
1998        *  @param  end  End of input stream.
1999        *  @param  io  Source of locale and flags.
2000        *  @param  err  Error flags to set.
2001        *  @param  v  Value to format and insert.
2002        *  @return  Iterator after reading.
2003       */
2004       iter_type
2005       get(iter_type __in, iter_type __end, ios_base& __io,
2006           ios_base::iostate& __err, long& __v) const
2007       { return this->do_get(__in, __end, __io, __err, __v); }
2008
2009       iter_type
2010       get(iter_type __in, iter_type __end, ios_base& __io,
2011           ios_base::iostate& __err, unsigned short& __v) const
2012       { return this->do_get(__in, __end, __io, __err, __v); }
2013
2014       iter_type
2015       get(iter_type __in, iter_type __end, ios_base& __io,
2016           ios_base::iostate& __err, unsigned int& __v)   const
2017       { return this->do_get(__in, __end, __io, __err, __v); }
2018
2019       iter_type
2020       get(iter_type __in, iter_type __end, ios_base& __io,
2021           ios_base::iostate& __err, unsigned long& __v)  const
2022       { return this->do_get(__in, __end, __io, __err, __v); }
2023
2024 #ifdef _GLIBCXX_USE_LONG_LONG
2025       iter_type
2026       get(iter_type __in, iter_type __end, ios_base& __io,
2027           ios_base::iostate& __err, long long& __v) const
2028       { return this->do_get(__in, __end, __io, __err, __v); }
2029
2030       iter_type
2031       get(iter_type __in, iter_type __end, ios_base& __io,
2032           ios_base::iostate& __err, unsigned long long& __v)  const
2033       { return this->do_get(__in, __end, __io, __err, __v); }
2034 #endif
2035       //@}
2036
2037       //@{
2038       /**
2039        *  @brief  Numeric parsing.
2040        *
2041        *  Parses the input stream into the integral variable @a v.  It does so
2042        *  by calling num_put::do_put().
2043        *
2044        *  The input characters are parsed like the scanf %g specifier.  The
2045        *  matching type length modifier is also used.
2046        *
2047        *  The decimal point character used is numpunct::decimal_point().
2048        *  Digit grouping is intrepreted according to numpunct::grouping() and
2049        *  numpunct::thousands_sep().  If the pattern of digit groups isn't
2050        *  consistent, sets err to ios_base::failbit.
2051        *
2052        *  If parsing the string yields a valid value for @a v, @a v is set.
2053        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2054        *  Sets err to ios_base::eofbit if the stream is emptied.
2055        *
2056        *  @param  in  Start of input stream.
2057        *  @param  end  End of input stream.
2058        *  @param  io  Source of locale and flags.
2059        *  @param  err  Error flags to set.
2060        *  @param  v  Value to format and insert.
2061        *  @return  Iterator after reading.
2062       */
2063       iter_type
2064       get(iter_type __in, iter_type __end, ios_base& __io,
2065           ios_base::iostate& __err, float& __v) const
2066       { return this->do_get(__in, __end, __io, __err, __v); }
2067
2068       iter_type
2069       get(iter_type __in, iter_type __end, ios_base& __io,
2070           ios_base::iostate& __err, double& __v) const
2071       { return this->do_get(__in, __end, __io, __err, __v); }
2072
2073       iter_type
2074       get(iter_type __in, iter_type __end, ios_base& __io,
2075           ios_base::iostate& __err, long double& __v) const
2076       { return this->do_get(__in, __end, __io, __err, __v); }
2077       //@}
2078
2079       /**
2080        *  @brief  Numeric parsing.
2081        *
2082        *  Parses the input stream into the pointer variable @a v.  It does so
2083        *  by calling num_put::do_put().
2084        *
2085        *  The input characters are parsed like the scanf %p specifier.
2086        *
2087        *  Digit grouping is intrepreted according to numpunct::grouping() and
2088        *  numpunct::thousands_sep().  If the pattern of digit groups isn't
2089        *  consistent, sets err to ios_base::failbit.
2090        *
2091        *  Note that the digit grouping effect for pointers is a bit ambiguous
2092        *  in the standard and shouldn't be relied on.  See DR 344.
2093        *
2094        *  If parsing the string yields a valid value for @a v, @a v is set.
2095        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2096        *  Sets err to ios_base::eofbit if the stream is emptied.
2097        *
2098        *  @param  in  Start of input stream.
2099        *  @param  end  End of input stream.
2100        *  @param  io  Source of locale and flags.
2101        *  @param  err  Error flags to set.
2102        *  @param  v  Value to format and insert.
2103        *  @return  Iterator after reading.
2104       */
2105       iter_type
2106       get(iter_type __in, iter_type __end, ios_base& __io,
2107           ios_base::iostate& __err, void*& __v) const
2108       { return this->do_get(__in, __end, __io, __err, __v); }
2109
2110     protected:
2111       /// Destructor.
2112       virtual ~num_get() { }
2113
2114       iter_type
2115       _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
2116                        string& __xtrc) const;
2117
2118       template<typename _ValueT>
2119         iter_type
2120         _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
2121                        _ValueT& __v) const;
2122
2123       //@{
2124       /**
2125        *  @brief  Numeric parsing.
2126        *
2127        *  Parses the input stream into the variable @a v.  This function is a
2128        *  hook for derived classes to change the value returned.  @see get()
2129        *  for more details.
2130        *
2131        *  @param  in  Start of input stream.
2132        *  @param  end  End of input stream.
2133        *  @param  io  Source of locale and flags.
2134        *  @param  err  Error flags to set.
2135        *  @param  v  Value to format and insert.
2136        *  @return  Iterator after reading.
2137       */
2138       virtual iter_type
2139       do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
2140
2141
2142       virtual iter_type
2143       do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const;
2144
2145       virtual iter_type
2146       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2147               unsigned short&) const;
2148
2149       virtual iter_type
2150       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2151              unsigned int&) const;
2152
2153       virtual iter_type
2154       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2155              unsigned long&) const;
2156
2157 #ifdef _GLIBCXX_USE_LONG_LONG
2158       virtual iter_type
2159       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2160              long long&) const;
2161
2162       virtual iter_type
2163       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2164              unsigned long long&) const;
2165 #endif
2166
2167       virtual iter_type
2168       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2169              float&) const;
2170
2171       virtual iter_type
2172       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2173              double&) const;
2174
2175       virtual iter_type
2176       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2177              long double&) const;
2178
2179       virtual iter_type
2180       do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2181              void*&) const;
2182       //@}
2183     };
2184
2185   template<typename _CharT, typename _InIter>
2186     locale::id num_get<_CharT, _InIter>::id;
2187
2188
2189   /**
2190    *  @brief  Facet for converting numbers to strings.
2191    *
2192    *  This facet encapsulates the code to convert a number to a string.  It is
2193    *  used by the ostream numeric insertion operators.
2194    *
2195    *  The num_put template uses protected virtual functions to provide the
2196    *  actual results.  The public accessors forward the call to the virtual
2197    *  functions.  These virtual functions are hooks for developers to
2198    *  implement the behavior they require from the num_put facet.
2199   */
2200   template<typename _CharT, typename _OutIter>
2201     class num_put : public locale::facet
2202     {
2203     public:
2204       // Types:
2205       //@{
2206       /// Public typedefs
2207       typedef _CharT            char_type;
2208       typedef _OutIter          iter_type;
2209       //@}
2210
2211       /// Numpunct facet id.
2212       static locale::id         id;
2213
2214       /**
2215        *  @brief  Constructor performs initialization.
2216        *
2217        *  This is the constructor provided by the standard.
2218        *
2219        *  @param refs  Passed to the base facet class.
2220       */
2221       explicit
2222       num_put(size_t __refs = 0) : facet(__refs) { }
2223
2224       /**
2225        *  @brief  Numeric formatting.
2226        *
2227        *  Formats the boolean @a v and inserts it into a stream.  It does so
2228        *  by calling num_put::do_put().
2229        *
2230        *  If ios_base::boolalpha is set, writes ctype<CharT>::truename() or
2231        *  ctype<CharT>::falsename().  Otherwise formats @a v as an int.
2232        *
2233        *  @param  s  Stream to write to.
2234        *  @param  io  Source of locale and flags.
2235        *  @param  fill  Char_type to use for filling.
2236        *  @param  v  Value to format and insert.
2237        *  @return  Iterator after writing.
2238       */
2239       iter_type
2240       put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
2241       { return this->do_put(__s, __f, __fill, __v); }
2242
2243       //@{
2244       /**
2245        *  @brief  Numeric formatting.
2246        *
2247        *  Formats the integral value @a v and inserts it into a
2248        *  stream.  It does so by calling num_put::do_put().
2249        *
2250        *  Formatting is affected by the flag settings in @a io.
2251        *
2252        *  The basic format is affected by the value of io.flags() &
2253        *  ios_base::basefield.  If equal to ios_base::oct, formats like the
2254        *  printf %o specifier.  Else if equal to ios_base::hex, formats like
2255        *  %x or %X with ios_base::uppercase unset or set respectively.
2256        *  Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu
2257        *  for unsigned values.  Note that if both oct and hex are set, neither
2258        *  will take effect.
2259        *
2260        *  If ios_base::showpos is set, '+' is output before positive values.
2261        *  If ios_base::showbase is set, '0' precedes octal values (except 0)
2262        *  and '0[xX]' precedes hex values.
2263        *
2264        *  Thousands separators are inserted according to numpunct::grouping()
2265        *  and numpunct::thousands_sep().  The decimal point character used is
2266        *  numpunct::decimal_point().
2267        *
2268        *  If io.width() is non-zero, enough @a fill characters are inserted to
2269        *  make the result at least that wide.  If
2270        *  (io.flags() & ios_base::adjustfield) == ios_base::left, result is
2271        *  padded at the end.  If ios_base::internal, then padding occurs
2272        *  immediately after either a '+' or '-' or after '0x' or '0X'.
2273        *  Otherwise, padding occurs at the beginning.
2274        *
2275        *  @param  s  Stream to write to.
2276        *  @param  io  Source of locale and flags.
2277        *  @param  fill  Char_type to use for filling.
2278        *  @param  v  Value to format and insert.
2279        *  @return  Iterator after writing.
2280       */
2281       iter_type
2282       put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
2283       { return this->do_put(__s, __f, __fill, __v); }
2284
2285       iter_type
2286       put(iter_type __s, ios_base& __f, char_type __fill,
2287           unsigned long __v) const
2288       { return this->do_put(__s, __f, __fill, __v); }
2289
2290 #ifdef _GLIBCXX_USE_LONG_LONG
2291       iter_type
2292       put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
2293       { return this->do_put(__s, __f, __fill, __v); }
2294
2295       iter_type
2296       put(iter_type __s, ios_base& __f, char_type __fill,
2297           unsigned long long __v) const
2298       { return this->do_put(__s, __f, __fill, __v); }
2299 #endif
2300       //@}
2301
2302       //@{
2303       /**
2304        *  @brief  Numeric formatting.
2305        *
2306        *  Formats the floating point value @a v and inserts it into a stream.
2307        *  It does so by calling num_put::do_put().
2308        *
2309        *  Formatting is affected by the flag settings in @a io.
2310        *
2311        *  The basic format is affected by the value of io.flags() &
2312        *  ios_base::floatfield.  If equal to ios_base::fixed, formats like the
2313        *  printf %f specifier.  Else if equal to ios_base::scientific, formats
2314        *  like %e or %E with ios_base::uppercase unset or set respectively.
2315        *  Otherwise, formats like %g or %G depending on uppercase.  Note that
2316        *  if both fixed and scientific are set, the effect will also be like
2317        *  %g or %G.
2318        *
2319        *  The output precision is given by io.precision().  This precision is
2320        *  capped at numeric_limits::digits10 + 2 (different for double and
2321        *  long double).  The default precision is 6.
2322        *
2323        *  If ios_base::showpos is set, '+' is output before positive values.
2324        *  If ios_base::showpoint is set, a decimal point will always be
2325        *  output.
2326        *
2327        *  Thousands separators are inserted according to numpunct::grouping()
2328        *  and numpunct::thousands_sep().  The decimal point character used is
2329        *  numpunct::decimal_point().
2330        *
2331        *  If io.width() is non-zero, enough @a fill characters are inserted to
2332        *  make the result at least that wide.  If
2333        *  (io.flags() & ios_base::adjustfield) == ios_base::left, result is
2334        *  padded at the end.  If ios_base::internal, then padding occurs
2335        *  immediately after either a '+' or '-' or after '0x' or '0X'.
2336        *  Otherwise, padding occurs at the beginning.
2337        *
2338        *  @param  s  Stream to write to.
2339        *  @param  io  Source of locale and flags.
2340        *  @param  fill  Char_type to use for filling.
2341        *  @param  v  Value to format and insert.
2342        *  @return  Iterator after writing.
2343       */
2344       iter_type
2345       put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
2346       { return this->do_put(__s, __f, __fill, __v); }
2347
2348       iter_type
2349       put(iter_type __s, ios_base& __f, char_type __fill,
2350           long double __v) const
2351       { return this->do_put(__s, __f, __fill, __v); }
2352       //@}
2353
2354       /**
2355        *  @brief  Numeric formatting.
2356        *
2357        *  Formats the pointer value @a v and inserts it into a stream.  It
2358        *  does so by calling num_put::do_put().
2359        *
2360        *  This function formats @a v as an unsigned long with ios_base::hex
2361        *  and ios_base::showbase set.
2362        *
2363        *  @param  s  Stream to write to.
2364        *  @param  io  Source of locale and flags.
2365        *  @param  fill  Char_type to use for filling.
2366        *  @param  v  Value to format and insert.
2367        *  @return  Iterator after writing.
2368       */
2369       iter_type
2370       put(iter_type __s, ios_base& __f, char_type __fill,
2371           const void* __v) const
2372       { return this->do_put(__s, __f, __fill, __v); }
2373
2374     protected:
2375       template<typename _ValueT>
2376         iter_type
2377         _M_insert_float(iter_type, ios_base& __io, char_type __fill,
2378                         char __mod, _ValueT __v) const;
2379
2380       void
2381       _M_group_float(const char* __grouping, size_t __grouping_size,
2382                      char_type __sep, const char_type* __p, char_type* __new,
2383                      char_type* __cs, int& __len) const;
2384
2385       template<typename _ValueT>
2386         iter_type
2387         _M_insert_int(iter_type, ios_base& __io, char_type __fill,
2388                       _ValueT __v) const;
2389
2390       void
2391       _M_group_int(const char* __grouping, size_t __grouping_size,
2392                    char_type __sep, ios_base& __io, char_type* __new,
2393                    char_type* __cs, int& __len) const;
2394
2395       void
2396       _M_pad(char_type __fill, streamsize __w, ios_base& __io,
2397              char_type* __new, const char_type* __cs, int& __len) const;
2398
2399       /// Destructor.
2400       virtual
2401       ~num_put() { };
2402
2403       //@{
2404       /**
2405        *  @brief  Numeric formatting.
2406        *
2407        *  These functions do the work of formatting numeric values and
2408        *  inserting them into a stream. This function is a hook for derived
2409        *  classes to change the value returned.
2410        *
2411        *  @param  s  Stream to write to.
2412        *  @param  io  Source of locale and flags.
2413        *  @param  fill  Char_type to use for filling.
2414        *  @param  v  Value to format and insert.
2415        *  @return  Iterator after writing.
2416       */
2417       virtual iter_type
2418       do_put(iter_type, ios_base&, char_type __fill, bool __v) const;
2419
2420       virtual iter_type
2421       do_put(iter_type, ios_base&, char_type __fill, long __v) const;
2422
2423       virtual iter_type
2424       do_put(iter_type, ios_base&, char_type __fill, unsigned long) const;
2425
2426 #ifdef _GLIBCXX_USE_LONG_LONG
2427       virtual iter_type
2428       do_put(iter_type, ios_base&, char_type __fill, long long __v) const;
2429
2430       virtual iter_type
2431       do_put(iter_type, ios_base&, char_type __fill, unsigned long long) const;
2432 #endif
2433
2434       virtual iter_type
2435       do_put(iter_type, ios_base&, char_type __fill, double __v) const;
2436
2437       virtual iter_type
2438       do_put(iter_type, ios_base&, char_type __fill, long double __v) const;
2439
2440       virtual iter_type
2441       do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
2442       //@}
2443     };
2444
2445   template <typename _CharT, typename _OutIter>
2446     locale::id num_put<_CharT, _OutIter>::id;
2447
2448
2449   /**
2450    *  @brief  Facet for localized string comparison.
2451    *
2452    *  This facet encapsulates the code to compare strings in a localized
2453    *  manner.
2454    *
2455    *  The collate template uses protected virtual functions to provide
2456    *  the actual results.  The public accessors forward the call to
2457    *  the virtual functions.  These virtual functions are hooks for
2458    *  developers to implement the behavior they require from the
2459    *  collate facet.
2460   */
2461   template<typename _CharT>
2462     class collate : public locale::facet
2463     {
2464     public:
2465       // Types:
2466       //@{
2467       /// Public typedefs
2468       typedef _CharT                    char_type;
2469       typedef basic_string<_CharT>      string_type;
2470       //@}
2471
2472     protected:
2473       // Underlying "C" library locale information saved from
2474       // initialization, needed by collate_byname as well.
2475       __c_locale                        _M_c_locale_collate;
2476
2477     public:
2478       /// Numpunct facet id.
2479       static locale::id                 id;
2480
2481       /**
2482        *  @brief  Constructor performs initialization.
2483        *
2484        *  This is the constructor provided by the standard.
2485        *
2486        *  @param refs  Passed to the base facet class.
2487       */
2488       explicit
2489       collate(size_t __refs = 0)
2490       : facet(__refs)
2491       { _M_c_locale_collate = _S_get_c_locale(); }
2492
2493       /**
2494        *  @brief  Internal constructor. Not for general use.
2495        *
2496        *  This is a constructor for use by the library itself to set up new
2497        *  locales.
2498        *
2499        *  @param cloc  The "C" locale.
2500        *  @param refs  Passed to the base facet class.
2501       */
2502       explicit
2503       collate(__c_locale __cloc, size_t __refs = 0)
2504       : facet(__refs)
2505       { _M_c_locale_collate = _S_clone_c_locale(__cloc); }
2506
2507       /**
2508        *  @brief  Compare two strings.
2509        *
2510        *  This function compares two strings and returns the result by calling
2511        *  collate::do_compare().
2512        *
2513        *  @param lo1  Start of string 1.
2514        *  @param hi1  End of string 1.
2515        *  @param lo2  Start of string 2.
2516        *  @param hi2  End of string 2.
2517        *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
2518       */
2519       int
2520       compare(const _CharT* __lo1, const _CharT* __hi1,
2521               const _CharT* __lo2, const _CharT* __hi2) const
2522       { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
2523
2524       /**
2525        *  @brief  Transform string to comparable form.
2526        *
2527        *  This function is a wrapper for strxfrm functionality.  It takes the
2528        *  input string and returns a modified string that can be directly
2529        *  compared to other transformed strings.  In the "C" locale, this
2530        *  function just returns a copy of the input string.  In some other
2531        *  locales, it may replace two chars with one, change a char for
2532        *  another, etc.  It does so by returning collate::do_transform().
2533        *
2534        *  @param lo  Start of string.
2535        *  @param hi  End of string.
2536        *  @return  Transformed string_type.
2537       */
2538       string_type
2539       transform(const _CharT* __lo, const _CharT* __hi) const
2540       { return this->do_transform(__lo, __hi); }
2541
2542       /**
2543        *  @brief  Return hash of a string.
2544        *
2545        *  This function computes and returns a hash on the input string.  It
2546        *  does so by returning collate::do_hash().
2547        *
2548        *  @param lo  Start of string.
2549        *  @param hi  End of string.
2550        *  @return  Hash value.
2551       */
2552       long
2553       hash(const _CharT* __lo, const _CharT* __hi) const
2554       { return this->do_hash(__lo, __hi); }
2555
2556       // Used to abstract out _CharT bits in virtual member functions, below.
2557       int
2558       _M_compare(const _CharT*, const _CharT*) const;
2559
2560       size_t
2561       _M_transform(_CharT*, const _CharT*, size_t) const;
2562
2563   protected:
2564       /// Destructor.
2565       virtual
2566       ~collate()
2567       { _S_destroy_c_locale(_M_c_locale_collate); }
2568
2569       /**
2570        *  @brief  Compare two strings.
2571        *
2572        *  This function is a hook for derived classes to change the value
2573        *  returned.  @see compare().
2574        *
2575        *  @param lo1  Start of string 1.
2576        *  @param hi1  End of string 1.
2577        *  @param lo2  Start of string 2.
2578        *  @param hi2  End of string 2.
2579        *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
2580       */
2581       virtual int
2582       do_compare(const _CharT* __lo1, const _CharT* __hi1,
2583                  const _CharT* __lo2, const _CharT* __hi2) const;
2584
2585       /**
2586        *  @brief  Transform string to comparable form.
2587        *
2588        *  This function is a hook for derived classes to change the value
2589        *  returned.
2590        *
2591        *  @param lo1  Start of string 1.
2592        *  @param hi1  End of string 1.
2593        *  @param lo2  Start of string 2.
2594        *  @param hi2  End of string 2.
2595        *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
2596       */
2597       virtual string_type
2598       do_transform(const _CharT* __lo, const _CharT* __hi) const;
2599
2600       /**
2601        *  @brief  Return hash of a string.
2602        *
2603        *  This function computes and returns a hash on the input string.  This
2604        *  function is a hook for derived classes to change the value returned.
2605        *
2606        *  @param lo  Start of string.
2607        *  @param hi  End of string.
2608        *  @return  Hash value.
2609       */
2610       virtual long
2611       do_hash(const _CharT* __lo, const _CharT* __hi) const;
2612     };
2613
2614   template<typename _CharT>
2615     locale::id collate<_CharT>::id;
2616
2617   // Specializations.
2618   template<>
2619     int
2620     collate<char>::_M_compare(const char*, const char*) const;
2621
2622   template<>
2623     size_t
2624     collate<char>::_M_transform(char*, const char*, size_t) const;
2625
2626 #ifdef _GLIBCXX_USE_WCHAR_T
2627   template<>
2628     int
2629     collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const;
2630
2631   template<>
2632     size_t
2633     collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const;
2634 #endif
2635
2636   template<typename _CharT>
2637     class collate_byname : public collate<_CharT>
2638     {
2639     public:
2640       //@{
2641       /// Public typedefs
2642       typedef _CharT               char_type;
2643       typedef basic_string<_CharT> string_type;
2644       //@}
2645
2646       explicit
2647       collate_byname(const char* __s, size_t __refs = 0)
2648       : collate<_CharT>(__refs)
2649       {
2650         if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
2651           {
2652             this->_S_destroy_c_locale(this->_M_c_locale_collate);
2653             this->_S_create_c_locale(this->_M_c_locale_collate, __s);
2654           }
2655       }
2656
2657     protected:
2658       virtual
2659       ~collate_byname() { }
2660     };
2661
2662
2663   /**
2664    *  @brief  Time format ordering data.
2665    *
2666    *  This class provides an enum representing different orderings of day,
2667    *  month, and year.
2668   */
2669   class time_base
2670   {
2671   public:
2672     enum dateorder { no_order, dmy, mdy, ymd, ydm };
2673   };
2674
2675   template<typename _CharT>
2676     struct __timepunct_cache : public locale::facet
2677     {
2678       // List of all known timezones, with GMT first.
2679       static const _CharT*              _S_timezones[14];
2680
2681       const _CharT*                     _M_date_format;
2682       const _CharT*                     _M_date_era_format;
2683       const _CharT*                     _M_time_format;
2684       const _CharT*                     _M_time_era_format;
2685       const _CharT*                     _M_date_time_format;
2686       const _CharT*                     _M_date_time_era_format;
2687       const _CharT*                     _M_am;
2688       const _CharT*                     _M_pm;
2689       const _CharT*                     _M_am_pm_format;
2690
2691       // Day names, starting with "C"'s Sunday.
2692       const _CharT*                     _M_day1;
2693       const _CharT*                     _M_day2;
2694       const _CharT*                     _M_day3;
2695       const _CharT*                     _M_day4;
2696       const _CharT*                     _M_day5;
2697       const _CharT*                     _M_day6;
2698       const _CharT*                     _M_day7;
2699
2700       // Abbreviated day names, starting with "C"'s Sun.
2701       const _CharT*                     _M_aday1;
2702       const _CharT*                     _M_aday2;
2703       const _CharT*                     _M_aday3;
2704       const _CharT*                     _M_aday4;
2705       const _CharT*                     _M_aday5;
2706       const _CharT*                     _M_aday6;
2707       const _CharT*                     _M_aday7;
2708
2709       // Month names, starting with "C"'s January.
2710       const _CharT*                     _M_month01;
2711       const _CharT*                     _M_month02;
2712       const _CharT*                     _M_month03;
2713       const _CharT*                     _M_month04;
2714       const _CharT*                     _M_month05;
2715       const _CharT*                     _M_month06;
2716       const _CharT*                     _M_month07;
2717       const _CharT*                     _M_month08;
2718       const _CharT*                     _M_month09;
2719       const _CharT*                     _M_month10;
2720       const _CharT*                     _M_month11;
2721       const _CharT*                     _M_month12;
2722
2723       // Abbreviated month names, starting with "C"'s Jan.
2724       const _CharT*                     _M_amonth01;
2725       const _CharT*                     _M_amonth02;
2726       const _CharT*                     _M_amonth03;
2727       const _CharT*                     _M_amonth04;
2728       const _CharT*                     _M_amonth05;
2729       const _CharT*                     _M_amonth06;
2730       const _CharT*                     _M_amonth07;
2731       const _CharT*                     _M_amonth08;
2732       const _CharT*                     _M_amonth09;
2733       const _CharT*                     _M_amonth10;
2734       const _CharT*                     _M_amonth11;
2735       const _CharT*                     _M_amonth12;
2736
2737       bool                              _M_allocated;
2738
2739       __timepunct_cache(size_t __refs = 0) : facet(__refs),
2740       _M_date_format(NULL), _M_date_era_format(NULL), _M_time_format(NULL),
2741       _M_time_era_format(NULL), _M_date_time_format(NULL),
2742       _M_date_time_era_format(NULL), _M_am(NULL), _M_pm(NULL),
2743       _M_am_pm_format(NULL), _M_day1(NULL), _M_day2(NULL), _M_day3(NULL),
2744       _M_day4(NULL), _M_day5(NULL), _M_day6(NULL), _M_day7(NULL),
2745       _M_aday1(NULL), _M_aday2(NULL), _M_aday3(NULL), _M_aday4(NULL),
2746       _M_aday5(NULL), _M_aday6(NULL), _M_aday7(NULL), _M_month01(NULL),
2747       _M_month02(NULL), _M_month03(NULL), _M_month04(NULL), _M_month05(NULL),
2748       _M_month06(NULL), _M_month07(NULL), _M_month08(NULL), _M_month09(NULL),
2749       _M_month10(NULL), _M_month11(NULL), _M_month12(NULL), _M_amonth01(NULL),
2750       _M_amonth02(NULL), _M_amonth03(NULL), _M_amonth04(NULL),
2751       _M_amonth05(NULL), _M_amonth06(NULL), _M_amonth07(NULL),
2752       _M_amonth08(NULL), _M_amonth09(NULL), _M_amonth10(NULL),
2753       _M_amonth11(NULL), _M_amonth12(NULL), _M_allocated(false)
2754       { }
2755
2756       ~__timepunct_cache();
2757
2758       void
2759       _M_cache(const locale& __loc);
2760     };
2761
2762   template<typename _CharT>
2763     __timepunct_cache<_CharT>::~__timepunct_cache()
2764     {
2765       if (_M_allocated)
2766         {
2767           // Unused.
2768         }
2769     }
2770
2771   // Specializations.
2772   template<>
2773     const char*
2774     __timepunct_cache<char>::_S_timezones[14];
2775
2776 #ifdef _GLIBCXX_USE_WCHAR_T
2777   template<>
2778     const wchar_t*
2779     __timepunct_cache<wchar_t>::_S_timezones[14];
2780 #endif
2781
2782   // Generic.
2783   template<typename _CharT>
2784     const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
2785
2786   template<typename _CharT>
2787     class __timepunct : public locale::facet
2788     {
2789     public:
2790       // Types:
2791       typedef _CharT                    __char_type;
2792       typedef basic_string<_CharT>      __string_type;
2793       typedef __timepunct_cache<_CharT> __cache_type;
2794
2795     protected:
2796       __cache_type*                     _M_data;
2797       __c_locale                        _M_c_locale_timepunct;
2798       const char*                       _M_name_timepunct;
2799
2800     public:
2801       /// Numpunct facet id.
2802       static locale::id                 id;
2803
2804       explicit
2805       __timepunct(size_t __refs = 0);
2806
2807       explicit
2808       __timepunct(__cache_type* __cache, size_t __refs = 0);
2809
2810       /**
2811        *  @brief  Internal constructor. Not for general use.
2812        *
2813        *  This is a constructor for use by the library itself to set up new
2814        *  locales.
2815        *
2816        *  @param cloc  The "C" locale.
2817        *  @param s  The name of a locale.
2818        *  @param refs  Passed to the base facet class.
2819       */
2820       explicit
2821       __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);
2822
2823       void
2824       _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
2825              const tm* __tm) const;
2826
2827       void
2828       _M_date_formats(const _CharT** __date) const
2829       {
2830         // Always have default first.
2831         __date[0] = _M_data->_M_date_format;
2832         __date[1] = _M_data->_M_date_era_format;
2833       }
2834
2835       void
2836       _M_time_formats(const _CharT** __time) const
2837       {
2838         // Always have default first.
2839         __time[0] = _M_data->_M_time_format;
2840         __time[1] = _M_data->_M_time_era_format;
2841       }
2842
2843       void
2844       _M_date_time_formats(const _CharT** __dt) const
2845       {
2846         // Always have default first.
2847         __dt[0] = _M_data->_M_date_time_format;
2848         __dt[1] = _M_data->_M_date_time_era_format;
2849       }
2850
2851       void
2852       _M_am_pm_format(const _CharT* __ampm) const
2853       { __ampm = _M_data->_M_am_pm_format; }
2854
2855       void
2856       _M_am_pm(const _CharT** __ampm) const
2857       {
2858         __ampm[0] = _M_data->_M_am;
2859         __ampm[1] = _M_data->_M_pm;
2860       }
2861
2862       void
2863       _M_days(const _CharT** __days) const
2864       {
2865         __days[0] = _M_data->_M_day1;
2866         __days[1] = _M_data->_M_day2;
2867         __days[2] = _M_data->_M_day3;
2868         __days[3] = _M_data->_M_day4;
2869         __days[4] = _M_data->_M_day5;
2870         __days[5] = _M_data->_M_day6;
2871         __days[6] = _M_data->_M_day7;
2872       }
2873
2874       void
2875       _M_days_abbreviated(const _CharT** __days) const
2876       {
2877         __days[0] = _M_data->_M_aday1;
2878         __days[1] = _M_data->_M_aday2;
2879         __days[2] = _M_data->_M_aday3;
2880         __days[3] = _M_data->_M_aday4;
2881         __days[4] = _M_data->_M_aday5;
2882         __days[5] = _M_data->_M_aday6;
2883         __days[6] = _M_data->_M_aday7;
2884       }
2885
2886       void
2887       _M_months(const _CharT** __months) const
2888       {
2889         __months[0] = _M_data->_M_month01;
2890         __months[1] = _M_data->_M_month02;
2891         __months[2] = _M_data->_M_month03;
2892         __months[3] = _M_data->_M_month04;
2893         __months[4] = _M_data->_M_month05;
2894         __months[5] = _M_data->_M_month06;
2895         __months[6] = _M_data->_M_month07;
2896         __months[7] = _M_data->_M_month08;
2897         __months[8] = _M_data->_M_month09;
2898         __months[9] = _M_data->_M_month10;
2899         __months[10] = _M_data->_M_month11;
2900         __months[11] = _M_data->_M_month12;
2901       }
2902
2903       void
2904       _M_months_abbreviated(const _CharT** __months) const
2905       {
2906         __months[0] = _M_data->_M_amonth01;
2907         __months[1] = _M_data->_M_amonth02;
2908         __months[2] = _M_data->_M_amonth03;
2909         __months[3] = _M_data->_M_amonth04;
2910         __months[4] = _M_data->_M_amonth05;
2911         __months[5] = _M_data->_M_amonth06;
2912         __months[6] = _M_data->_M_amonth07;
2913         __months[7] = _M_data->_M_amonth08;
2914         __months[8] = _M_data->_M_amonth09;
2915         __months[9] = _M_data->_M_amonth10;
2916         __months[10] = _M_data->_M_amonth11;
2917         __months[11] = _M_data->_M_amonth12;
2918       }
2919
2920     protected:
2921       virtual
2922       ~__timepunct();
2923
2924       // For use at construction time only.
2925       void
2926       _M_initialize_timepunct(__c_locale __cloc = NULL);
2927     };
2928
2929   template<typename _CharT>
2930     locale::id __timepunct<_CharT>::id;
2931
2932   // Specializations.
2933   template<>
2934     void
2935     __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
2936
2937   template<>
2938     void
2939     __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const;
2940
2941 #ifdef _GLIBCXX_USE_WCHAR_T
2942   template<>
2943     void
2944     __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
2945
2946   template<>
2947     void
2948     __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
2949                                  const tm*) const;
2950 #endif
2951
2952   // Include host and configuration specific timepunct functions.
2953   #include <bits/time_members.h>
2954
2955   /**
2956    *  @brief  Facet for parsing dates and times.
2957    *
2958    *  This facet encapsulates the code to parse and return a date or
2959    *  time from a string.  It is used by the istream numeric
2960    *  extraction operators.
2961    *
2962    *  The time_get template uses protected virtual functions to provide the
2963    *  actual results.  The public accessors forward the call to the virtual
2964    *  functions.  These virtual functions are hooks for developers to
2965    *  implement the behavior they require from the time_get facet.
2966   */
2967   template<typename _CharT, typename _InIter>
2968     class time_get : public locale::facet, public time_base
2969     {
2970     public:
2971       // Types:
2972       //@{
2973       /// Public typedefs
2974       typedef _CharT                    char_type;
2975       typedef _InIter                   iter_type;
2976       //@}
2977       typedef basic_string<_CharT>      __string_type;
2978
2979       /// Numpunct facet id.
2980       static locale::id                 id;
2981
2982       /**
2983        *  @brief  Constructor performs initialization.
2984        *
2985        *  This is the constructor provided by the standard.
2986        *
2987        *  @param refs  Passed to the base facet class.
2988       */
2989       explicit
2990       time_get(size_t __refs = 0)
2991       : facet (__refs) { }
2992
2993       /**
2994        *  @brief  Return preferred order of month, day, and year.
2995        *
2996        *  This function returns an enum from timebase::dateorder giving the
2997        *  preferred ordering if the format "x" given to time_put::put() only
2998        *  uses month, day, and year.  If the format "x" for the associated
2999        *  locale uses other fields, this function returns
3000        *  timebase::dateorder::noorder.
3001        *
3002        *  NOTE: The library always returns noorder at the moment.
3003        *
3004        *  @return  A member of timebase::dateorder.
3005       */
3006       dateorder
3007       date_order()  const
3008       { return this->do_date_order(); }
3009
3010       /**
3011        *  @brief  Parse input time string.
3012        *
3013        *  This function parses a time according to the format "x" and puts the
3014        *  results into a user-supplied struct tm.  The result is returned by
3015        *  calling time_get::do_get_time().
3016        *
3017        *  If there is a valid time string according to format "x", @a tm will
3018        *  be filled in accordingly and the returned iterator will point to the
3019        *  first character beyond the time string.  If an error occurs before
3020        *  the end, err |= ios_base::failbit.  If parsing reads all the
3021        *  characters, err |= ios_base::eofbit.
3022        *
3023        *  @param  beg  Start of string to parse.
3024        *  @param  end  End of string to parse.
3025        *  @param  io  Source of the locale.
3026        *  @param  err  Error flags to set.
3027        *  @param  tm  Pointer to struct tm to fill in.
3028        *  @return  Iterator to first char beyond time string.
3029       */
3030       iter_type
3031       get_time(iter_type __beg, iter_type __end, ios_base& __io,
3032                ios_base::iostate& __err, tm* __tm)  const
3033       { return this->do_get_time(__beg, __end, __io, __err, __tm); }
3034
3035       /**
3036        *  @brief  Parse input date string.
3037        *
3038        *  This function parses a date according to the format "X" and puts the
3039        *  results into a user-supplied struct tm.  The result is returned by
3040        *  calling time_get::do_get_date().
3041        *
3042        *  If there is a valid date string according to format "X", @a tm will
3043        *  be filled in accordingly and the returned iterator will point to the
3044        *  first character beyond the date string.  If an error occurs before
3045        *  the end, err |= ios_base::failbit.  If parsing reads all the
3046        *  characters, err |= ios_base::eofbit.
3047        *
3048        *  @param  beg  Start of string to parse.
3049        *  @param  end  End of string to parse.
3050        *  @param  io  Source of the locale.
3051        *  @param  err  Error flags to set.
3052        *  @param  tm  Pointer to struct tm to fill in.
3053        *  @return  Iterator to first char beyond date string.
3054       */
3055       iter_type
3056       get_date(iter_type __beg, iter_type __end, ios_base& __io,
3057                ios_base::iostate& __err, tm* __tm)  const
3058       { return this->do_get_date(__beg, __end, __io, __err, __tm); }
3059
3060       /**
3061        *  @brief  Parse input weekday string.
3062        *
3063        *  This function parses a weekday name and puts the results into a
3064        *  user-supplied struct tm.  The result is returned by calling
3065        *  time_get::do_get_weekday().
3066        *
3067        *  Parsing starts by parsing an abbreviated weekday name.  If a valid
3068        *  abbreviation is followed by a character that would lead to the full
3069        *  weekday name, parsing continues until the full name is found or an
3070        *  error occurs.  Otherwise parsing finishes at the end of the
3071        *  abbreviated name.
3072        *
3073        *  If an error occurs before the end, err |= ios_base::failbit.  If
3074        *  parsing reads all the characters, err |= ios_base::eofbit.
3075        *
3076        *  @param  beg  Start of string to parse.
3077        *  @param  end  End of string to parse.
3078        *  @param  io  Source of the locale.
3079        *  @param  err  Error flags to set.
3080        *  @param  tm  Pointer to struct tm to fill in.
3081        *  @return  Iterator to first char beyond weekday name.
3082       */
3083       iter_type
3084       get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
3085                   ios_base::iostate& __err, tm* __tm) const
3086       { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
3087
3088       /**
3089        *  @brief  Parse input month string.
3090        *
3091        *  This function parses a month name and puts the results into a
30