OSDN Git Service

2004-11-18 Paolo Carlini <pcarlini@suse.de>
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / bits / locale_facets.tcc
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 // Warning: this file is not meant for user inclusion. Use <locale>.
32
33 #ifndef _LOCALE_FACETS_TCC
34 #define _LOCALE_FACETS_TCC 1
35
36 #pragma GCC system_header
37
38 #include <limits>               // For numeric_limits
39 #include <typeinfo>             // For bad_cast.
40 #include <bits/streambuf_iterator.h>
41
42 namespace std
43 {
44   template<typename _Facet>
45     locale
46     locale::combine(const locale& __other) const
47     {
48       _Impl* __tmp = new _Impl(*_M_impl, 1);
49       try
50         {
51           __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
52         }
53       catch(...)
54         {
55           __tmp->_M_remove_reference();
56           __throw_exception_again;
57         }
58       return locale(__tmp);
59     }
60
61   template<typename _CharT, typename _Traits, typename _Alloc>
62     bool
63     locale::operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
64                        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
65     {
66       typedef std::collate<_CharT> __collate_type;
67       const __collate_type& __collate = use_facet<__collate_type>(*this);
68       return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
69                                 __s2.data(), __s2.data() + __s2.length()) < 0);
70     }
71
72   /**
73    *  @brief  Test for the presence of a facet.
74    *
75    *  has_facet tests the locale argument for the presence of the facet type
76    *  provided as the template parameter.  Facets derived from the facet
77    *  parameter will also return true.
78    *
79    *  @param  Facet  The facet type to test the presence of.
80    *  @param  locale  The locale to test.
81    *  @return  true if locale contains a facet of type Facet, else false.
82   */
83   template<typename _Facet>
84     inline bool
85     has_facet(const locale& __loc) throw()
86     {
87       const size_t __i = _Facet::id._M_id();
88       const locale::facet** __facets = __loc._M_impl->_M_facets;
89       return (__i < __loc._M_impl->_M_facets_size && __facets[__i]);
90     }
91
92   /**
93    *  @brief  Return a facet.
94    *
95    *  use_facet looks for and returns a reference to a facet of type Facet
96    *  where Facet is the template parameter.  If has_facet(locale) is true,
97    *  there is a suitable facet to return.  It throws std::bad_cast if the
98    *  locale doesn't contain a facet of type Facet.
99    *
100    *  @param  Facet  The facet type to access.
101    *  @param  locale  The locale to use.
102    *  @return  Reference to facet of type Facet.
103    *  @throw  std::bad_cast if locale doesn't contain a facet of type Facet.
104   */
105   template<typename _Facet>
106     inline const _Facet&
107     use_facet(const locale& __loc)
108     {
109       const size_t __i = _Facet::id._M_id();
110       const locale::facet** __facets = __loc._M_impl->_M_facets;
111       if (!(__i < __loc._M_impl->_M_facets_size && __facets[__i]))
112         __throw_bad_cast();
113       return static_cast<const _Facet&>(*__facets[__i]);
114     }
115
116   // Routine to access a cache for the facet.  If the cache didn't
117   // exist before, it gets constructed on the fly.
118   template<typename _Facet>
119     struct __use_cache
120     {
121       const _Facet*
122       operator() (const locale& __loc) const;
123     };
124
125   // Specializations.
126   template<typename _CharT>
127     struct __use_cache<__numpunct_cache<_CharT> >
128     {
129       const __numpunct_cache<_CharT>*
130       operator() (const locale& __loc) const
131       {
132         const size_t __i = numpunct<_CharT>::id._M_id();
133         const locale::facet** __caches = __loc._M_impl->_M_caches;
134         if (!__caches[__i])
135           {
136             __numpunct_cache<_CharT>* __tmp = NULL;
137             try
138               {
139                 __tmp = new __numpunct_cache<_CharT>;
140                 __tmp->_M_cache(__loc);
141               }
142             catch(...)
143               {
144                 delete __tmp;
145                 __throw_exception_again;
146               }
147             __loc._M_impl->_M_install_cache(__tmp, __i);
148           }
149         return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
150       }
151     };
152
153   template<typename _CharT, bool _Intl>
154     struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
155     {
156       const __moneypunct_cache<_CharT, _Intl>*
157       operator() (const locale& __loc) const
158       {
159         const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
160         const locale::facet** __caches = __loc._M_impl->_M_caches;
161         if (!__caches[__i])
162           {
163             __moneypunct_cache<_CharT, _Intl>* __tmp = NULL;
164             try
165               {
166                 __tmp = new __moneypunct_cache<_CharT, _Intl>;
167                 __tmp->_M_cache(__loc);
168               }
169             catch(...)
170               {
171                 delete __tmp;
172                 __throw_exception_again;
173               }
174             __loc._M_impl->_M_install_cache(__tmp, __i);
175           }
176         return static_cast<
177           const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
178       }
179     };
180
181   template<typename _CharT>
182     void
183     __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
184     {
185       _M_allocated = true;
186
187       const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
188
189       _M_grouping_size = __np.grouping().size();
190       char* __grouping = new char[_M_grouping_size];
191       __np.grouping().copy(__grouping, _M_grouping_size);
192       _M_grouping = __grouping;
193       _M_use_grouping = _M_grouping_size && __np.grouping()[0] != 0;
194
195       _M_truename_size = __np.truename().size();
196       _CharT* __truename = new _CharT[_M_truename_size];
197       __np.truename().copy(__truename, _M_truename_size);
198       _M_truename = __truename;
199
200       _M_falsename_size = __np.falsename().size();
201       _CharT* __falsename = new _CharT[_M_falsename_size];
202       __np.falsename().copy(__falsename, _M_falsename_size);
203       _M_falsename = __falsename;
204
205       _M_decimal_point = __np.decimal_point();
206       _M_thousands_sep = __np.thousands_sep();
207
208       const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
209       __ct.widen(__num_base::_S_atoms_out,
210                  __num_base::_S_atoms_out + __num_base::_S_oend, _M_atoms_out);
211       __ct.widen(__num_base::_S_atoms_in,
212                  __num_base::_S_atoms_in + __num_base::_S_iend, _M_atoms_in);
213     }
214
215   template<typename _CharT, bool _Intl>
216     void
217     __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
218     {
219       _M_allocated = true;
220
221       const moneypunct<_CharT, _Intl>& __mp =
222         use_facet<moneypunct<_CharT, _Intl> >(__loc);
223
224       _M_grouping_size = __mp.grouping().size();
225       char* __grouping = new char[_M_grouping_size];
226       __mp.grouping().copy(__grouping, _M_grouping_size);
227       _M_grouping = __grouping;
228       _M_use_grouping = _M_grouping_size && __mp.grouping()[0] != 0;
229       
230       _M_decimal_point = __mp.decimal_point();
231       _M_thousands_sep = __mp.thousands_sep();
232       _M_frac_digits = __mp.frac_digits();
233       
234       _M_curr_symbol_size = __mp.curr_symbol().size();
235       _CharT* __curr_symbol = new _CharT[_M_curr_symbol_size];
236       __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
237       _M_curr_symbol = __curr_symbol;
238       
239       _M_positive_sign_size = __mp.positive_sign().size();
240       _CharT* __positive_sign = new _CharT[_M_positive_sign_size];
241       __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
242       _M_positive_sign = __positive_sign;
243
244       _M_negative_sign_size = __mp.negative_sign().size();
245       _CharT* __negative_sign = new _CharT[_M_negative_sign_size];
246       __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
247       _M_negative_sign = __negative_sign;
248       
249       _M_pos_format = __mp.pos_format();
250       _M_neg_format = __mp.neg_format();
251
252       const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
253       __ct.widen(money_base::_S_atoms,
254                  money_base::_S_atoms + money_base::_S_end, _M_atoms);
255     }
256
257
258   // Used by both numeric and monetary facets.
259   // Check to make sure that the __grouping_tmp string constructed in
260   // money_get or num_get matches the canonical grouping for a given
261   // locale.
262   // __grouping_tmp is parsed L to R
263   // 1,222,444 == __grouping_tmp of "\1\3\3"
264   // __grouping is parsed R to L
265   // 1,222,444 == __grouping of "\3" == "\3\3\3"
266   static bool
267   __verify_grouping(const char* __grouping, size_t __grouping_size,
268                     const string& __grouping_tmp);
269
270   template<typename _CharT, typename _InIter>
271     _InIter
272     num_get<_CharT, _InIter>::
273     _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
274                      ios_base::iostate& __err, string& __xtrc) const
275     {
276       typedef char_traits<_CharT>                       __traits_type;
277       typedef typename numpunct<_CharT>::__cache_type   __cache_type;
278       __use_cache<__cache_type> __uc;
279       const locale& __loc = __io._M_getloc();
280       const __cache_type* __lc = __uc(__loc);
281       const _CharT* __lit = __lc->_M_atoms_in;
282       char_type __c = char_type();
283
284       // True if __beg becomes equal to __end.
285       bool __testeof = __beg == __end;
286
287       // First check for sign.
288       if (!__testeof)
289         {
290           __c = *__beg;
291           const bool __plus = __c == __lit[__num_base::_S_iplus];
292           if ((__plus || __c == __lit[__num_base::_S_iminus])
293               && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
294               && !(__c == __lc->_M_decimal_point))
295             {
296               __xtrc += __plus ? '+' : '-';
297               if (++__beg != __end)
298                 __c = *__beg;
299               else
300                 __testeof = true;
301             }
302         }
303
304       // Next, look for leading zeros.
305       bool __found_mantissa = false;
306       while (!__testeof)
307         {
308           if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep
309               || __c == __lc->_M_decimal_point)
310             break;
311           else if (__c == __lit[__num_base::_S_izero])
312             {
313               if (!__found_mantissa)
314                 {
315                   __xtrc += '0';
316                   __found_mantissa = true;
317                 }
318               if (++__beg != __end)
319                 __c = *__beg;
320               else
321                 __testeof = true;
322             }
323           else
324             break;
325         }
326
327       // Only need acceptable digits for floating point numbers.
328       bool __found_dec = false;
329       bool __found_sci = false;
330       string __found_grouping;
331       if (__lc->_M_use_grouping)
332         __found_grouping.reserve(32);
333       int __sep_pos = 0;
334       const char_type* __q;
335       const char_type* __lit_zero = __lit + __num_base::_S_izero;
336       while (!__testeof)
337         {
338           // According to 22.2.2.1.2, p8-9, first look for thousands_sep
339           // and decimal_point.
340           if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
341             {
342               if (!__found_dec && !__found_sci)
343                 {
344                   // NB: Thousands separator at the beginning of a string
345                   // is a no-no, as is two consecutive thousands separators.
346                   if (__sep_pos)
347                     {
348                       __found_grouping += static_cast<char>(__sep_pos);
349                       __sep_pos = 0;
350                     }
351                   else
352                     {
353                       __err |= ios_base::failbit;
354                       break;
355                     }
356                 }
357               else
358                 break;
359             }
360           else if (__c == __lc->_M_decimal_point)
361             {
362               if (!__found_dec && !__found_sci)
363                 {
364                   // If no grouping chars are seen, no grouping check
365                   // is applied. Therefore __found_grouping is adjusted
366                   // only if decimal_point comes after some thousands_sep.
367                   if (__found_grouping.size())
368                     __found_grouping += static_cast<char>(__sep_pos);
369                   __xtrc += '.';
370                   __found_dec = true;
371                 }
372               else
373                 break;
374             }
375           else if ((__q = __traits_type::find(__lit_zero, 10, __c)))
376             {
377               __xtrc += __num_base::_S_atoms_in[__q - __lit];
378               __found_mantissa = true;
379               ++__sep_pos;
380             }
381           else if ((__c == __lit[__num_base::_S_ie] 
382                     || __c == __lit[__num_base::_S_iE])
383                    && __found_mantissa && !__found_sci)
384             {
385               // Scientific notation.
386               if (__found_grouping.size() && !__found_dec)
387                 __found_grouping += static_cast<char>(__sep_pos);
388               __xtrc += 'e';
389               __found_sci = true;
390
391               // Remove optional plus or minus sign, if they exist.
392               if (++__beg != __end)
393                 {
394                   __c = *__beg;
395                   const bool __plus = __c == __lit[__num_base::_S_iplus];
396                   if ((__plus || __c == __lit[__num_base::_S_iminus])
397                       && !(__lc->_M_use_grouping
398                            && __c == __lc->_M_thousands_sep)
399                       && !(__c == __lc->_M_decimal_point))
400                     __xtrc += __plus ? '+' : '-';
401                   else
402                     continue;
403                 }
404               else
405                 {
406                   __testeof = true;
407                   break;
408                 }
409             }
410           else
411             // Not a valid input item.
412             break;
413
414           if (++__beg != __end)
415             __c = *__beg;
416           else
417             __testeof = true;
418         }
419
420       // Digit grouping is checked. If grouping and found_grouping don't
421       // match, then get very very upset, and set failbit.
422       if (__found_grouping.size())
423         {
424           // Add the ending grouping if a decimal or 'e'/'E' wasn't found.
425           if (!__found_dec && !__found_sci)
426             __found_grouping += static_cast<char>(__sep_pos);
427
428           if (!std::__verify_grouping(__lc->_M_grouping, 
429                                       __lc->_M_grouping_size,
430                                       __found_grouping))
431             __err |= ios_base::failbit;
432         }
433
434       // Finish up.
435       if (__testeof)
436         __err |= ios_base::eofbit;
437       return __beg;
438     }
439
440   template<typename _CharT, typename _InIter>
441     template<typename _ValueT>
442       _InIter
443       num_get<_CharT, _InIter>::
444       _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
445                      ios_base::iostate& __err, _ValueT& __v) const
446       {
447         typedef char_traits<_CharT>                     __traits_type;
448         typedef typename numpunct<_CharT>::__cache_type __cache_type;
449         __use_cache<__cache_type> __uc;
450         const locale& __loc = __io._M_getloc();
451         const __cache_type* __lc = __uc(__loc);
452         const _CharT* __lit = __lc->_M_atoms_in;
453         char_type __c = char_type();
454
455         // NB: Iff __basefield == 0, __base can change based on contents.
456         const ios_base::fmtflags __basefield = __io.flags()
457                                                & ios_base::basefield;
458         const bool __oct = __basefield == ios_base::oct;
459         int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
460
461         // True if __beg becomes equal to __end.
462         bool __testeof = __beg == __end;
463
464         // First check for sign.
465         bool __negative = false;
466         if (!__testeof)
467           {
468             __c = *__beg;
469             if (numeric_limits<_ValueT>::is_signed)
470               __negative = __c == __lit[__num_base::_S_iminus];
471             if ((__negative || __c == __lit[__num_base::_S_iplus])
472                 && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
473                 && !(__c == __lc->_M_decimal_point))
474               {
475                 if (++__beg != __end)
476                   __c = *__beg;
477                 else
478                   __testeof = true;
479               }
480           }
481
482         // Next, look for leading zeros and check required digits
483         // for base formats.
484         bool __found_zero = false;
485         while (!__testeof)
486           {
487             if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep
488                 || __c == __lc->_M_decimal_point)
489               break;
490             else if (__c == __lit[__num_base::_S_izero] 
491                      && (!__found_zero || __base == 10))
492               __found_zero = true;
493             else if (__found_zero)
494               {
495                 if (__c == __lit[__num_base::_S_ix] 
496                     || __c == __lit[__num_base::_S_iX])
497                   {
498                     if (__basefield == 0)
499                       __base = 16;
500                     if (__base == 16)
501                       __found_zero = false;
502                     else
503                       break;
504                   }
505                 else
506                   {
507                     if (__basefield == 0)
508                       __base = 8;
509                     break;
510                   }
511               }
512             else
513               break;
514
515             if (++__beg != __end)
516               {
517                 __c = *__beg;
518                 if (!__found_zero)
519                   break;
520               }
521             else
522               __testeof = true;
523           }
524         
525         // At this point, base is determined. If not hex, only allow
526         // base digits as valid input.
527         const size_t __len = (__base == 16 ? __num_base::_S_iend
528                               - __num_base::_S_izero : __base);
529
530         // Extract.
531         string __found_grouping;
532         if (__lc->_M_use_grouping)
533           __found_grouping.reserve(32);
534         int __sep_pos = 0;
535         bool __overflow = false;
536         _ValueT __result = 0;
537         const char_type* __q;
538         const char_type* __lit_zero = __lit + __num_base::_S_izero;
539         if (__negative)
540           {
541             const _ValueT __min = numeric_limits<_ValueT>::min() / __base;
542             while (!__testeof)
543               {
544                 // According to 22.2.2.1.2, p8-9, first look for thousands_sep
545                 // and decimal_point.
546                 if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
547                   {
548                     // NB: Thousands separator at the beginning of a string
549                     // is a no-no, as is two consecutive thousands separators.
550                     if (__sep_pos)
551                       {
552                         __found_grouping += static_cast<char>(__sep_pos);
553                         __sep_pos = 0;
554                       }
555                     else
556                       {
557                         __err |= ios_base::failbit;
558                         break;
559                       }
560                   }
561                 else if (__c == __lc->_M_decimal_point)
562                   break;
563                 else if ((__q = __traits_type::find(__lit_zero, __len, __c)))
564                   {
565                     int __digit = __q - __lit_zero;
566                     if (__digit > 15)
567                       __digit -= 6;
568                     if (__result < __min)
569                       __overflow = true;
570                     else
571                       {
572                         const _ValueT __new_result = (__result * __base
573                                                       - __digit);
574                         __overflow |= __new_result > __result;
575                         __result = __new_result;
576                         ++__sep_pos;
577                       }
578                   }
579                 else
580                   // Not a valid input item.
581                   break;
582
583                 if (++__beg != __end)
584                   __c = *__beg;
585                 else
586                   __testeof = true;
587               }
588           }
589         else
590           {
591             const _ValueT __max = numeric_limits<_ValueT>::max() / __base;
592             while (!__testeof)
593               {
594                 if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
595                   {
596                     if (__sep_pos)
597                       {
598                         __found_grouping += static_cast<char>(__sep_pos);
599                         __sep_pos = 0;
600                       }
601                     else
602                       {
603                         __err |= ios_base::failbit;
604                         break;
605                       }
606                   }
607                 else if (__c == __lc->_M_decimal_point)
608                   break;
609                 else if ((__q = __traits_type::find(__lit_zero, __len, __c)))
610                   {
611                     int __digit = __q - __lit_zero;
612                     if (__digit > 15)
613                       __digit -= 6;
614                     if (__result > __max)
615                       __overflow = true;
616                     else
617                       {
618                         const _ValueT __new_result = (__result * __base
619                                                       + __digit);
620                         __overflow |= __new_result < __result;
621                         __result = __new_result;
622                         ++__sep_pos;
623                       }
624                   }
625                 else
626                   break;
627
628                 if (++__beg != __end)
629                   __c = *__beg;
630                 else
631                   __testeof = true;
632               }
633           }
634
635         // Digit grouping is checked. If grouping and found_grouping don't
636         // match, then get very very upset, and set failbit.
637         if (__found_grouping.size())
638           {
639             // Add the ending grouping.
640             __found_grouping += static_cast<char>(__sep_pos);
641
642             if (!std::__verify_grouping(__lc->_M_grouping,
643                                         __lc->_M_grouping_size,
644                                         __found_grouping))
645               __err |= ios_base::failbit;
646           }
647
648         if (!(__err & ios_base::failbit) && !__overflow
649             && (__sep_pos || __found_zero || __found_grouping.size()))
650           __v = __result;
651         else
652           __err |= ios_base::failbit;
653
654         if (__testeof)
655           __err |= ios_base::eofbit;
656         return __beg;
657       }
658
659   // _GLIBCXX_RESOLVE_LIB_DEFECTS
660   // 17.  Bad bool parsing
661   template<typename _CharT, typename _InIter>
662     _InIter
663     num_get<_CharT, _InIter>::
664     do_get(iter_type __beg, iter_type __end, ios_base& __io,
665            ios_base::iostate& __err, bool& __v) const
666     {
667       if (!(__io.flags() & ios_base::boolalpha))
668         {
669           // Parse bool values as long.
670           // NB: We can't just call do_get(long) here, as it might
671           // refer to a derived class.
672           long __l = -1;
673           __beg = _M_extract_int(__beg, __end, __io, __err, __l);
674           if (__l == 0 || __l == 1)
675             __v = __l;
676           else
677             __err |= ios_base::failbit;
678         }
679       else
680         {
681           // Parse bool values as alphanumeric.
682           typedef typename numpunct<_CharT>::__cache_type __cache_type;
683           __use_cache<__cache_type> __uc;
684           const locale& __loc = __io._M_getloc();
685           const __cache_type* __lc = __uc(__loc);
686
687           bool __testf = true;
688           bool __testt = true;
689           size_t __n;
690           bool __testeof = __beg == __end;
691           for (__n = 0; !__testeof; ++__n)
692             {
693               const char_type __c = *__beg;
694
695               if (__testf)
696                 if (__n < __lc->_M_falsename_size)
697                   __testf = __c == __lc->_M_falsename[__n];
698                 else
699                   break;
700
701               if (__testt)
702                 if (__n < __lc->_M_truename_size)
703                   __testt = __c == __lc->_M_truename[__n];
704                 else
705                   break;
706
707               if (!__testf && !__testt)
708                 break;
709               
710               if (++__beg == __end)
711                 __testeof = true;
712             }
713           if (__testf && __n == __lc->_M_falsename_size)
714             __v = 0;
715           else if (__testt && __n == __lc->_M_truename_size)
716             __v = 1;
717           else
718             __err |= ios_base::failbit;
719
720           if (__testeof)
721             __err |= ios_base::eofbit;
722         }
723       return __beg;
724     }
725
726   template<typename _CharT, typename _InIter>
727     _InIter
728     num_get<_CharT, _InIter>::
729     do_get(iter_type __beg, iter_type __end, ios_base& __io,
730            ios_base::iostate& __err, long& __v) const
731     { return _M_extract_int(__beg, __end, __io, __err, __v); }
732
733   template<typename _CharT, typename _InIter>
734     _InIter
735     num_get<_CharT, _InIter>::
736     do_get(iter_type __beg, iter_type __end, ios_base& __io,
737            ios_base::iostate& __err, unsigned short& __v) const
738     { return _M_extract_int(__beg, __end, __io, __err, __v); }
739
740   template<typename _CharT, typename _InIter>
741     _InIter
742     num_get<_CharT, _InIter>::
743     do_get(iter_type __beg, iter_type __end, ios_base& __io,
744            ios_base::iostate& __err, unsigned int& __v) const
745     { return _M_extract_int(__beg, __end, __io, __err, __v); }
746
747   template<typename _CharT, typename _InIter>
748     _InIter
749     num_get<_CharT, _InIter>::
750     do_get(iter_type __beg, iter_type __end, ios_base& __io,
751            ios_base::iostate& __err, unsigned long& __v) const
752     { return _M_extract_int(__beg, __end, __io, __err, __v); }
753
754 #ifdef _GLIBCXX_USE_LONG_LONG
755   template<typename _CharT, typename _InIter>
756     _InIter
757     num_get<_CharT, _InIter>::
758     do_get(iter_type __beg, iter_type __end, ios_base& __io,
759            ios_base::iostate& __err, long long& __v) const
760     { return _M_extract_int(__beg, __end, __io, __err, __v); }
761
762   template<typename _CharT, typename _InIter>
763     _InIter
764     num_get<_CharT, _InIter>::
765     do_get(iter_type __beg, iter_type __end, ios_base& __io,
766            ios_base::iostate& __err, unsigned long long& __v) const
767     { return _M_extract_int(__beg, __end, __io, __err, __v); }
768 #endif
769
770   template<typename _CharT, typename _InIter>
771     _InIter
772     num_get<_CharT, _InIter>::
773     do_get(iter_type __beg, iter_type __end, ios_base& __io,
774            ios_base::iostate& __err, float& __v) const
775     {
776       string __xtrc;
777       __xtrc.reserve(32);
778       __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
779       std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
780       return __beg;
781     }
782
783   template<typename _CharT, typename _InIter>
784     _InIter
785     num_get<_CharT, _InIter>::
786     do_get(iter_type __beg, iter_type __end, ios_base& __io,
787            ios_base::iostate& __err, double& __v) const
788     {
789       string __xtrc;
790       __xtrc.reserve(32);
791       __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
792       std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
793       return __beg;
794     }
795
796   template<typename _CharT, typename _InIter>
797     _InIter
798     num_get<_CharT, _InIter>::
799     do_get(iter_type __beg, iter_type __end, ios_base& __io,
800            ios_base::iostate& __err, long double& __v) const
801     {
802       string __xtrc;
803       __xtrc.reserve(32);
804       __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
805       std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
806       return __beg;
807     }
808
809   template<typename _CharT, typename _InIter>
810     _InIter
811     num_get<_CharT, _InIter>::
812     do_get(iter_type __beg, iter_type __end, ios_base& __io,
813            ios_base::iostate& __err, void*& __v) const
814     {
815       // Prepare for hex formatted input.
816       typedef ios_base::fmtflags        fmtflags;
817       const fmtflags __fmt = __io.flags();
818       __io.flags(__fmt & ~ios_base::basefield | ios_base::hex);
819
820       unsigned long __ul;
821       __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
822
823       // Reset from hex formatted input.
824       __io.flags(__fmt);
825
826       if (!(__err & ios_base::failbit))
827         __v = reinterpret_cast<void*>(__ul);
828       return __beg;
829     }
830
831   // For use by integer and floating-point types after they have been
832   // converted into a char_type string.
833   template<typename _CharT, typename _OutIter>
834     void
835     num_put<_CharT, _OutIter>::
836     _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
837            _CharT* __new, const _CharT* __cs, int& __len) const
838     {
839       // [22.2.2.2.2] Stage 3.
840       // If necessary, pad.
841       __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, __cs,
842                                                   __w, __len, true);
843       __len = static_cast<int>(__w);
844     }
845
846   // Forwarding functions to peel signed from unsigned integer types.
847   template<typename _CharT>
848     inline int
849     __int_to_char(_CharT* __bufend, long __v, const _CharT* __lit,
850                   ios_base::fmtflags __flags)
851     {
852       unsigned long __ul = static_cast<unsigned long>(__v);
853       bool __neg = false;
854       if (__v < 0)
855         {
856           __ul = -__ul;
857           __neg = true;
858         }
859       return __int_to_char(__bufend, __ul, __lit, __flags, __neg);
860     }
861
862   template<typename _CharT>
863     inline int
864     __int_to_char(_CharT* __bufend, unsigned long __v, const _CharT* __lit,
865                   ios_base::fmtflags __flags)
866     {
867       // About showpos, see Table 60 and C99 7.19.6.1, p6 (+).
868       return __int_to_char(__bufend, __v, __lit,
869                            __flags & ~ios_base::showpos, false);
870     }
871
872 #ifdef _GLIBCXX_USE_LONG_LONG
873   template<typename _CharT>
874     inline int
875     __int_to_char(_CharT* __bufend, long long __v, const _CharT* __lit,
876                   ios_base::fmtflags __flags)
877     {
878       unsigned long long __ull = static_cast<unsigned long long>(__v);
879       bool __neg = false;
880       if (__v < 0)
881         {
882           __ull = -__ull;
883           __neg = true;
884         }
885       return __int_to_char(__bufend, __ull, __lit, __flags, __neg);
886     }
887
888   template<typename _CharT>
889     inline int
890     __int_to_char(_CharT* __bufend, unsigned long long __v, 
891                   const _CharT* __lit, ios_base::fmtflags __flags)
892     { return __int_to_char(__bufend, __v, __lit,
893                            __flags & ~ios_base::showpos, false); }
894 #endif
895
896   template<typename _CharT, typename _ValueT>
897     int
898     __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
899                   ios_base::fmtflags __flags, bool __neg)
900     {
901       // Don't write base if already 0.
902       const bool __showbase = (__flags & ios_base::showbase) && __v;
903       const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
904       _CharT* __buf = __bufend - 1;
905
906       if (__builtin_expect(__basefield != ios_base::oct &&
907                            __basefield != ios_base::hex, true))
908         {
909           // Decimal.
910           do
911             {
912               *__buf-- = __lit[(__v % 10) + __num_base::_S_odigits];
913               __v /= 10;
914             }
915           while (__v != 0);
916           if (__neg)
917             *__buf-- = __lit[__num_base::_S_ominus];
918           else if (__flags & ios_base::showpos)
919             *__buf-- = __lit[__num_base::_S_oplus];
920         }
921       else if (__basefield == ios_base::oct)
922         {
923           // Octal.
924           do
925             {
926               *__buf-- = __lit[(__v & 0x7) + __num_base::_S_odigits];
927               __v >>= 3;
928             }
929           while (__v != 0);
930           if (__showbase)
931             *__buf-- = __lit[__num_base::_S_odigits];
932         }
933       else
934         {
935           // Hex.
936           const bool __uppercase = __flags & ios_base::uppercase;
937           const int __case_offset = __uppercase ? __num_base::_S_oudigits
938                                                 : __num_base::_S_odigits;
939           do
940             {
941               *__buf-- = __lit[(__v & 0xf) + __case_offset];
942               __v >>= 4;
943             }
944           while (__v != 0);
945           if (__showbase)
946             {
947               // 'x' or 'X'
948               *__buf-- = __lit[__num_base::_S_ox + __uppercase];
949               // '0'
950               *__buf-- = __lit[__num_base::_S_odigits];
951             }
952         }
953       return __bufend - __buf - 1;
954     }
955
956   template<typename _CharT, typename _OutIter>
957     void
958     num_put<_CharT, _OutIter>::
959     _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
960                  ios_base& __io, _CharT* __new, _CharT* __cs, int& __len) const
961     {
962       // By itself __add_grouping cannot deal correctly with __cs when
963       // ios::showbase is set and ios_base::oct || ios_base::hex.
964       // Therefore we take care "by hand" of the initial 0, 0x or 0X.
965       // However, remember that the latter do not occur if the number
966       // printed is '0' (__len == 1).
967       streamsize __off = 0;
968       const ios_base::fmtflags __basefield = __io.flags()
969                                              & ios_base::basefield;
970       if ((__io.flags() & ios_base::showbase) && __len > 1)
971         if (__basefield == ios_base::oct)
972           {
973             __off = 1;
974             __new[0] = __cs[0];
975           }
976         else if (__basefield == ios_base::hex)
977           {
978             __off = 2;
979             __new[0] = __cs[0];
980             __new[1] = __cs[1];
981           }
982       _CharT* __p = std::__add_grouping(__new + __off, __sep, __grouping,
983                                         __grouping_size, __cs + __off,
984                                         __cs + __len);
985       __len = __p - __new;
986     }
987
988   template<typename _CharT, typename _OutIter>
989     template<typename _ValueT>
990       _OutIter
991       num_put<_CharT, _OutIter>::
992       _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
993                     _ValueT __v) const
994       {
995         typedef typename numpunct<_CharT>::__cache_type __cache_type;
996         __use_cache<__cache_type> __uc;
997         const locale& __loc = __io._M_getloc();
998         const __cache_type* __lc = __uc(__loc);
999         const _CharT* __lit = __lc->_M_atoms_out;
1000
1001         // Long enough to hold hex, dec, and octal representations.
1002         const int __ilen = 4 * sizeof(_ValueT);
1003         _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1004                                                              * __ilen));
1005
1006         // [22.2.2.2.2] Stage 1, numeric conversion to character.
1007         // Result is returned right-justified in the buffer.
1008         int __len;
1009         __len = __int_to_char(__cs + __ilen, __v, __lit, __io.flags());
1010         __cs += __ilen - __len;
1011
1012         // Add grouping, if necessary.
1013         if (__lc->_M_use_grouping)
1014           {
1015             // Grouping can add (almost) as many separators as the
1016             // number of digits, but no more.
1017             _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1018                                                                   * __len * 2));
1019             _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
1020                          __lc->_M_thousands_sep, __io, __cs2, __cs, __len);
1021             __cs = __cs2;
1022           }
1023
1024         // Pad.
1025         const streamsize __w = __io.width();
1026         if (__w > static_cast<streamsize>(__len))
1027           {
1028             _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1029                                                                   * __w));
1030             _M_pad(__fill, __w, __io, __cs3, __cs, __len);
1031             __cs = __cs3;
1032           }
1033         __io.width(0);
1034
1035         // [22.2.2.2.2] Stage 4.
1036         // Write resulting, fully-formatted string to output iterator.
1037         return std::__write(__s, __cs, __len);
1038       }
1039
1040   template<typename _CharT, typename _OutIter>
1041     void
1042     num_put<_CharT, _OutIter>::
1043     _M_group_float(const char* __grouping, size_t __grouping_size,
1044                    _CharT __sep, const _CharT* __p, _CharT* __new,
1045                    _CharT* __cs, int& __len) const
1046     {
1047       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1048       // 282. What types does numpunct grouping refer to?
1049       // Add grouping, if necessary.
1050       const int __declen = __p ? __p - __cs : __len;
1051       _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
1052                                          __grouping_size,
1053                                          __cs, __cs + __declen);
1054
1055       // Tack on decimal part.
1056       int __newlen = __p2 - __new;
1057       if (__p)
1058         {
1059           char_traits<_CharT>::copy(__p2, __p, __len - __declen);
1060           __newlen += __len - __declen;
1061         }
1062       __len = __newlen;
1063     }
1064
1065   // The following code uses snprintf (or sprintf(), when
1066   // _GLIBCXX_USE_C99 is not defined) to convert floating point values
1067   // for insertion into a stream.  An optimization would be to replace
1068   // them with code that works directly on a wide buffer and then use
1069   // __pad to do the padding.  It would be good to replace them anyway
1070   // to gain back the efficiency that C++ provides by knowing up front
1071   // the type of the values to insert.  Also, sprintf is dangerous
1072   // since may lead to accidental buffer overruns.  This
1073   // implementation follows the C++ standard fairly directly as
1074   // outlined in 22.2.2.2 [lib.locale.num.put]
1075   template<typename _CharT, typename _OutIter>
1076     template<typename _ValueT>
1077       _OutIter
1078       num_put<_CharT, _OutIter>::
1079       _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
1080                        _ValueT __v) const
1081       {
1082         typedef typename numpunct<_CharT>::__cache_type __cache_type;
1083         __use_cache<__cache_type> __uc;
1084         const locale& __loc = __io._M_getloc();
1085         const __cache_type* __lc = __uc(__loc);
1086
1087         // Use default precision if out of range.
1088         streamsize __prec = __io.precision();
1089         if (__prec < static_cast<streamsize>(0))
1090           __prec = static_cast<streamsize>(6);
1091
1092         const int __max_digits = numeric_limits<_ValueT>::digits10;
1093
1094         // [22.2.2.2.2] Stage 1, numeric conversion to character.
1095         int __len;
1096         // Long enough for the max format spec.
1097         char __fbuf[16];
1098
1099 #ifdef _GLIBCXX_USE_C99
1100         // First try a buffer perhaps big enough (most probably sufficient
1101         // for non-ios_base::fixed outputs)
1102         int __cs_size = __max_digits * 3;
1103         char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1104
1105         __num_base::_S_format_float(__io, __fbuf, __mod);
1106         __len = std::__convert_from_v(__cs, __cs_size, __fbuf, __v,
1107                                       _S_get_c_locale(), __prec);
1108
1109         // If the buffer was not large enough, try again with the correct size.
1110         if (__len >= __cs_size)
1111           {
1112             __cs_size = __len + 1;
1113             __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1114             __len = std::__convert_from_v(__cs, __cs_size, __fbuf, __v,
1115                                           _S_get_c_locale(), __prec);
1116           }
1117 #else
1118         // Consider the possibility of long ios_base::fixed outputs
1119         const bool __fixed = __io.flags() & ios_base::fixed;
1120         const int __max_exp = numeric_limits<_ValueT>::max_exponent10;
1121
1122         // The size of the output string is computed as follows.
1123         // ios_base::fixed outputs may need up to __max_exp + 1 chars
1124         // for the integer part + __prec chars for the fractional part
1125         // + 3 chars for sign, decimal point, '\0'. On the other hand,
1126         // for non-fixed outputs __max_digits * 2 + __prec chars are
1127         // largely sufficient.
1128         const int __cs_size = __fixed ? __max_exp + __prec + 4
1129                                       : __max_digits * 2 + __prec;
1130         char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1131
1132         __num_base::_S_format_float(__io, __fbuf, __mod);
1133         __len = std::__convert_from_v(__cs, 0, __fbuf, __v,
1134                                       _S_get_c_locale(), __prec);
1135 #endif
1136
1137       // [22.2.2.2.2] Stage 2, convert to char_type, using correct
1138       // numpunct.decimal_point() values for '.' and adding grouping.
1139       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1140
1141       _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1142                                                            * __len));
1143       __ctype.widen(__cs, __cs + __len, __ws);
1144
1145       // Replace decimal point.
1146       const _CharT __cdec = __ctype.widen('.');
1147       const _CharT __dec = __lc->_M_decimal_point;
1148       const _CharT* __p = char_traits<_CharT>::find(__ws, __len, __cdec);
1149       if (__p)
1150         __ws[__p - __ws] = __dec;
1151
1152       // Add grouping, if necessary.
1153       if (__lc->_M_use_grouping)
1154         {
1155           // Grouping can add (almost) as many separators as the
1156           // number of digits, but no more.
1157           _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1158                                                                 * __len * 2));
1159           _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
1160                          __lc->_M_thousands_sep, __p, __ws2, __ws, __len);
1161           __ws = __ws2;
1162         }
1163
1164       // Pad.
1165       const streamsize __w = __io.width();
1166       if (__w > static_cast<streamsize>(__len))
1167         {
1168           _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1169                                                                 * __w));
1170           _M_pad(__fill, __w, __io, __ws3, __ws, __len);
1171           __ws = __ws3;
1172         }
1173       __io.width(0);
1174
1175       // [22.2.2.2.2] Stage 4.
1176       // Write resulting, fully-formatted string to output iterator.
1177       return std::__write(__s, __ws, __len);
1178       }
1179
1180   template<typename _CharT, typename _OutIter>
1181     _OutIter
1182     num_put<_CharT, _OutIter>::
1183     do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
1184     {
1185       const ios_base::fmtflags __flags = __io.flags();
1186       if ((__flags & ios_base::boolalpha) == 0)
1187         {
1188           const long __l = __v;
1189           __s = _M_insert_int(__s, __io, __fill, __l);
1190         }
1191       else
1192         {
1193           typedef typename numpunct<_CharT>::__cache_type __cache_type;
1194           __use_cache<__cache_type> __uc;
1195           const locale& __loc = __io._M_getloc();
1196           const __cache_type* __lc = __uc(__loc);
1197
1198           const _CharT* __name = __v ? __lc->_M_truename
1199                                      : __lc->_M_falsename;
1200           int __len = __v ? __lc->_M_truename_size
1201                           : __lc->_M_falsename_size;
1202
1203           const streamsize __w = __io.width();
1204           if (__w > static_cast<streamsize>(__len))
1205             {
1206               _CharT* __cs
1207                 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1208                                                         * __w));
1209               _M_pad(__fill, __w, __io, __cs, __name, __len);
1210               __name = __cs;
1211             }
1212           __io.width(0);
1213           __s = std::__write(__s, __name, __len);
1214         }
1215       return __s;
1216     }
1217
1218   template<typename _CharT, typename _OutIter>
1219     _OutIter
1220     num_put<_CharT, _OutIter>::
1221     do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
1222     { return _M_insert_int(__s, __io, __fill, __v); }
1223
1224   template<typename _CharT, typename _OutIter>
1225     _OutIter
1226     num_put<_CharT, _OutIter>::
1227     do_put(iter_type __s, ios_base& __io, char_type __fill,
1228            unsigned long __v) const
1229     { return _M_insert_int(__s, __io, __fill, __v); }
1230
1231 #ifdef _GLIBCXX_USE_LONG_LONG
1232   template<typename _CharT, typename _OutIter>
1233     _OutIter
1234     num_put<_CharT, _OutIter>::
1235     do_put(iter_type __s, ios_base& __b, char_type __fill, long long __v) const
1236     { return _M_insert_int(__s, __b, __fill, __v); }
1237
1238   template<typename _CharT, typename _OutIter>
1239     _OutIter
1240     num_put<_CharT, _OutIter>::
1241     do_put(iter_type __s, ios_base& __io, char_type __fill,
1242            unsigned long long __v) const
1243     { return _M_insert_int(__s, __io, __fill, __v); }
1244 #endif
1245
1246   template<typename _CharT, typename _OutIter>
1247     _OutIter
1248     num_put<_CharT, _OutIter>::
1249     do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
1250     { return _M_insert_float(__s, __io, __fill, char(), __v); }
1251
1252   template<typename _CharT, typename _OutIter>
1253     _OutIter
1254     num_put<_CharT, _OutIter>::
1255     do_put(iter_type __s, ios_base& __io, char_type __fill,
1256            long double __v) const
1257     { return _M_insert_float(__s, __io, __fill, 'L', __v); }
1258
1259   template<typename _CharT, typename _OutIter>
1260     _OutIter
1261     num_put<_CharT, _OutIter>::
1262     do_put(iter_type __s, ios_base& __io, char_type __fill,
1263            const void* __v) const
1264     {
1265       const ios_base::fmtflags __flags = __io.flags();
1266       const ios_base::fmtflags __fmt = ~(ios_base::basefield
1267                                          | ios_base::uppercase
1268                                          | ios_base::internal);
1269       __io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase));
1270
1271       __s = _M_insert_int(__s, __io, __fill,
1272                           reinterpret_cast<unsigned long>(__v));
1273       __io.flags(__flags);
1274       return __s;
1275     }
1276
1277   template<typename _CharT, typename _InIter>
1278     template<bool _Intl>
1279       _InIter
1280       money_get<_CharT, _InIter>::
1281       _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
1282                  ios_base::iostate& __err, string& __units) const
1283       {
1284         typedef char_traits<_CharT>                       __traits_type;
1285         typedef typename string_type::size_type           size_type;    
1286         typedef money_base::part                          part;
1287         typedef moneypunct<_CharT, _Intl>                 __moneypunct_type;
1288         typedef typename __moneypunct_type::__cache_type  __cache_type;
1289         
1290         const locale& __loc = __io._M_getloc();
1291         const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1292
1293         __use_cache<__cache_type> __uc;
1294         const __cache_type* __lc = __uc(__loc);
1295         const char_type* __lit = __lc->_M_atoms;
1296
1297         // Deduced sign.
1298         bool __negative = false;
1299         // Sign size.
1300         size_type __sign_size = 0;
1301         // True if sign is mandatory.
1302         const bool __mandatory_sign = (__lc->_M_positive_sign_size
1303                                        && __lc->_M_negative_sign_size);
1304         // String of grouping info from thousands_sep plucked from __units.
1305         string __grouping_tmp;
1306         if (__lc->_M_use_grouping)
1307           __grouping_tmp.reserve(32);
1308         // Last position before the decimal point.
1309         int __last_pos = 0;
1310         // Separator positions, then, possibly, fractional digits.
1311         int __n = 0;
1312         // If input iterator is in a valid state.
1313         bool __testvalid = true;
1314         // Flag marking when a decimal point is found.
1315         bool __testdecfound = false;
1316
1317         // The tentative returned string is stored here.
1318         string __res;
1319         __res.reserve(32);
1320
1321         const char_type* __lit_zero = __lit + money_base::_S_zero;
1322         const money_base::pattern __p = __lc->_M_neg_format;
1323         for (int __i = 0; __i < 4 && __testvalid; ++__i)
1324           {
1325             const part __which = static_cast<part>(__p.field[__i]);
1326             switch (__which)
1327               {
1328               case money_base::symbol:
1329                 // According to 22.2.6.1.2, p2, symbol is required
1330                 // if (__io.flags() & ios_base::showbase), otherwise
1331                 // is optional and consumed only if other characters
1332                 // are needed to complete the format.
1333                 if (__io.flags() & ios_base::showbase || __sign_size > 1
1334                     || __i == 0
1335                     || (__i == 1 && (__mandatory_sign
1336                                      || (static_cast<part>(__p.field[0])
1337                                          == money_base::sign)
1338                                      || (static_cast<part>(__p.field[2])
1339                                          == money_base::space)))
1340                     || (__i == 2 && ((static_cast<part>(__p.field[3])
1341                                       == money_base::value)
1342                                      || __mandatory_sign
1343                                      && (static_cast<part>(__p.field[3])
1344                                          == money_base::sign))))
1345                   {
1346                     const size_type __len = __lc->_M_curr_symbol_size;
1347                     size_type __j = 0;
1348                     for (; __beg != __end && __j < __len
1349                            && *__beg == __lc->_M_curr_symbol[__j];
1350                          ++__beg, ++__j);
1351                     if (__j != __len
1352                         && (__j || __io.flags() & ios_base::showbase))
1353                       __testvalid = false;
1354                   }
1355                 break;
1356               case money_base::sign:
1357                 // Sign might not exist, or be more than one character long.
1358                 if (__lc->_M_positive_sign_size && __beg != __end
1359                     && *__beg == __lc->_M_positive_sign[0])
1360                   {
1361                     __sign_size = __lc->_M_positive_sign_size;
1362                     ++__beg;
1363                   }
1364                 else if (__lc->_M_negative_sign_size && __beg != __end
1365                          && *__beg == __lc->_M_negative_sign[0])
1366                   {
1367                     __negative = true;
1368                     __sign_size = __lc->_M_negative_sign_size;
1369                     ++__beg;
1370                   }
1371                 else if (__lc->_M_positive_sign_size
1372                          && !__lc->_M_negative_sign_size)
1373                   // "... if no sign is detected, the result is given the sign
1374                   // that corresponds to the source of the empty string"
1375                   __negative = true;
1376                 else if (__mandatory_sign)
1377                   __testvalid = false;
1378                 break;
1379               case money_base::value:
1380                 // Extract digits, remove and stash away the
1381                 // grouping of found thousands separators.
1382                 for (; __beg != __end; ++__beg)
1383                   {
1384                     const char_type __c = *__beg;
1385                     const char_type* __q = __traits_type::find(__lit_zero, 
1386                                                                10, __c);
1387                     if (__q != 0)
1388                       {
1389                         __res += money_base::_S_atoms[__q - __lit];
1390                         ++__n;
1391                       }
1392                     else if (__c == __lc->_M_decimal_point 
1393                              && !__testdecfound)
1394                       {
1395                         __last_pos = __n;
1396                         __n = 0;
1397                         __testdecfound = true;
1398                       }
1399                     else if (__lc->_M_use_grouping
1400                              && __c == __lc->_M_thousands_sep
1401                              && !__testdecfound)
1402                       {
1403                         if (__n)
1404                           {
1405                             // Mark position for later analysis.
1406                             __grouping_tmp += static_cast<char>(__n);
1407                             __n = 0;
1408                           }
1409                         else
1410                           {
1411                             __testvalid = false;
1412                             break;
1413                           }
1414                       }
1415                     else
1416                       break;
1417                   }
1418                 if (__res.empty())
1419                   __testvalid = false;
1420                 break;
1421               case money_base::space:
1422                 // At least one space is required.
1423                 if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
1424                   ++__beg;
1425                 else
1426                   __testvalid = false;
1427               case money_base::none:
1428                 // Only if not at the end of the pattern.
1429                 if (__i != 3)
1430                   for (; __beg != __end
1431                          && __ctype.is(ctype_base::space, *__beg); ++__beg);
1432                 break;
1433               }
1434           }
1435
1436         // Need to get the rest of the sign characters, if they exist.
1437         if (__sign_size > 1 && __testvalid)
1438           {
1439             const char_type* __sign = __negative ? __lc->_M_negative_sign
1440                                                  : __lc->_M_positive_sign;
1441             size_type __i = 1;
1442             for (; __beg != __end && __i < __sign_size
1443                    && *__beg == __sign[__i]; ++__beg, ++__i);
1444             
1445             if (__i != __sign_size)
1446               __testvalid = false;
1447           }
1448
1449         if (__testvalid)
1450           {
1451             // Strip leading zeros.
1452             if (__res.size() > 1)
1453               {
1454                 const size_type __first = __res.find_first_not_of('0');
1455                 const bool __only_zeros = __first == string::npos;
1456                 if (__first)
1457                   __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
1458               }
1459
1460             // 22.2.6.1.2, p4
1461             if (__negative && __res[0] != '0')
1462               __res.insert(__res.begin(), '-');
1463             
1464             // Test for grouping fidelity.
1465             if (__grouping_tmp.size())
1466               {
1467                 // Add the ending grouping.
1468                 __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
1469                                                                    : __n);
1470                 if (!std::__verify_grouping(__lc->_M_grouping,
1471                                             __lc->_M_grouping_size,
1472                                             __grouping_tmp))
1473                   __testvalid = false;
1474               }
1475             
1476             // Iff not enough digits were supplied after the decimal-point.
1477             if (__testdecfound && __lc->_M_frac_digits > 0
1478                 && __n != __lc->_M_frac_digits)
1479               __testvalid = false;
1480           }
1481         
1482         // Iff valid sequence is not recognized.
1483         if (!__testvalid)
1484           __err |= ios_base::failbit;
1485         else
1486           __units.swap(__res);
1487         
1488         // Iff no more characters are available.
1489         if (__beg == __end)
1490           __err |= ios_base::eofbit;
1491         return __beg;
1492       }
1493
1494   template<typename _CharT, typename _InIter>
1495     _InIter
1496     money_get<_CharT, _InIter>::
1497     do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
1498            ios_base::iostate& __err, long double& __units) const
1499     {
1500       string __str;
1501       if (__intl)
1502         __beg = _M_extract<true>(__beg, __end, __io, __err, __str);
1503       else
1504         __beg = _M_extract<false>(__beg, __end, __io, __err, __str);
1505       std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
1506       return __beg;
1507     }
1508
1509   template<typename _CharT, typename _InIter>
1510     _InIter
1511     money_get<_CharT, _InIter>::
1512     do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
1513            ios_base::iostate& __err, string_type& __units) const
1514     {
1515       typedef typename string::size_type                  size_type;
1516
1517       const locale& __loc = __io._M_getloc();
1518       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1519
1520       string __str;
1521       const iter_type __ret = __intl ? _M_extract<true>(__beg, __end, __io,
1522                                                         __err, __str)
1523                                      : _M_extract<false>(__beg, __end, __io,
1524                                                          __err, __str);
1525       const size_type __len = __str.size();
1526       if (__len)
1527         {
1528           _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1529                                                                * __len));
1530           __ctype.widen(__str.data(), __str.data() + __len, __ws);
1531           __units.assign(__ws, __len);
1532         }
1533
1534       return __ret;
1535     }
1536
1537   template<typename _CharT, typename _OutIter>
1538     template<bool _Intl>
1539       _OutIter
1540       money_put<_CharT, _OutIter>::
1541       _M_insert(iter_type __s, ios_base& __io, char_type __fill,
1542                 const string_type& __digits) const
1543       {
1544         typedef typename string_type::size_type           size_type;
1545         typedef money_base::part                          part;
1546         typedef moneypunct<_CharT, _Intl>                 __moneypunct_type;
1547         typedef typename __moneypunct_type::__cache_type  __cache_type;
1548       
1549         const locale& __loc = __io._M_getloc();
1550         const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1551
1552         __use_cache<__cache_type> __uc;
1553         const __cache_type* __lc = __uc(__loc);
1554         const char_type* __lit = __lc->_M_atoms;
1555
1556         // Determine if negative or positive formats are to be used, and
1557         // discard leading negative_sign if it is present.
1558         const char_type* __beg = __digits.data();
1559
1560         money_base::pattern __p;
1561         const char_type* __sign;
1562         size_type __sign_size;
1563         if (*__beg != __lit[money_base::_S_minus])
1564           {
1565             __p = __lc->_M_pos_format;
1566             __sign = __lc->_M_positive_sign;
1567             __sign_size = __lc->_M_positive_sign_size;
1568           }
1569         else
1570           {
1571             __p = __lc->_M_neg_format;
1572             __sign = __lc->_M_negative_sign;
1573             __sign_size = __lc->_M_negative_sign_size;
1574             if (__digits.size())
1575               ++__beg;
1576           }
1577        
1578         // Look for valid numbers in the ctype facet within input digits.
1579         size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
1580                                            __beg + __digits.size()) - __beg;
1581         if (__len)
1582           {
1583             // Assume valid input, and attempt to format.
1584             // Break down input numbers into base components, as follows:
1585             //   final_value = grouped units + (decimal point) + (digits)
1586             string_type __value;
1587             __value.reserve(2 * __len);
1588
1589             // Add thousands separators to non-decimal digits, per
1590             // grouping rules.
1591             int __paddec = __len - __lc->_M_frac_digits;
1592             if (__paddec > 0)
1593               {
1594                 if (__lc->_M_frac_digits < 0)
1595                   __paddec = __len;
1596                 if (__lc->_M_grouping_size)
1597                   {
1598                     _CharT* __ws =
1599                       static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1600                                                             * 2 * __len));
1601                     _CharT* __ws_end =
1602                       std::__add_grouping(__ws, __lc->_M_thousands_sep,
1603                                           __lc->_M_grouping,
1604                                           __lc->_M_grouping_size,
1605                                           __beg, __beg + __paddec);
1606                     __value.assign(__ws, __ws_end - __ws);
1607                   }
1608                 else
1609                   __value.assign(__beg, __paddec);
1610               }
1611
1612             // Deal with decimal point, decimal digits.
1613             if (__lc->_M_frac_digits > 0)
1614               {
1615                 __value += __lc->_M_decimal_point;
1616                 if (__paddec >= 0)
1617                   __value.append(__beg + __paddec, __lc->_M_frac_digits);
1618                 else
1619                   {
1620                     // Have to pad zeros in the decimal position.
1621                     __value.append(-__paddec, __lit[money_base::_S_zero]);
1622                     __value.append(__beg, __len);
1623                   }
1624               }
1625   
1626             // Calculate length of resulting string.
1627             const ios_base::fmtflags __f = __io.flags() 
1628                                            & ios_base::adjustfield;
1629             __len = __value.size() + __sign_size;
1630             __len += ((__io.flags() & ios_base::showbase)
1631                       ? __lc->_M_curr_symbol_size : 0);
1632
1633             string_type __res;
1634             __res.reserve(2 * __len);
1635             
1636             const size_type __width = static_cast<size_type>(__io.width());  
1637             const bool __testipad = (__f == ios_base::internal
1638                                      && __len < __width);
1639             // Fit formatted digits into the required pattern.
1640             for (int __i = 0; __i < 4; ++__i)
1641               {
1642                 const part __which = static_cast<part>(__p.field[__i]);
1643                 switch (__which)
1644                   {
1645                   case money_base::symbol:
1646                     if (__io.flags() & ios_base::showbase)
1647                       __res.append(__lc->_M_curr_symbol,
1648                                    __lc->_M_curr_symbol_size);
1649                     break;
1650                   case money_base::sign:
1651                     // Sign might not exist, or be more than one
1652                     // charater long. In that case, add in the rest
1653                     // below.
1654                     if (__sign_size)
1655                       __res += __sign[0];
1656                     break;
1657                   case money_base::value:
1658                     __res += __value;
1659                     break;
1660                   case money_base::space:
1661                     // At least one space is required, but if internal
1662                     // formatting is required, an arbitrary number of
1663                     // fill spaces will be necessary.
1664                     if (__testipad)
1665                       __res.append(__width - __len, __fill);
1666                     else
1667                       __res += __fill;
1668                     break;
1669                   case money_base::none:
1670                     if (__testipad)
1671                       __res.append(__width - __len, __fill);
1672                     break;
1673                   }
1674               }
1675             
1676             // Special case of multi-part sign parts.
1677             if (__sign_size > 1)
1678               __res.append(__sign + 1, __sign_size - 1);
1679             
1680             // Pad, if still necessary.
1681             __len = __res.size();
1682             if (__width > __len)
1683               {
1684                 if (__f == ios_base::left)
1685                   // After.
1686                   __res.append(__width - __len, __fill);
1687                 else
1688                   // Before.
1689                   __res.insert(0, __width - __len, __fill);
1690                 __len = __width;
1691               }
1692             
1693             // Write resulting, fully-formatted string to output iterator.
1694             __s = std::__write(__s, __res.data(), __len);
1695           }
1696         __io.width(0);
1697         return __s;    
1698       }
1699   
1700   template<typename _CharT, typename _OutIter>
1701     _OutIter
1702     money_put<_CharT, _OutIter>::
1703     do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
1704            long double __units) const
1705     {
1706       const locale __loc = __io.getloc();
1707       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1708 #ifdef _GLIBCXX_USE_C99
1709       // First try a buffer perhaps big enough.
1710       int __cs_size = 64;
1711       char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1712       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1713       // 328. Bad sprintf format modifier in money_put<>::do_put()
1714       int __len = std::__convert_from_v(__cs, __cs_size, "%.*Lf", __units,
1715                                         _S_get_c_locale(), 0);
1716       // If the buffer was not large enough, try again with the correct size.
1717       if (__len >= __cs_size)
1718         {
1719           __cs_size = __len + 1;
1720           __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1721           __len = std::__convert_from_v(__cs, __cs_size, "%.*Lf", __units,
1722                                         _S_get_c_locale(), 0);
1723         }
1724 #else
1725       // max_exponent10 + 1 for the integer part, + 2 for sign and '\0'.
1726       const int __cs_size = numeric_limits<long double>::max_exponent10 + 3;
1727       char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1728       int __len = std::__convert_from_v(__cs, 0, "%.*Lf", __units,
1729                                         _S_get_c_locale(), 0);
1730 #endif
1731       _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1732                                                            * __cs_size));
1733       __ctype.widen(__cs, __cs + __len, __ws);
1734       const string_type __digits(__ws, __len);
1735       return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
1736                     : _M_insert<false>(__s, __io, __fill, __digits);
1737     }
1738
1739   template<typename _CharT, typename _OutIter>
1740     _OutIter
1741     money_put<_CharT, _OutIter>::
1742     do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
1743            const string_type& __digits) const
1744     { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
1745                     : _M_insert<false>(__s, __io, __fill, __digits); }
1746
1747
1748   // NB: Not especially useful. Without an ios_base object or some
1749   // kind of locale reference, we are left clawing at the air where
1750   // the side of the mountain used to be...
1751   template<typename _CharT, typename _InIter>
1752     time_base::dateorder
1753     time_get<_CharT, _InIter>::do_date_order() const
1754     { return time_base::no_order; }
1755
1756   // Expand a strftime format string and parse it.  E.g., do_get_date() may
1757   // pass %m/%d/%Y => extracted characters.
1758   template<typename _CharT, typename _InIter>
1759     _InIter
1760     time_get<_CharT, _InIter>::
1761     _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
1762                           ios_base::iostate& __err, tm* __tm,
1763                           const _CharT* __format) const
1764     {
1765       const locale& __loc = __io._M_getloc();
1766       const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
1767       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1768       const size_t __len = char_traits<_CharT>::length(__format);
1769
1770       for (size_t __i = 0; __beg != __end && __i < __len && !__err; ++__i)
1771         {
1772           if (__ctype.narrow(__format[__i], 0) == '%')
1773             {
1774               // Verify valid formatting code, attempt to extract.
1775               char __c = __ctype.narrow(__format[++__i], 0);
1776               int __mem = 0;
1777               if (__c == 'E' || __c == 'O')
1778                 __c = __ctype.narrow(__format[++__i], 0);
1779               switch (__c)
1780                 {
1781                   const char* __cs;
1782                   _CharT __wcs[10];
1783                 case 'a':
1784                   // Abbreviated weekday name [tm_wday]
1785                   const char_type*  __days1[7];
1786                   __tp._M_days_abbreviated(__days1);
1787                   __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
1788                                           7, __io, __err);
1789                   break;
1790                 case 'A':
1791                   // Weekday name [tm_wday].
1792                   const char_type*  __days2[7];
1793                   __tp._M_days(__days2);
1794                   __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
1795                                           7, __io, __err);
1796                   break;
1797                 case 'h':
1798                 case 'b':
1799                   // Abbreviated month name [tm_mon]
1800                   const char_type*  __months1[12];
1801                   __tp._M_months_abbreviated(__months1);
1802                   __beg = _M_extract_name(__beg, __end, __tm->tm_mon, 
1803                                           __months1, 12, __io, __err);
1804                   break;
1805                 case 'B':
1806                   // Month name [tm_mon].
1807                   const char_type*  __months2[12];
1808                   __tp._M_months(__months2);
1809                   __beg = _M_extract_name(__beg, __end, __tm->tm_mon, 
1810                                           __months2, 12, __io, __err);
1811                   break;
1812                 case 'c':
1813                   // Default time and date representation.
1814                   const char_type*  __dt[2];
1815                   __tp._M_date_time_formats(__dt);
1816                   __beg = _M_extract_via_format(__beg, __end, __io, __err, 
1817                                                 __tm, __dt[0]);
1818                   break;
1819                 case 'd':
1820                   // Day [01, 31]. [tm_mday]
1821                   __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
1822                                          __io, __err);
1823                   break;
1824                 case 'e':
1825                   // Day [1, 31], with single digits preceded by
1826                   // space. [tm_mday]
1827                   if (__ctype.is(ctype_base::space, *__beg))
1828                     __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
1829                                            1, __io, __err);
1830                   else
1831                     __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
1832                                            2, __io, __err);
1833                   break;
1834                 case 'D':
1835                   // Equivalent to %m/%d/%y.[tm_mon, tm_mday, tm_year]
1836                   __cs = "%m/%d/%y";
1837                   __ctype.widen(__cs, __cs + 9, __wcs);
1838                   __beg = _M_extract_via_format(__beg, __end, __io, __err, 
1839                                                 __tm, __wcs);
1840                   break;
1841                 case 'H':
1842                   // Hour [00, 23]. [tm_hour]
1843                   __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
1844                                          __io, __err);
1845                   break;
1846                 case 'I':
1847                   // Hour [01, 12]. [tm_hour]
1848                   __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
1849                                          __io, __err);
1850                   break;
1851                 case 'm':
1852                   // Month [01, 12]. [tm_mon]
1853                   __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2, 
1854                                          __io, __err);
1855                   if (!__err)
1856                     __tm->tm_mon = __mem - 1;
1857                   break;
1858                 case 'M':
1859                   // Minute [00, 59]. [tm_min]
1860                   __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
1861                                          __io, __err);
1862                   break;
1863                 case 'n':
1864                   if (__ctype.narrow(*__beg, 0) == '\n')
1865                     ++__beg;
1866                   else
1867                     __err |= ios_base::failbit;
1868                   break;
1869                 case 'R':
1870                   // Equivalent to (%H:%M).
1871                   __cs = "%H:%M";
1872                   __ctype.widen(__cs, __cs + 6, __wcs);
1873                   __beg = _M_extract_via_format(__beg, __end, __io, __err, 
1874                                                 __tm, __wcs);
1875                   break;
1876                 case 'S':
1877                   // Seconds. [tm_sec]
1878                   // [00, 60] in C99 (one leap-second), [00, 61] in C89.
1879 #ifdef _GLIBCXX_USE_C99
1880                   __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
1881 #else
1882                   __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 61, 2,
1883 #endif
1884                                          __io, __err);
1885                   break;
1886                 case 't':
1887                   if (__ctype.narrow(*__beg, 0) == '\t')
1888                     ++__beg;
1889                   else
1890                     __err |= ios_base::failbit;
1891                   break;
1892                 case 'T':
1893                   // Equivalent to (%H:%M:%S).
1894                   __cs = "%H:%M:%S";
1895                   __ctype.widen(__cs, __cs + 9, __wcs);
1896                   __beg = _M_extract_via_format(__beg, __end, __io, __err, 
1897                                                 __tm, __wcs);
1898                   break;
1899                 case 'x':
1900                   // Locale's date.
1901                   const char_type*  __dates[2];
1902                   __tp._M_date_formats(__dates);
1903                   __beg = _M_extract_via_format(__beg, __end, __io, __err, 
1904                                                 __tm, __dates[0]);
1905                   break;
1906                 case 'X':
1907                   // Locale's time.
1908                   const char_type*  __times[2];
1909                   __tp._M_time_formats(__times);
1910                   __beg = _M_extract_via_format(__beg, __end, __io, __err, 
1911                                                 __tm, __times[0]);
1912                   break;
1913                 case 'y':
1914                 case 'C': // C99
1915                   // Two digit year. [tm_year]
1916                   __beg = _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2,
1917                                          __io, __err);
1918                   break;
1919                 case 'Y':
1920                   // Year [1900). [tm_year]
1921                   __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
1922                                          __io, __err);
1923                   if (!__err)
1924                     __tm->tm_year = __mem - 1900;
1925                   break;
1926                 case 'Z':
1927                   // Timezone info.
1928                   if (__ctype.is(ctype_base::upper, *__beg))
1929                     {
1930                       int __tmp;
1931                       __beg = _M_extract_name(__beg, __end, __tmp,
1932                                        __timepunct_cache<_CharT>::_S_timezones,
1933                                               14, __io, __err);
1934
1935                       // GMT requires special effort.
1936                       if (__beg != __end && !__err && __tmp == 0
1937                           && (*__beg == __ctype.widen('-')
1938                               || *__beg == __ctype.widen('+')))
1939                         {
1940                           __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
1941                                                  __io, __err);
1942                           __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
1943                                                  __io, __err);
1944                         }
1945                     }
1946                   else
1947                     __err |= ios_base::failbit;
1948                   break;
1949                 default:
1950                   // Not recognized.
1951                   __err |= ios_base::failbit;
1952                 }
1953             }
1954           else
1955             {
1956               // Verify format and input match, extract and discard.
1957               if (__format[__i] == *__beg)
1958                 ++__beg;
1959               else
1960                 __err |= ios_base::failbit;
1961             }
1962         }
1963       return __beg;
1964     }
1965
1966   template<typename _CharT, typename _InIter>
1967     _InIter
1968     time_get<_CharT, _InIter>::
1969     _M_extract_num(iter_type __beg, iter_type __end, int& __member,
1970                    int __min, int __max, size_t __len,
1971                    ios_base& __io, ios_base::iostate& __err) const
1972     {
1973       const locale& __loc = __io._M_getloc();
1974       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1975
1976       // As-is works for __len = 1, 2, 4, the values actually used.
1977       int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
1978
1979       ++__min;
1980       size_t __i = 0;
1981       int __value = 0;
1982       for (; __beg != __end && __i < __len; ++__beg, ++__i)
1983         {
1984           const char __c = __ctype.narrow(*__beg, '*');
1985           if (__c >= '0' && __c <= '9')
1986             {
1987               __value = __value * 10 + (__c - '0');
1988               const int __valuec = __value * __mult;
1989               if (__valuec > __max || __valuec + __mult < __min)
1990                 break;
1991               __mult /= 10;
1992             }
1993           else
1994             break;
1995         }
1996       if (__i == __len)
1997         __member = __value;
1998       else
1999         __err |= ios_base::failbit;
2000       return __beg;
2001     }
2002
2003   // Assumptions:
2004   // All elements in __names are unique.
2005   template<typename _CharT, typename _InIter>
2006     _InIter
2007     time_get<_CharT, _InIter>::
2008     _M_extract_name(iter_type __beg, iter_type __end, int& __member,
2009                     const _CharT** __names, size_t __indexlen,
2010                     ios_base& __io, ios_base::iostate& __err) const
2011     {
2012       typedef char_traits<_CharT>               __traits_type;
2013       const locale& __loc = __io._M_getloc();
2014       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2015
2016       int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
2017                                                           * __indexlen));
2018       size_t __nmatches = 0;
2019       size_t __pos = 0;
2020       bool __testvalid = true;
2021       const char_type* __name;
2022
2023       // Look for initial matches.
2024       // NB: Some of the locale data is in the form of all lowercase
2025       // names, and some is in the form of initially-capitalized
2026       // names. Look for both.
2027       if (__beg != __end)
2028         {
2029           const char_type __c = *__beg;
2030           for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
2031             if (__c == __names[__i1][0]
2032                 || __c == __ctype.toupper(__names[__i1][0]))
2033               __matches[__nmatches++] = __i1;
2034         }
2035
2036       while (__nmatches > 1)
2037         {
2038           // Find smallest matching string.
2039           size_t __minlen = __traits_type::length(__names[__matches[0]]);
2040           for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
2041             __minlen = std::min(__minlen,
2042                               __traits_type::length(__names[__matches[__i2]]));
2043           ++__beg, ++__pos;
2044           if (__pos < __minlen && __beg != __end)
2045             for (size_t __i3 = 0; __i3 < __nmatches;)
2046               {
2047                 __name = __names[__matches[__i3]];
2048                 if (__name[__pos] != *__beg)
2049                   __matches[__i3] = __matches[--__nmatches];
2050                 else
2051                   ++__i3;
2052               }
2053           else
2054             break;
2055         }
2056
2057       if (__nmatches == 1)
2058         {
2059           // Make sure found name is completely extracted.
2060           ++__beg, ++__pos;
2061           __name = __names[__matches[0]];
2062           const size_t __len = __traits_type::length(__name);
2063           while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
2064             ++__beg, ++__pos;
2065
2066           if (__len == __pos)
2067             __member = __matches[0];
2068           else
2069             __testvalid = false;
2070         }
2071       else
2072         __testvalid = false;
2073       if (!__testvalid)
2074         __err |= ios_base::failbit;
2075       return __beg;
2076     }
2077
2078   template<typename _CharT, typename _InIter>
2079     _InIter
2080     time_get<_CharT, _InIter>::
2081     do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
2082                 ios_base::iostate& __err, tm* __tm) const
2083     {
2084       const locale& __loc = __io._M_getloc();
2085       const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
2086       const char_type*  __times[2];
2087       __tp._M_time_formats(__times);
2088       __beg = _M_extract_via_format(__beg, __end, __io, __err, 
2089                                     __tm, __times[0]);
2090       if (__beg == __end)
2091         __err |= ios_base::eofbit;
2092       return __beg;
2093     }
2094
2095   template<typename _CharT, typename _InIter>
2096     _InIter
2097     time_get<_CharT, _InIter>::
2098     do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
2099                 ios_base::iostate& __err, tm* __tm) const
2100     {
2101       const locale& __loc = __io._M_getloc();
2102       const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
2103       const char_type*  __dates[2];
2104       __tp._M_date_formats(__dates);
2105       __beg = _M_extract_via_format(__beg, __end, __io, __err, 
2106                                     __tm, __dates[0]);
2107       if (__beg == __end)
2108         __err |= ios_base::eofbit;
2109       return __beg;
2110     }
2111
2112   template<typename _CharT, typename _InIter>
2113     _InIter
2114     time_get<_CharT, _InIter>::
2115     do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
2116                    ios_base::iostate& __err, tm* __tm) const
2117     {
2118       typedef char_traits<_CharT>               __traits_type;
2119       const locale& __loc = __io._M_getloc();
2120       const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
2121       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2122       const char_type*  __days[7];
2123       __tp._M_days_abbreviated(__days);
2124       int __tmpwday;
2125       __beg = _M_extract_name(__beg, __end, __tmpwday, __days, 7, __io, __err);
2126
2127       // Check to see if non-abbreviated name exists, and extract.
2128       // NB: Assumes both _M_days and _M_days_abbreviated organized in
2129       // exact same order, first to last, such that the resulting
2130       // __days array with the same index points to a day, and that
2131       // day's abbreviated form.
2132       // NB: Also assumes that an abbreviated name is a subset of the name.
2133       if (!__err && __beg != __end)
2134         {
2135           size_t __pos = __traits_type::length(__days[__tmpwday]);
2136           __tp._M_days(__days);
2137           const char_type* __name = __days[__tmpwday];
2138           if (__name[__pos] == *__beg)
2139             {
2140               // Extract the rest of it.
2141               const size_t __len = __traits_type::length(__name);
2142               while (__pos < __len && __beg != __end
2143                      && __name[__pos] == *__beg)
2144                 ++__beg, ++__pos;
2145               if (__len != __pos)
2146                 __err |= ios_base::failbit;
2147             }
2148         }
2149       if (!__err)
2150         __tm->tm_wday = __tmpwday;
2151       
2152       if (__beg == __end)
2153         __err |= ios_base::eofbit;
2154       return __beg;
2155      }
2156
2157   template<typename _CharT, typename _InIter>
2158     _InIter
2159     time_get<_CharT, _InIter>::
2160     do_get_monthname(iter_type __beg, iter_type __end,
2161                      ios_base& __io, ios_base::iostate& __err, tm* __tm) const
2162     {
2163       typedef char_traits<_CharT>               __traits_type;
2164       const locale& __loc = __io._M_getloc();
2165       const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
2166       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2167       const char_type*  __months[12];
2168       __tp._M_months_abbreviated(__months);
2169       int __tmpmon;
2170       __beg = _M_extract_name(__beg, __end, __tmpmon, __months, 12, 
2171                               __io, __err);
2172
2173       // Check to see if non-abbreviated name exists, and extract.
2174       // NB: Assumes both _M_months and _M_months_abbreviated organized in
2175       // exact same order, first to last, such that the resulting
2176       // __months array with the same index points to a month, and that
2177       // month's abbreviated form.
2178       // NB: Also assumes that an abbreviated name is a subset of the name.
2179       if (!__err && __beg != __end)
2180         {
2181           size_t __pos = __traits_type::length(__months[__tmpmon]);
2182           __tp._M_months(__months);
2183           const char_type* __name = __months[__tmpmon];
2184           if (__name[__pos] == *__beg)
2185             {
2186               // Extract the rest of it.
2187               const size_t __len = __traits_type::length(__name);
2188               while (__pos < __len && __beg != __end
2189                      && __name[__pos] == *__beg)
2190                 ++__beg, ++__pos;
2191               if (__len != __pos)
2192                 __err |= ios_base::failbit;
2193             }
2194         }
2195       if (!__err)
2196         __tm->tm_mon = __tmpmon;
2197
2198       if (__beg == __end)
2199         __err |= ios_base::eofbit;
2200       return __beg;
2201     }
2202
2203   template<typename _CharT, typename _InIter>
2204     _InIter
2205     time_get<_CharT, _InIter>::
2206     do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
2207                 ios_base::iostate& __err, tm* __tm) const
2208     {
2209       const locale& __loc = __io._M_getloc();
2210       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2211
2212       size_t __i = 0;
2213       int __value = 0;
2214       for (; __beg != __end && __i < 4; ++__beg, ++__i)
2215         {
2216           const char __c = __ctype.narrow(*__beg, '*');
2217           if (__c >= '0' && __c <= '9')
2218             __value = __value * 10 + (__c - '0');
2219           else
2220             break;
2221         }
2222       if (__i == 2 || __i == 4)
2223         __tm->tm_year = __i == 2 ? __value : __value - 1900;
2224       else
2225         __err |= ios_base::failbit;
2226       if (__beg == __end)
2227         __err |= ios_base::eofbit;
2228       return __beg;
2229     }
2230
2231   template<typename _CharT, typename _OutIter>
2232     _OutIter
2233     time_put<_CharT, _OutIter>::
2234     put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
2235         const _CharT* __beg, const _CharT* __end) const
2236     {
2237       const locale& __loc = __io._M_getloc();
2238       ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
2239       for (; __beg != __end; ++__beg)
2240         if (__ctype.narrow(*__beg, 0) != '%')
2241           {
2242             *__s = *__beg;
2243             ++__s;
2244           }
2245         else if (++__beg != __end)
2246           {
2247             char __format;
2248             char __mod = 0;
2249             const char __c = __ctype.narrow(*__beg, 0);
2250             if (__c != 'E' && __c != 'O')
2251               __format = __c;
2252             else if (++__beg != __end)
2253               {
2254                 __mod = __c;
2255                 __format = __ctype.narrow(*__beg, 0);
2256               }
2257             else
2258               break;
2259             __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
2260           }
2261         else
2262           break;
2263       return __s;
2264     }
2265
2266   template<typename _CharT, typename _OutIter>
2267     _OutIter
2268     time_put<_CharT, _OutIter>::
2269     do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
2270            char __format, char __mod) const
2271     {
2272       const locale& __loc = __io._M_getloc();
2273       ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
2274       __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
2275
2276       // NB: This size is arbitrary. Should this be a data member,
2277       // initialized at construction?
2278       const size_t __maxlen = 128;
2279       char_type* __res = 
2280        static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __maxlen));
2281
2282       // NB: In IEE 1003.1-200x, and perhaps other locale models, it
2283       // is possible that the format character will be longer than one
2284       // character. Possibilities include 'E' or 'O' followed by a
2285       // format character: if __mod is not the default argument, assume
2286       // it's a valid modifier.
2287       char_type __fmt[4];
2288       __fmt[0] = __ctype.widen('%');
2289       if (!__mod)
2290         {
2291           __fmt[1] = __format;
2292           __fmt[2] = char_type();
2293         }
2294       else
2295         {
2296           __fmt[1] = __mod;
2297           __fmt[2] = __format;
2298           __fmt[3] = char_type();
2299         }
2300
2301       __tp._M_put(__res, __maxlen, __fmt, __tm);
2302
2303       // Write resulting, fully-formatted string to output iterator.
2304       return std::__write(__s, __res, char_traits<char_type>::length(__res));
2305     }
2306
2307   // Generic version does nothing.
2308   template<typename _CharT>
2309     int
2310     collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const
2311     { return 0; }
2312
2313   // Generic version does nothing.
2314   template<typename _CharT>
2315     size_t
2316     collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const
2317     { return 0; }
2318
2319   template<typename _CharT>
2320     int
2321     collate<_CharT>::
2322     do_compare(const _CharT* __lo1, const _CharT* __hi1,
2323                const _CharT* __lo2, const _CharT* __hi2) const
2324     {
2325       // strcoll assumes zero-terminated strings so we make a copy
2326       // and then put a zero at the end.
2327       const string_type __one(__lo1, __hi1);
2328       const string_type __two(__lo2, __hi2);
2329
2330       const _CharT* __p = __one.c_str();
2331       const _CharT* __pend = __one.data() + __one.length();
2332       const _CharT* __q = __two.c_str();
2333       const _CharT* __qend = __two.data() + __two.length();
2334
2335       // strcoll stops when it sees a nul character so we break
2336       // the strings into zero-terminated substrings and pass those
2337       // to strcoll.
2338       for (;;)
2339         {
2340           const int __res = _M_compare(__p, __q);
2341           if (__res)
2342             return __res;
2343
2344           __p += char_traits<_CharT>::length(__p);
2345           __q += char_traits<_CharT>::length(__q);
2346           if (__p == __pend && __q == __qend)
2347             return 0;
2348           else if (__p == __pend)
2349             return -1;
2350           else if (__q == __qend)
2351             return 1;
2352
2353           __p++;
2354           __q++;
2355         }
2356     }
2357
2358   template<typename _CharT>
2359     typename collate<_CharT>::string_type
2360     collate<_CharT>::
2361     do_transform(const _CharT* __lo, const _CharT* __hi) const
2362     {
2363       // strxfrm assumes zero-terminated strings so we make a copy
2364       string_type __str(__lo, __hi);
2365
2366       const _CharT* __p = __str.c_str();
2367       const _CharT* __pend = __str.data() + __str.length();
2368
2369       size_t __len = (__hi - __lo) * 2;
2370
2371       string_type __ret;
2372
2373       // strxfrm stops when it sees a nul character so we break
2374       // the string into zero-terminated substrings and pass those
2375       // to strxfrm.
2376       for (;;)
2377         {
2378           // First try a buffer perhaps big enough.
2379           _CharT* __c =
2380             static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len));
2381           size_t __res = _M_transform(__c, __p, __len);
2382           // If the buffer was not large enough, try again with the
2383           // correct size.
2384           if (__res >= __len)
2385             {
2386               __len = __res + 1;
2387               __c = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
2388                                                           * __len));
2389               __res = _M_transform(__c, __p, __len);
2390             }
2391
2392           __ret.append(__c, __res);
2393           __p += char_traits<_CharT>::length(__p);
2394           if (__p == __pend)
2395             return __ret;
2396
2397           __p++;
2398           __ret.push_back(_CharT());
2399         }
2400     }
2401
2402   template<typename _CharT>
2403     long
2404     collate<_CharT>::
2405     do_hash(const _CharT* __lo, const _CharT* __hi) const
2406     {
2407       unsigned long __val = 0;
2408       for (; __lo < __hi; ++__lo)
2409         __val = *__lo + ((__val << 7) |
2410                        (__val >> (numeric_limits<unsigned long>::digits - 7)));
2411       return static_cast<long>(__val);
2412     }
2413
2414   // Construct correctly padded string, as per 22.2.2.2.2
2415   // Assumes
2416   // __newlen > __oldlen
2417   // __news is allocated for __newlen size
2418   // Used by both num_put and ostream inserters: if __num,
2419   // internal-adjusted objects are padded according to the rules below
2420   // concerning 0[xX] and +-, otherwise, exactly as right-adjusted
2421   // ones are.
2422
2423   // NB: Of the two parameters, _CharT can be deduced from the
2424   // function arguments. The other (_Traits) has to be explicitly specified.
2425   template<typename _CharT, typename _Traits>
2426     void
2427     __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
2428                                    _CharT* __news, const _CharT* __olds,
2429                                    const streamsize __newlen,
2430                                    const streamsize __oldlen, const bool __num)
2431     {
2432       const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
2433       const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
2434
2435       // Padding last.
2436       if (__adjust == ios_base::left)
2437         {
2438           _Traits::copy(__news, const_cast<_CharT*>(__olds), __oldlen);
2439           _Traits::assign(__news + __oldlen, __plen, __fill);
2440           return;
2441         }
2442
2443       size_t __mod = 0;
2444       if (__adjust == ios_base::internal && __num)
2445         {
2446           // Pad after the sign, if there is one.
2447           // Pad after 0[xX], if there is one.
2448           // Who came up with these rules, anyway? Jeeze.
2449           const locale& __loc = __io._M_getloc();
2450           const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2451
2452           const bool __testsign = (__ctype.widen('-') == __olds[0]
2453                                    || __ctype.widen('+') == __olds[0]);
2454           const bool __testhex = (__ctype.widen('0') == __olds[0]
2455                                   && __oldlen > 1
2456                                   && (__ctype.widen('x') == __olds[1]
2457                                       || __ctype.widen('X') == __olds[1]));
2458           if (__testhex)
2459             {
2460               __news[0] = __olds[0];
2461               __news[1] = __olds[1];
2462               __mod = 2;
2463               __news += 2;
2464             }
2465           else if (__testsign)
2466             {
2467               __news[0] = __olds[0];
2468               __mod = 1;
2469               ++__news;
2470             }
2471           // else Padding first.
2472         }
2473       _Traits::assign(__news, __plen, __fill);
2474       _Traits::copy(__news + __plen, const_cast<_CharT*>(__olds + __mod),
2475                     __oldlen - __mod);
2476     }
2477
2478   bool
2479   __verify_grouping(const char* __grouping, size_t __grouping_size,
2480                     const string& __grouping_tmp)
2481   {
2482     const size_t __n = __grouping_tmp.size() - 1;
2483     const size_t __min = std::min(__n, size_t(__grouping_size - 1));
2484     size_t __i = __n;
2485     bool __test = true;
2486     
2487     // Parsed number groupings have to match the
2488     // numpunct::grouping string exactly, starting at the
2489     // right-most point of the parsed sequence of elements ...
2490     for (size_t __j = 0; __j < __min && __test; --__i, ++__j)
2491       __test = __grouping_tmp[__i] == __grouping[__j];
2492     for (; __i && __test; --__i)
2493       __test = __grouping_tmp[__i] == __grouping[__min];
2494     // ... but the last parsed grouping can be <= numpunct
2495     // grouping.
2496     __test &= __grouping_tmp[0] <= __grouping[__min];
2497     return __test;
2498   }
2499
2500   template<typename _CharT>
2501     _CharT*
2502     __add_grouping(_CharT* __s, _CharT __sep,
2503                    const char* __gbeg, size_t __gsize,
2504                    const _CharT* __first, const _CharT* __last)
2505     {
2506       if (__last - __first > *__gbeg)
2507         {
2508           const bool __bump = __gsize != 1;
2509           __s = std::__add_grouping(__s,  __sep, __gbeg + __bump,
2510                                     __gsize - __bump, __first,
2511                                     __last - *__gbeg);
2512           __first = __last - *__gbeg;
2513           *__s++ = __sep;
2514         }
2515       do
2516         *__s++ = *__first++;
2517       while (__first != __last);
2518       return __s;
2519     }
2520
2521   // Inhibit implicit instantiations for required instantiations,
2522   // which are defined via explicit instantiations elsewhere.
2523   // NB: This syntax is a GNU extension.
2524 #if _GLIBCXX_EXTERN_TEMPLATE
2525   extern template class moneypunct<char, false>;
2526   extern template class moneypunct<char, true>;
2527   extern template class moneypunct_byname<char, false>;
2528   extern template class moneypunct_byname<char, true>;
2529   extern template class money_get<char>;
2530   extern template class money_put<char>;
2531   extern template class numpunct<char>;
2532   extern template class numpunct_byname<char>;
2533   extern template class num_get<char>;
2534   extern template class num_put<char>;
2535   extern template class __timepunct<char>;
2536   extern template class time_put<char>;
2537   extern template class time_put_byname<char>;
2538   extern template class time_get<char>;
2539   extern template class time_get_byname<char>;
2540   extern template class messages<char>;
2541   extern template class messages_byname<char>;
2542   extern template class ctype_byname<char>;
2543   extern template class codecvt_byname<char, char, mbstate_t>;
2544   extern template class collate<char>;
2545   extern template class collate_byname<char>;
2546
2547   extern template
2548     const codecvt<char, char, mbstate_t>&
2549     use_facet<codecvt<char, char, mbstate_t> >(const locale&);
2550
2551   extern template
2552     const collate<char>&
2553     use_facet<collate<char> >(const locale&);
2554
2555   extern template
2556     const numpunct<char>&
2557     use_facet<numpunct<char> >(const locale&);
2558
2559   extern template
2560     const num_put<char>&
2561     use_facet<num_put<char> >(const locale&);
2562
2563   extern template
2564     const num_get<char>&
2565     use_facet<num_get<char> >(const locale&);
2566
2567   extern template
2568     const moneypunct<char, true>&
2569     use_facet<moneypunct<char, true> >(const locale&);
2570
2571   extern template
2572     const moneypunct<char, false>&
2573     use_facet<moneypunct<char, false> >(const locale&);
2574
2575   extern template
2576     const money_put<char>&
2577     use_facet<money_put<char> >(const locale&);
2578
2579   extern template
2580     const money_get<char>&
2581     use_facet<money_get<char> >(const locale&);
2582
2583   extern template
2584     const __timepunct<char>&
2585     use_facet<__timepunct<char> >(const locale&);
2586
2587   extern template
2588     const time_put<char>&
2589     use_facet<time_put<char> >(const locale&);
2590
2591   extern template
2592     const time_get<char>&
2593     use_facet<time_get<char> >(const locale&);
2594
2595   extern template
2596     const messages<char>&
2597     use_facet<messages<char> >(const locale&);
2598
2599   extern template
2600     bool
2601     has_facet<ctype<char> >(const locale&);
2602
2603   extern template
2604     bool
2605     has_facet<codecvt<char, char, mbstate_t> >(const locale&);
2606
2607   extern template
2608     bool
2609     has_facet<collate<char> >(const locale&);
2610
2611   extern template
2612     bool
2613     has_facet<numpunct<char> >(const locale&);
2614
2615   extern template
2616     bool
2617     has_facet<num_put<char> >(const locale&);
2618
2619   extern template
2620     bool
2621     has_facet<num_get<char> >(const locale&);
2622
2623   extern template
2624     bool
2625     has_facet<moneypunct<char> >(const locale&);
2626
2627   extern template
2628     bool
2629     has_facet<money_put<char> >(const locale&);
2630
2631   extern template
2632     bool
2633     has_facet<money_get<char> >(const locale&);
2634
2635   extern template
2636     bool
2637     has_facet<__timepunct<char> >(const locale&);
2638
2639   extern template
2640     bool
2641     has_facet<time_put<char> >(const locale&);
2642
2643   extern template
2644     bool
2645     has_facet<time_get<char> >(const locale&);
2646
2647   extern template
2648     bool
2649     has_facet<messages<char> >(const locale&);
2650
2651 #ifdef _GLIBCXX_USE_WCHAR_T
2652   extern template class moneypunct<wchar_t, false>;
2653   extern template class moneypunct<wchar_t, true>;
2654   extern template class moneypunct_byname<wchar_t, false>;
2655   extern template class moneypunct_byname<wchar_t, true>;
2656   extern template class money_get<wchar_t>;
2657   extern template class money_put<wchar_t>;
2658   extern template class numpunct<wchar_t>;
2659   extern template class numpunct_byname<wchar_t>;
2660   extern template class num_get<wchar_t>;
2661   extern template class num_put<wchar_t>;
2662   extern template class __timepunct<wchar_t>;
2663   extern template class time_put<wchar_t>;
2664   extern template class time_put_byname<wchar_t>;
2665   extern template class time_get<wchar_t>;
2666   extern template class time_get_byname<wchar_t>;
2667   extern template class messages<wchar_t>;
2668   extern template class messages_byname<wchar_t>;
2669   extern template class ctype_byname<wchar_t>;
2670   extern template class codecvt_byname<wchar_t, char, mbstate_t>;
2671   extern template class collate<wchar_t>;
2672   extern template class collate_byname<wchar_t>;
2673
2674   extern template
2675     const codecvt<wchar_t, char, mbstate_t>&
2676     use_facet<codecvt<wchar_t, char, mbstate_t> >(locale const&);
2677
2678   extern template
2679     const collate<wchar_t>&
2680     use_facet<collate<wchar_t> >(const locale&);
2681
2682   extern template
2683     const numpunct<wchar_t>&
2684     use_facet<numpunct<wchar_t> >(const locale&);
2685
2686   extern template
2687     const num_put<wchar_t>&
2688     use_facet<num_put<wchar_t> >(const locale&);
2689
2690   extern template
2691     const num_get<wchar_t>&
2692     use_facet<num_get<wchar_t> >(const locale&);
2693
2694   extern template
2695     const moneypunct<wchar_t, true>&
2696     use_facet<moneypunct<wchar_t, true> >(const locale&);
2697
2698   extern template
2699     const moneypunct<wchar_t, false>&
2700     use_facet<moneypunct<wchar_t, false> >(const locale&);
2701
2702   extern template
2703     const money_put<wchar_t>&
2704     use_facet<money_put<wchar_t> >(const locale&);
2705
2706   extern template
2707     const money_get<wchar_t>&
2708     use_facet<money_get<wchar_t> >(const locale&);
2709
2710   extern template
2711     const __timepunct<wchar_t>&
2712     use_facet<__timepunct<wchar_t> >(const locale&);
2713
2714   extern template
2715     const time_put<wchar_t>&
2716     use_facet<time_put<wchar_t> >(const locale&);
2717
2718   extern template
2719     const time_get<wchar_t>&
2720     use_facet<time_get<wchar_t> >(const locale&);
2721
2722   extern template
2723     const messages<wchar_t>&
2724     use_facet<messages<wchar_t> >(const locale&);
2725
2726  extern template
2727     bool
2728     has_facet<ctype<wchar_t> >(const locale&);
2729
2730   extern template
2731     bool
2732     has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
2733
2734   extern template
2735     bool
2736     has_facet<collate<wchar_t> >(const locale&);
2737
2738   extern template
2739     bool
2740     has_facet<numpunct<wchar_t> >(const locale&);
2741
2742   extern template
2743     bool
2744     has_facet<num_put<wchar_t> >(const locale&);
2745
2746   extern template
2747     bool
2748     has_facet<num_get<wchar_t> >(const locale&);
2749
2750   extern template
2751     bool
2752     has_facet<moneypunct<wchar_t> >(const locale&);
2753
2754   extern template
2755     bool
2756     has_facet<money_put<wchar_t> >(const locale&);
2757
2758   extern template
2759     bool
2760     has_facet<money_get<wchar_t> >(const locale&);
2761
2762   extern template
2763     bool
2764     has_facet<__timepunct<wchar_t> >(const locale&);
2765
2766   extern template
2767     bool
2768     has_facet<time_put<wchar_t> >(const locale&);
2769
2770   extern template
2771     bool
2772     has_facet<time_get<wchar_t> >(const locale&);
2773
2774   extern template
2775     bool
2776     has_facet<messages<wchar_t> >(const locale&);
2777 #endif
2778 #endif
2779 } // namespace std
2780
2781 #endif