OSDN Git Service

083cb63c5ad818824117cb6e39870d384b65833e
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / bits / locale_facets.tcc
1 // Locale support -*- C++ -*-
2
3 // Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library.  This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 2, or (at your option)
9 // any later version.
10
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 // GNU General Public License for more details.
15
16 // You should have received a copy of the GNU General Public License along
17 // with this library; see the file COPYING.  If not, write to the Free
18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
19 // USA.
20
21 // As a special exception, you may use this file as part of a free software
22 // library without restriction.  Specifically, if other files instantiate
23 // templates or use macros or inline functions from this file, or you compile
24 // this file and link it with other files to produce an executable, this
25 // file does not by itself cause the resulting executable to be covered by
26 // the GNU General Public License.  This exception does not however
27 // invalidate any other reasons why the executable file might be covered by
28 // the GNU General Public License.
29
30 // Warning: this file is not meant for user inclusion.  Use <locale>.
31
32 #ifndef _CPP_BITS_LOCFACETS_TCC
33 #define _CPP_BITS_LOCFACETS_TCC 1
34
35 #include <cerrno>
36 #include <clocale>   // For localeconv
37 #include <cstdlib>   // For strof, strtold
38 #include <cmath>     // For ceil
39 #include <cctype>    // For isspace
40 #include <limits>    // For numeric_limits
41 #include <memory>    // For auto_ptr
42 #include <bits/streambuf_iterator.h>     // For streambuf_iterators
43 #include <typeinfo>             // For bad_cast
44 #include <vector>       
45
46 namespace std
47 {
48   template<typename _Facet>
49     locale
50     locale::combine(const locale& __other) const
51     {
52       _Impl* __tmp = new _Impl(*_M_impl, 1);
53       __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
54       return locale(__tmp);
55     }
56
57   template<typename _CharT, typename _Traits, typename _Alloc>
58     bool
59     locale::operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
60                        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
61     {
62       typedef std::collate<_CharT> __collate_type;
63       const __collate_type& __collate = use_facet<__collate_type>(*this);
64       return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
65                                 __s2.data(), __s2.data() + __s2.length()) < 0);
66     }
67
68   template<typename _Facet>
69     const _Facet&
70     use_facet(const locale& __loc)
71     {
72       size_t __i = _Facet::id._M_index;
73       locale::_Impl::__vec_facet* __facet = __loc._M_impl->_M_facets;
74       const locale::facet* __fp = (*__facet)[__i]; 
75       if (__fp == 0 || __i >= __facet->size())
76         __throw_bad_cast();
77       return static_cast<const _Facet&>(*__fp);
78     }
79
80   template<typename _Facet>
81     bool
82     has_facet(const locale& __loc) throw()
83     {
84       size_t __i = _Facet::id._M_index;
85       locale::_Impl::__vec_facet* __facet = __loc._M_impl->_M_facets;
86       return (__i < __facet->size() && (*__facet)[__i] != 0);
87     }
88
89
90   template<typename _CharT, typename _InIter>
91     _InIter
92     num_get<_CharT, _InIter>::
93     _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
94                      ios_base::iostate& __err, string& __xtrc) const
95     {
96       const locale __loc = __io.getloc();
97       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
98       const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
99
100       // Check first for sign.
101       const char_type __plus = __ctype.widen('+');
102       const char_type __minus = __ctype.widen('-');
103       int __pos = 0;
104       char_type  __c = *__beg;
105       if ((__c == __plus || __c == __minus) && __beg != __end)
106         {
107           __xtrc += __ctype.narrow(__c, char());
108           ++__pos;
109           __c = *(++__beg);
110         }
111
112       // Next, strip leading zeros.
113       const char_type __zero = __ctype.widen(_S_atoms[_M_zero]);
114       bool __found_zero = false;
115       while (__c == __zero && __beg != __end)
116         {
117           __c = *(++__beg);
118           __found_zero = true;
119         }
120       if (__found_zero)
121         {
122           __xtrc += _S_atoms[_M_zero];
123           ++__pos;
124         }
125
126       // Only need acceptable digits for floating point numbers.
127       const size_t __len = _M_E - _M_zero + 1;
128       char_type  __watoms[__len];
129       __ctype.widen(_S_atoms, _S_atoms + __len, __watoms);
130       bool __found_dec = false;
131       bool __found_sci = false;
132       const char_type __dec = __np.decimal_point();
133
134       string __found_grouping;
135       const string __grouping = __np.grouping();
136       bool __check_grouping = __grouping.size();
137       int __sep_pos = 0;
138       const char_type __sep = __np.thousands_sep();
139
140       while (__beg != __end)
141         {
142           // Only look in digits.
143           typedef char_traits<_CharT>   __traits_type;
144           const char_type* __p = __traits_type::find(__watoms, 10,  __c);
145
146           // NB: strchr returns true for __c == 0x0
147           if (__p && __c)
148             {
149               // Try first for acceptable digit; record it if found.
150               ++__pos;
151               __xtrc += _S_atoms[__p - __watoms];
152               ++__sep_pos;
153               __c = *(++__beg);
154             }
155           else if (__c == __sep && __check_grouping && !__found_dec)
156             {
157               // NB: Thousands separator at the beginning of a string
158               // is a no-no, as is two consecutive thousands separators.
159               if (__sep_pos)
160                 {
161                   __found_grouping += static_cast<char>(__sep_pos);
162                   __sep_pos = 0;
163                   __c = *(++__beg);
164                 }
165               else
166                 {
167                   __err |= ios_base::failbit;
168                   break;
169                 }
170             }
171           else if (__c == __dec && !__found_dec)
172             {
173               __found_grouping += static_cast<char>(__sep_pos);
174               ++__pos;
175               __xtrc += '.';
176               __c = *(++__beg);
177               __found_dec = true;
178             }
179           else if ((__c == __watoms[_M_e] || __c == __watoms[_M_E]) 
180                    && !__found_sci && __pos)
181             {
182               // Scientific notation.
183               ++__pos;
184               __xtrc += __ctype.narrow(__c, char());
185               __c = *(++__beg);
186
187               // Remove optional plus or minus sign, if they exist.
188               if (__c == __plus || __c == __minus)
189                 {
190                   ++__pos;
191                   __xtrc += __ctype.narrow(__c, char());
192                   __c = *(++__beg);
193                 }
194               __found_sci = true;
195             }
196           else
197             // Not a valid input item.
198             break;
199         }
200
201       // Digit grouping is checked. If grouping and found_grouping don't
202       // match, then get very very upset, and set failbit.
203       if (__check_grouping && __found_grouping.size())
204         {
205           // Add the ending grouping if a decimal wasn't found.
206           if (!__found_dec)
207             __found_grouping += static_cast<char>(__sep_pos);
208           if (!__verify_grouping(__grouping, __found_grouping))
209             __err |= ios_base::failbit;
210         }
211
212       // Finish up
213       __xtrc += char();
214       if (__beg == __end)
215         __err |= ios_base::eofbit;
216       return __beg;
217     }
218
219   template<typename _CharT, typename _InIter>
220     _InIter
221     num_get<_CharT, _InIter>::
222     _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
223                    ios_base::iostate& __err, char* __xtrc, int __max, 
224                    int& __base) const
225     {
226       const locale __loc = __io.getloc();
227       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
228       const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
229  
230       // Stage 1: determine a conversion specifier.
231       // NB: Iff __basefield == 0, this can change based on contents.
232       ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield;
233       if (__basefield == ios_base::oct)
234         __base = 8;
235       else if (__basefield == ios_base::hex)
236         __base = 16;
237       else
238         __base = 10;
239
240      // Check first for sign.
241       int __pos = 0;
242       char_type  __c = *__beg;
243       if ((__c == __ctype.widen('+') || __c == __ctype.widen('-'))
244           && __beg != __end)
245         {
246           __xtrc[__pos++] = __ctype.narrow(__c, char());
247           __c = *(++__beg);
248         }
249
250       // Next, strip leading zeros and check required digits for base formats.
251       const char_type __zero = __ctype.widen(_S_atoms[_M_zero]);
252       const char_type __x = __ctype.widen('x');
253       const char_type __X = __ctype.widen('X');
254       if (__base == 10)
255         {
256           bool __found_zero = false;
257           while (__c == __zero && __beg != __end)
258             {
259               __c = *(++__beg);
260               __found_zero = true;
261             }
262           if (__found_zero)
263             {
264               __xtrc[__pos++] = _S_atoms[_M_zero];
265               if (__basefield == 0)
266                 {             
267                   if ((__c == __x || __c == __X) && __beg != __end)
268                     {
269                       __xtrc[__pos++] = __ctype.narrow(__c, char());
270                       __c = *(++__beg);
271                       __base = 16;
272                     }
273                   else 
274                     __base = 8;
275                 }
276             }
277         }
278       else if (__base == 16)
279         {
280           if (__c == __zero && __beg != __end)
281             {
282               __xtrc[__pos++] = _S_atoms[_M_zero];
283               __c = *(++__beg); 
284               if  ((__c == __x || __c == __X) && __beg != __end)
285                 {
286                   __xtrc[__pos++] = __ctype.narrow(__c, char());
287                   __c = *(++__beg);
288                 }
289             }
290         }
291
292       // At this point, base is determined. If not hex, only allow
293       // base digits as valid input.
294       size_t __len;
295       if (__base == 16)
296         __len = _M_size;
297       else
298         __len = __base;
299
300       // Figure out the maximum number of digits that can be extracted
301       // for the given type, using the determined base.
302       int __max_digits;
303       if (__base == 16)
304         __max_digits = static_cast<int>(ceil(__max * _S_scale_hex));
305       else if (__base == 8)
306         __max_digits = static_cast<int>(ceil(__max * _S_scale_oct));
307       else
308         __max_digits = __max;
309
310       // Add in what's already been extracted.
311       __max_digits += __pos;
312
313       // Extract.
314       char_type __watoms[_M_size];
315       __ctype.widen(_S_atoms, _S_atoms + __len, __watoms);
316       string __found_grouping;
317       const string __grouping = __np.grouping();
318       bool __check_grouping = __grouping.size() && __base == 10;
319       int __sep_pos = 0;
320       const char_type __sep = __np.thousands_sep();
321       while (__beg != __end && __pos <= __max_digits)
322         {
323           typedef char_traits<_CharT>   __traits_type;
324           const char_type* __p = __traits_type::find(__watoms, __len,  __c);
325
326           // NB: strchr returns true for __c == 0x0
327           if (__p && __c)
328             {
329               // Try first for acceptable digit; record it if found.
330               __xtrc[__pos++] = _S_atoms[__p - __watoms];
331               ++__sep_pos;
332               __c = *(++__beg);
333             }
334           else if (__c == __sep && __check_grouping)
335             {
336               // NB: Thousands separator at the beginning of a string
337               // is a no-no, as is two consecutive thousands separators.
338               if (__sep_pos)
339                 {
340                   __found_grouping += static_cast<char>(__sep_pos);
341                   __sep_pos = 0;
342                   __c = *(++__beg);
343                 }
344               else
345                 {
346                   __err |= ios_base::failbit;
347                   break;
348                 }
349             }
350           else
351             // Not a valid input item.
352             break;
353         }
354
355       // If one more than the maximum number of digits is extracted.
356       if (__pos > __max_digits)
357         __err |= ios_base::failbit;
358
359       // Digit grouping is checked. If grouping and found_grouping don't
360       // match, then get very very upset, and set failbit.
361       if (__check_grouping && __found_grouping.size())
362         {
363           // Add the ending grouping.
364           __found_grouping += static_cast<char>(__sep_pos);
365           if (!__verify_grouping(__grouping, __found_grouping))
366             __err |= ios_base::failbit;
367         }
368
369       // Finish up
370       __xtrc[__pos] = char();
371       if (__beg == __end)
372         __err |= ios_base::eofbit;
373       return __beg;
374     }
375
376 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
377   //17.  Bad bool parsing
378   template<typename _CharT, typename _InIter>
379     _InIter
380     num_get<_CharT, _InIter>::
381     do_get(iter_type __beg, iter_type __end, ios_base& __io,
382            ios_base::iostate& __err, bool& __v) const
383     {
384       // Parse bool values as long
385       if (!(__io.flags() & ios_base::boolalpha))
386         {
387           // NB: We can't just call do_get(long) here, as it might
388           // refer to a derived class.
389
390           // Stage 1: extract and determine the conversion specifier.
391           // Assuming leading zeros eliminated, thus the size of 32 for
392           // integral types
393           char __xtrc[32];
394           int __base;
395           // According to 18.2.1.2.9, digits10 is "Number of base 10 digits
396           // that can be represented without change" so we have to add 1 to it
397           // in order to obtain the max number of digits. The same for the
398           // other do_get for integral types below.
399           __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, 
400                                  numeric_limits<bool>::digits10 + 1, __base);
401
402           // Stage 2: convert and store results.
403           char* __sanity;
404           errno = 0;
405           long __l = strtol(__xtrc, &__sanity, __base);
406           if (!(__err & ios_base::failbit)
407               && __l <= 1
408               && __sanity != __xtrc && *__sanity == '\0' && errno == 0)
409             __v = __l;
410           else
411             __err |= ios_base::failbit;
412         }
413
414       // Parse bool values as alphanumeric
415       else
416         {
417           locale __loc = __io.getloc();
418           const numpunct<char_type>& __np = use_facet<numpunct<char_type> >(__loc); 
419           const char_type* __true = __np.truename().c_str();
420           const char_type* __false = __np.falsename().c_str();
421
422           const size_t __truen =  __np.truename().size() - 1;
423           const size_t __falsen =  __np.falsename().size() - 1;
424
425           for (size_t __n = 0; __beg != __end; ++__n)
426             {
427               char_type __c = *__beg++;
428               bool __testf = __n <= __falsen ? __c == __false[__n] : false;
429               bool __testt = __n <= __truen ? __c == __true[__n] : false;
430               if (!(__testf || __testt))
431                 {
432                   __err |= ios_base::failbit;
433                   break;
434                 }
435               else if (__testf && __n == __falsen)
436                 {
437                   __v = 0;
438                   break;
439                 }
440               else if (__testt && __n == __truen)
441                 {
442                   __v = 1;
443                   break;
444                 }
445             }
446           if (__beg == __end)
447             __err |= ios_base::eofbit;
448         }
449       return __beg;
450     }
451 #endif
452
453   template<typename _CharT, typename _InIter>
454     _InIter
455     num_get<_CharT, _InIter>::
456     do_get(iter_type __beg, iter_type __end, ios_base& __io,
457            ios_base::iostate& __err, long& __v) const
458     {
459       // Stage 1: extract and determine the conversion specifier.
460       // Assuming leading zeros eliminated, thus the size of 32 for
461       // integral types.
462       char __xtrc[32];
463       int __base;
464       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, 
465                              numeric_limits<long>::digits10 + 1, __base);
466
467       // Stage 2: convert and store results.
468       char* __sanity;
469       errno = 0;
470       long __l = strtol(__xtrc, &__sanity, __base);
471       if (!(__err & ios_base::failbit)
472           && __sanity != __xtrc && *__sanity == '\0' && errno == 0)
473         __v = __l;
474       else
475         __err |= ios_base::failbit;
476       return __beg;
477     }
478
479   template<typename _CharT, typename _InIter>
480     _InIter
481     num_get<_CharT, _InIter>::
482     do_get(iter_type __beg, iter_type __end, ios_base& __io,
483            ios_base::iostate& __err, unsigned short& __v) const
484     {
485       // Stage 1: extract and determine the conversion specifier.
486       // Assuming leading zeros eliminated, thus the size of 32 for
487       // integral types.
488       char __xtrc[32];
489       int __base;
490       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, 
491                              numeric_limits<unsigned short>::digits10 + 1,
492                              __base);
493
494       // Stage 2: convert and store results.
495       char* __sanity;
496       errno = 0;
497       unsigned long __ul = strtoul(__xtrc, &__sanity, __base);
498       if (!(__err & ios_base::failbit)
499           && __sanity != __xtrc && *__sanity == '\0' && errno == 0
500           && __ul <= USHRT_MAX)
501         __v = static_cast<unsigned short>(__ul);
502       else
503         __err |= ios_base::failbit;
504       return __beg;
505     }
506
507   template<typename _CharT, typename _InIter>
508     _InIter
509     num_get<_CharT, _InIter>::
510     do_get(iter_type __beg, iter_type __end, ios_base& __io,
511            ios_base::iostate& __err, unsigned int& __v) const
512     {
513       // Stage 1: extract and determine the conversion specifier.
514       // Assuming leading zeros eliminated, thus the size of 32 for
515       // integral types.
516       char __xtrc[32];
517       int __base;
518       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, 
519                              numeric_limits<unsigned int>::digits10 + 1,
520                              __base);
521
522       // Stage 2: convert and store results.
523       char* __sanity;
524       errno = 0;
525       unsigned long __ul = strtoul(__xtrc, &__sanity, __base);
526       if (!(__err & ios_base::failbit)
527           && __sanity != __xtrc && *__sanity == '\0' && errno == 0
528           && __ul <= UINT_MAX)
529         __v = static_cast<unsigned int>(__ul);
530       else
531         __err |= ios_base::failbit;
532       return __beg;
533     }
534
535   template<typename _CharT, typename _InIter>
536     _InIter
537     num_get<_CharT, _InIter>::
538     do_get(iter_type __beg, iter_type __end, ios_base& __io,
539            ios_base::iostate& __err, unsigned long& __v) const
540     {
541       // Stage 1: extract and determine the conversion specifier.
542       // Assuming leading zeros eliminated, thus the size of 32 for
543       // integral types.
544       char __xtrc[32];
545       int __base;
546       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, 
547                              numeric_limits<unsigned long>::digits10 + 1,
548                              __base);
549
550       // Stage 2: convert and store results.
551       char* __sanity;
552       errno = 0;
553       unsigned long __ul = strtoul(__xtrc, &__sanity, __base);
554       if (!(__err & ios_base::failbit)
555           && __sanity != __xtrc && *__sanity == '\0' && errno == 0)
556         __v = __ul;
557       else
558         __err |= ios_base::failbit;
559       return __beg;
560     }
561
562 #ifdef _GLIBCPP_USE_LONG_LONG
563   template<typename _CharT, typename _InIter>
564     _InIter
565     num_get<_CharT, _InIter>::
566     do_get(iter_type __beg, iter_type __end, ios_base& __io,
567            ios_base::iostate& __err, long long& __v) const
568     {
569       // Stage 1: extract and determine the conversion specifier.
570       // Assuming leading zeros eliminated, thus the size of 32 for
571       // integral types.
572       char __xtrc[32];
573       int __base;
574       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, 
575                              numeric_limits<long long>::digits10 + 1, __base);
576
577       // Stage 2: convert and store results.
578       char* __sanity;
579       errno = 0;
580       long long __ll = strtoll(__xtrc, &__sanity, __base);
581       if (!(__err & ios_base::failbit)
582           && __sanity != __xtrc && *__sanity == '\0' && errno == 0)
583         __v = __ll;
584       else
585         __err |= ios_base::failbit;
586       return __beg;
587     }
588
589   template<typename _CharT, typename _InIter>
590     _InIter
591     num_get<_CharT, _InIter>::
592     do_get(iter_type __beg, iter_type __end, ios_base& __io,
593            ios_base::iostate& __err, unsigned long long& __v) const
594     {
595       // Stage 1: extract and determine the conversion specifier.
596       // Assuming leading zeros eliminated, thus the size of 32 for
597       // integral types.
598       char __xtrc[32];
599       int __base;
600       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc,
601                              numeric_limits<unsigned long long>::digits10 + 1,
602                              __base);
603
604       // Stage 2: convert and store results.
605       char* __sanity;
606       errno = 0;
607       unsigned long long __ull = strtoull(__xtrc, &__sanity, __base);
608       if (!(__err & ios_base::failbit)
609           && __sanity != __xtrc && *__sanity == '\0' && errno == 0)
610         __v = __ull;
611       else
612         __err |= ios_base::failbit;
613       return __beg;
614     }
615 #endif
616
617   template<typename _CharT, typename _InIter>
618     _InIter
619     num_get<_CharT, _InIter>::
620     do_get(iter_type __beg, iter_type __end, ios_base& __io, 
621            ios_base::iostate& __err, float& __v) const
622     {
623       // Stage 1: extract and determine the conversion specifier.
624       string __xtrc;
625       __xtrc.reserve(32);
626       __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
627
628       // Stage 2: convert and store results.
629       char* __sanity;
630       errno = 0;
631 #ifdef _GLIBCPP_USE_C99
632       float __f = strtof(__xtrc.c_str(), &__sanity);
633 #else
634       float __f = static_cast<float>(strtod(__xtrc.c_str(), &__sanity));
635 #endif
636       if (!(__err & ios_base::failbit)
637           && __sanity != __xtrc.c_str() && *__sanity == '\0' && errno == 0)
638         __v = __f;
639       else
640         __err |= ios_base::failbit;
641       return __beg;
642     }
643
644   template<typename _CharT, typename _InIter>
645     _InIter
646     num_get<_CharT, _InIter>::
647     do_get(iter_type __beg, iter_type __end, ios_base& __io,
648            ios_base::iostate& __err, double& __v) const
649     {
650       // Stage 1: extract and determine the conversion specifier.
651       string __xtrc;
652       __xtrc.reserve(32);
653       __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
654
655       // Stage 2: convert and store results.
656       char* __sanity;
657       errno = 0;
658       double __d = strtod(__xtrc.c_str(), &__sanity);
659       if (!(__err & ios_base::failbit)
660           && __sanity != __xtrc.c_str() && *__sanity == '\0' && errno == 0)
661         __v = __d;
662       else
663         __err |= ios_base::failbit;
664       return __beg;
665     }
666
667   template<typename _CharT, typename _InIter>
668     _InIter
669     num_get<_CharT, _InIter>::
670     do_get(iter_type __beg, iter_type __end, ios_base& __io,
671            ios_base::iostate& __err, long double& __v) const
672     {
673       // Stage 1: extract and determine the conversion specifier.
674       string __xtrc;
675       __xtrc.reserve(32);
676       __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
677
678 #if defined(_GLIBCPP_USE_C99) && !defined(__hpux)
679       // Stage 2: convert and store results.
680       char* __sanity;
681       errno = 0;
682       long double __ld = strtold(__xtrc.c_str(), &__sanity);
683       if (!(__err & ios_base::failbit)
684           && __sanity != __xtrc.c_str() && *__sanity == '\0' && errno == 0)
685         __v = __ld;
686 #else
687       // Stage 2: determine a conversion specifier.
688       ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield;
689       const char* __conv;
690       if (__basefield == ios_base::oct)
691         __conv = "%Lo";
692       else if (__basefield == ios_base::hex)
693         __conv = "%LX";
694       else if (__basefield == 0)
695         __conv = "%Li";
696       else
697         __conv = "%Lf";
698
699       // Stage 3: store results.
700       typedef typename char_traits<_CharT>::int_type int_type;
701       long double __ld;
702       int __p = sscanf(__xtrc.c_str(), __conv, &__ld);
703       if (!(__err & ios_base::failbit) && __p 
704           && static_cast<int_type>(__p) != char_traits<_CharT>::eof())
705         __v = __ld;
706 #endif
707       else
708         __err |= ios_base::failbit;
709       return __beg;
710     }
711
712   template<typename _CharT, typename _InIter>
713     _InIter
714     num_get<_CharT, _InIter>::
715     do_get(iter_type __beg, iter_type __end, ios_base& __io,
716            ios_base::iostate& __err, void*& __v) const
717     {
718       // Prepare for hex formatted input
719       typedef ios_base::fmtflags        fmtflags;
720       fmtflags __fmt = __io.flags();
721       fmtflags __fmtmask = ~(ios_base::showpos | ios_base::basefield
722                              | ios_base::uppercase | ios_base::internal);
723       __io.flags(__fmt & __fmtmask | (ios_base::hex | ios_base::showbase));
724
725       // Stage 1: extract and determine the conversion specifier.
726       // Assuming leading zeros eliminated, thus the size of 32 for
727       // integral types.
728       char __xtrc[32];
729       int __base;
730       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, 
731                              numeric_limits<unsigned long>::digits10 + 1,
732                              __base);
733
734       // Stage 2: convert and store results.
735       char* __sanity;
736       errno = 0;
737       void* __vp = reinterpret_cast<void*>(strtoul(__xtrc, &__sanity, __base));
738       if (!(__err & ios_base::failbit)
739           && __sanity != __xtrc && *__sanity == '\0' && errno == 0)
740         __v = __vp;
741       else
742         __err |= ios_base::failbit;
743
744       // Reset from hex formatted input
745       __io.flags(__fmt);
746       return __beg;
747     }
748
749
750   // The following code uses sprintf() to convert floating point
751   // values for insertion into a stream.  An optimization would be to
752   // replace sprintf() with code that works directly on a wide buffer
753   // and then use __pad to do the padding. It would be good
754   // to replace sprintf() anyway to avoid accidental buffer overruns
755   // and to gain back the efficiency that C++ provides by knowing up
756   // front the type of the values to insert. This implementation
757   // follows the C++ standard fairly directly as outlined in 22.2.2.2
758   // [lib.locale.num.put]
759   template<typename _CharT, typename _OutIter>
760     template<typename _ValueT>
761       _OutIter
762       num_put<_CharT, _OutIter>::
763       _M_convert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
764                        _ValueT __v) const
765       {
766         const int __max_digits = numeric_limits<_ValueT>::digits10;
767         streamsize __prec = __io.precision();
768         // Protect against sprintf() buffer overflows.
769         if (__prec > static_cast<streamsize>(__max_digits))
770           __prec = static_cast<streamsize>(__max_digits);
771
772         // Long enough for the max format spec.
773         char __fbuf[16];
774
775         // Consider the possibility of long ios_base::fixed outputs
776         const bool __fixed = __io.flags() & ios_base::fixed;
777         const int __max_exp = numeric_limits<_ValueT>::max_exponent10;
778         // ios_base::fixed outputs may need up to __max_exp+1 chars
779         // for the integer part + up to __max_digits chars for the
780         // fractional part + 3 chars for sign, decimal point, '\0'. On
781         // the other hand, for non-fixed outputs __max_digits*3 chars
782         // are largely sufficient.
783         const int __cs_size = __fixed ? __max_exp + __max_digits + 4 
784                                       : __max_digits * 3;
785         char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
786
787         int __len;
788         // [22.2.2.2.2] Stage 1, numeric conversion to character.
789         if (_S_format_float(__io, __fbuf, __mod, __prec))
790           __len = sprintf(__cs, __fbuf, __prec, __v);
791         else
792           __len = sprintf(__cs, __fbuf, __v);
793         return _M_widen_float(__s, __io, __fill, __cs, __len);
794       }
795
796   template<typename _CharT, typename _OutIter>
797     template<typename _ValueT>
798       _OutIter
799       num_put<_CharT, _OutIter>::
800       _M_convert_int(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
801                      char __modl, _ValueT __v) const
802       {
803         // [22.2.2.2.2] Stage 1, numeric conversion to character.
804         // Leave room for "+/-," "0x," and commas. This size is
805         // arbitrary, but should work.
806         char __cs[64];
807         // Long enough for the max format spec.
808         char __fbuf[16];
809         _S_format_int(__io, __fbuf, __mod, __modl);
810         int __len = sprintf(__cs, __fbuf, __v);
811         return _M_widen_int(__s, __io, __fill, __cs, __len);
812       }
813
814   template<typename _CharT, typename _OutIter>
815     _OutIter
816     num_put<_CharT, _OutIter>::
817     _M_widen_float(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs, 
818                    int __len) const
819     {
820       // [22.2.2.2.2] Stage 2, convert to char_type, using correct
821       // numpunct.decimal_point() values for '.' and adding grouping.
822       const locale __loc = __io.getloc();
823       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
824       _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) 
825                                                            * __len));
826       // Grouping can add (almost) as many separators as the number of
827       // digits, but no more.
828       _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) 
829                                                             * __len * 2));
830       __ctype.widen(__cs, __cs + __len, __ws);
831       
832       // Replace decimal point.
833       const _CharT* __p;
834       const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
835       if (__p = char_traits<_CharT>::find(__ws, __len, __ctype.widen('.')))
836         __ws[__p - __ws] = __np.decimal_point();
837
838 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
839 //282. What types does numpunct grouping refer to?
840       // Add grouping, if necessary. 
841       const string __grouping = __np.grouping();
842       ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield;
843       if (__grouping.size())
844         {
845           _CharT* __p2;
846           int __declen = __p ? __p - __ws : __len;
847           __p2 = __add_grouping(__ws2, __np.thousands_sep(), 
848                                 __grouping.c_str(),
849                                 __grouping.c_str() + __grouping.size(),
850                                 __ws, __ws + __declen);
851           int __newlen = __p2 - __ws2;
852         
853           // Tack on decimal part.
854           if (__p)
855             {
856               char_traits<_CharT>::copy(__p2, __p, __len - __declen);
857               __newlen += __len - __declen;
858             }    
859
860           // Switch strings, establish correct new length.
861           __ws = __ws2;
862           __len = __newlen;
863         }
864 #endif
865       return _M_insert(__s, __io, __fill, __ws, __len);
866     }
867
868   template<typename _CharT, typename _OutIter>
869     _OutIter
870     num_put<_CharT, _OutIter>::
871     _M_widen_int(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs, 
872                  int __len) const
873     {
874       // [22.2.2.2.2] Stage 2, convert to char_type, using correct
875       // numpunct.decimal_point() values for '.' and adding grouping.
876       const locale __loc = __io.getloc();
877       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
878       _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) 
879                                                            * __len));
880       // Grouping can add (almost) as many separators as the number of
881       // digits, but no more.
882       _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) 
883                                                             * __len * 2));
884       __ctype.widen(__cs, __cs + __len, __ws);
885
886       // Add grouping, if necessary.
887       const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
888       const string __grouping = __np.grouping();
889       ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield;
890       bool __dec = __basefield != ios_base::oct 
891                    && __basefield != ios_base::hex;
892       if (__grouping.size() && __dec)
893         {
894           _CharT* __p;
895           __p = __add_grouping(__ws2, __np.thousands_sep(), __grouping.c_str(),
896                                __grouping.c_str() + __grouping.size(),
897                                __ws, __ws + __len);
898           __len = __p - __ws2;
899           // Switch strings.
900           __ws = __ws2;
901         }
902       return _M_insert(__s, __io, __fill, __ws, __len);
903     }
904
905   // For use by integer and floating-point types after they have been
906   // converted into a char_type string.
907   template<typename _CharT, typename _OutIter>
908     _OutIter
909     num_put<_CharT, _OutIter>::
910     _M_insert(_OutIter __s, ios_base& __io, _CharT __fill, const _CharT* __ws, 
911               int __len) const
912     {
913       // [22.2.2.2.2] Stage 3.
914       streamsize __w = __io.width();
915       _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) 
916                                                             * __w));
917       if (__w > static_cast<streamsize>(__len))
918         {
919           __pad(__io, __fill, __ws2, __ws, __w, __len, true);
920           __len = static_cast<int>(__w);
921           // Switch strings.
922           __ws = __ws2;
923         }
924       __io.width(0);
925
926       // [22.2.2.2.2] Stage 4.
927       // Write resulting, fully-formatted string to output iterator.
928       for (int __j = 0; __j < __len; ++__j, ++__s)
929         *__s = __ws[__j];
930       return __s;
931     }
932
933   template<typename _CharT, typename _OutIter>
934     _OutIter
935     num_put<_CharT, _OutIter>::
936     do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
937     {
938       ios_base::fmtflags __flags = __io.flags();
939       if ((__flags & ios_base::boolalpha) == 0)
940         {
941           unsigned long __uv = __v;
942           __s = _M_convert_int(__s, __io, __fill, 'u', char_type(), __uv);
943         }
944       else
945         {
946           locale __loc = __io.getloc();
947           const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); 
948           const char_type* __ws;
949           int __len;
950           if (__v)
951             {
952               __ws = __np.truename().c_str();
953               __len = __np.truename().size();
954             }
955           else
956             {
957               __ws = __np.falsename().c_str();
958               __len = __np.falsename().size();
959             }
960           __s = _M_insert(__s, __io, __fill, __ws, __len); 
961         }
962       return __s;
963     }
964
965   template<typename _CharT, typename _OutIter>
966     _OutIter
967     num_put<_CharT, _OutIter>::
968     do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
969     { return _M_convert_int(__s, __io, __fill, 'd', char_type(), __v); }
970
971   template<typename _CharT, typename _OutIter>
972     _OutIter
973     num_put<_CharT, _OutIter>::
974     do_put(iter_type __s, ios_base& __io, char_type __fill,
975            unsigned long __v) const
976     { return _M_convert_int(__s, __io, __fill, 'u', char_type(), __v); }
977
978 #ifdef _GLIBCPP_USE_LONG_LONG
979   template<typename _CharT, typename _OutIter>
980     _OutIter
981     num_put<_CharT, _OutIter>::
982     do_put(iter_type __s, ios_base& __b, char_type __fill, long long __v) const
983     { return _M_convert_int(__s, __b, __fill, 'd', 'l', __v); }
984
985   template<typename _CharT, typename _OutIter>
986     _OutIter
987     num_put<_CharT, _OutIter>::
988     do_put(iter_type __s, ios_base& __io, char_type __fill,
989            unsigned long long __v) const
990     { return _M_convert_int(__s, __io, __fill, 'u', 'l', __v); }
991 #endif
992
993   template<typename _CharT, typename _OutIter>
994     _OutIter
995     num_put<_CharT, _OutIter>::
996     do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
997     { return _M_convert_float(__s, __io, __fill, char_type(), __v); }
998
999   template<typename _CharT, typename _OutIter>
1000     _OutIter
1001     num_put<_CharT, _OutIter>::
1002     do_put(iter_type __s, ios_base& __io, char_type __fill, 
1003            long double __v) const
1004     { return _M_convert_float(__s, __io, __fill, 'L', __v); }
1005
1006   template<typename _CharT, typename _OutIter>
1007     _OutIter
1008     num_put<_CharT, _OutIter>::
1009     do_put(iter_type __s, ios_base& __io, char_type __fill,
1010            const void* __v) const
1011     {
1012       ios_base::fmtflags __flags = __io.flags();
1013       ios_base::fmtflags __fmt = ~(ios_base::showpos | ios_base::basefield
1014                                    | ios_base::uppercase | ios_base::internal);
1015       __io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase));
1016       try 
1017         {
1018           __s = _M_convert_int(__s, __io, __fill, 'u', char_type(),
1019                                reinterpret_cast<unsigned long>(__v));
1020           __io.flags(__flags);
1021         }
1022       catch (...) 
1023         {
1024           __io.flags(__flags);
1025           __throw_exception_again;
1026         }
1027       return __s;
1028     }
1029
1030
1031   template<typename _CharT, typename _InIter>
1032     _InIter
1033     money_get<_CharT, _InIter>::
1034     do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io, 
1035            ios_base::iostate& __err, long double& __units) const
1036     { 
1037       string_type __str;
1038       __beg = this->do_get(__beg, __end, __intl, __io, __err, __str); 
1039
1040       const int __n = numeric_limits<long double>::digits10;
1041       char* __cs = static_cast<char*>(__builtin_alloca(sizeof(char) * __n));
1042       const locale __loc = __io.getloc();
1043       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
1044       const _CharT* __wcs = __str.c_str();
1045       __ctype.narrow(__wcs, __wcs + __str.size() + 1, char(), __cs);      
1046
1047 #if defined(_GLIBCPP_USE_C99) && !defined(__hpux)
1048       char* __sanity;
1049       errno = 0;
1050       long double __ld = strtold(__cs, &__sanity);
1051       if (!(__err & ios_base::failbit)
1052           && __sanity != __cs && *__sanity == '\0' && errno == 0)
1053         __units = __ld;
1054 #else
1055       typedef typename char_traits<_CharT>::int_type int_type;
1056       long double __ld;
1057       int __p = sscanf(__cs, "%Lf", &__ld);
1058       if (!(__err & ios_base::failbit)
1059           && __p && static_cast<int_type>(__p) != char_traits<_CharT>::eof())
1060         __units = __ld;
1061 #endif
1062       return __beg;
1063     }
1064
1065   template<typename _CharT, typename _InIter>
1066     _InIter
1067     money_get<_CharT, _InIter>::
1068     do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io, 
1069            ios_base::iostate& __err, string_type& __units) const
1070     { 
1071       // These contortions are quite unfortunate.
1072       typedef moneypunct<_CharT, true>          __money_true;
1073       typedef moneypunct<_CharT, false>         __money_false;
1074       typedef money_base::part                  part;
1075       typedef typename string_type::size_type   size_type;
1076
1077       const locale __loc = __io.getloc();
1078       const __money_true& __mpt = use_facet<__money_true>(__loc); 
1079       const __money_false& __mpf = use_facet<__money_false>(__loc); 
1080       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
1081
1082       const money_base::pattern __p = __intl ? __mpt.neg_format() 
1083                                              : __mpf.neg_format();
1084
1085       const string_type __pos_sign =__intl ? __mpt.positive_sign() 
1086                                            : __mpf.positive_sign();
1087       const string_type __neg_sign =__intl ? __mpt.negative_sign() 
1088                                            : __mpf.negative_sign();
1089       const char_type __d = __intl ? __mpt.decimal_point() 
1090                                    : __mpf.decimal_point();
1091       const char_type __sep = __intl ? __mpt.thousands_sep() 
1092                                      : __mpf.thousands_sep();
1093
1094       const string __grouping = __intl ? __mpt.grouping() : __mpf.grouping();
1095
1096       // Set to deduced positive or negative sign, depending.
1097       string_type __sign;
1098       // String of grouping info from thousands_sep plucked from __units.
1099       string __grouping_tmp; 
1100       // Marker for thousands_sep position.
1101       int __sep_pos = 0;
1102       // If input iterator is in a valid state.
1103       bool __testvalid = true;
1104       // Flag marking when a decimal point is found.
1105       bool __testdecfound = false; 
1106
1107       char_type __c = *__beg;
1108       char_type __eof = static_cast<char_type>(char_traits<char_type>::eof());
1109       for (int __i = 0; __beg != __end && __i < 4 && __testvalid; ++__i)
1110         {
1111           part __which = static_cast<part>(__p.field[__i]);
1112           switch (__which)
1113                 {
1114                 case money_base::symbol:
1115                   if (__io.flags() & ios_base::showbase)
1116                     {
1117                       // Symbol is required.
1118                       const string_type __symbol = __intl ? __mpt.curr_symbol()
1119                                                          : __mpf.curr_symbol();
1120                       size_type __len = __symbol.size();
1121                       size_type __i = 0;
1122                       while (__beg != __end 
1123                              && __i < __len && __symbol[__i] == __c)
1124                         {
1125                           __c = *(++__beg);
1126                           ++__i;
1127                         }
1128                       if (__i != __len)
1129                         __testvalid = false;
1130                     }
1131                   break;
1132                 case money_base::sign:              
1133                   // Sign might not exist, or be more than one character long. 
1134                   if (__pos_sign.size() && __neg_sign.size())
1135                   {
1136                     // Sign is mandatory.
1137                     if (__c == __pos_sign[0])
1138                       {
1139                         __sign = __pos_sign;
1140                         __c = *(++__beg);
1141                       }
1142                     else if (__c == __neg_sign[0])
1143                       {
1144                         __sign = __neg_sign;
1145                         __c = *(++__beg);
1146                       }
1147                     else
1148                       __testvalid = false;
1149                   }
1150                   else if (__pos_sign.size() && __c == __pos_sign[0])
1151                     {
1152                       __sign = __pos_sign;
1153                       __c = *(++__beg);
1154                     }
1155                   else if (__neg_sign.size() && __c == __neg_sign[0])
1156                     {
1157                       __sign = __neg_sign;
1158                       __c = *(++__beg);
1159                     }
1160                   break;
1161                 case money_base::value:
1162                   // Extract digits, remove and stash away the
1163                   // grouping of found thousands separators.
1164                   while (__beg != __end 
1165                          && (__ctype.is(ctype_base::digit, __c) 
1166                              || (__c == __d && !__testdecfound)
1167                              || __c == __sep))
1168                     {
1169                       if (__c == __d)
1170                         {
1171                           __grouping_tmp += static_cast<char>(__sep_pos);
1172                           __sep_pos = 0;
1173                           __testdecfound = true;
1174                         }
1175                       else if (__c == __sep)
1176                         {
1177                           if (__grouping.size())
1178                             {
1179                               // Mark position for later analysis.
1180                               __grouping_tmp += static_cast<char>(__sep_pos);
1181                               __sep_pos = 0;
1182                             }
1183                           else
1184                             {
1185                               __testvalid = false;
1186                               break;
1187                             }
1188                         }
1189                       else
1190                         {
1191                           __units += __c;
1192                           ++__sep_pos;
1193                         }
1194                       __c = *(++__beg);
1195                     }
1196                   break;
1197                 case money_base::space:
1198                 case money_base::none:
1199                   // Only if not at the end of the pattern.
1200                   if (__i != 3)
1201                     while (__beg != __end 
1202                            && __ctype.is(ctype_base::space, __c))
1203                       __c = *(++__beg);
1204                   break;
1205                 }
1206         }
1207
1208       // Need to get the rest of the sign characters, if they exist.
1209       if (__sign.size() > 1)
1210         {
1211           size_type __len = __sign.size();
1212           size_type __i = 1;
1213           for (; __c != __eof && __i < __len; ++__i)
1214             while (__beg != __end && __c != __sign[__i])
1215               __c = *(++__beg);
1216           
1217           if (__i != __len)
1218             __testvalid = false;
1219         }
1220
1221       // Strip leading zeros.
1222       while (__units[0] == __ctype.widen('0'))
1223         __units.erase(__units.begin());
1224
1225       if (__sign.size() && __sign == __neg_sign)
1226         __units.insert(__units.begin(), __ctype.widen('-'));
1227
1228       // Test for grouping fidelity.
1229       if (__grouping.size() && __grouping_tmp.size())
1230         {
1231           if (!__verify_grouping(__grouping, __grouping_tmp))
1232             __testvalid = false;
1233         }
1234
1235       // Iff no more characters are available.      
1236       if (__c == __eof)
1237         __err |= ios_base::eofbit;
1238
1239       // Iff valid sequence is not recognized.
1240       if (!__testvalid || !__units.size())
1241         __err |= ios_base::failbit;
1242       return __beg; 
1243     }
1244
1245   template<typename _CharT, typename _OutIter>
1246     _OutIter
1247     money_put<_CharT, _OutIter>::
1248     do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
1249            long double __units) const
1250     { 
1251       const locale __loc = __io.getloc();
1252       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
1253       const int __n = numeric_limits<long double>::digits10;
1254       char* __cs = static_cast<char*>(__builtin_alloca(sizeof(char) * __n));
1255       _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __n));
1256       int __len = sprintf(__cs, "%.01Lf", __units);
1257       __ctype.widen(__cs, __cs + __len, __ws);
1258       string_type __digits(__ws);
1259       return this->do_put(__s, __intl, __io, __fill, __digits); 
1260     }
1261
1262   template<typename _CharT, typename _OutIter>
1263     _OutIter
1264     money_put<_CharT, _OutIter>::
1265     do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
1266            const string_type& __digits) const
1267     { 
1268       typedef typename string_type::size_type   size_type;
1269       typedef money_base::part                  part;
1270
1271       const locale __loc = __io.getloc();
1272       const size_type __width = static_cast<size_type>(__io.width());
1273
1274       // These contortions are quite unfortunate.
1275       typedef moneypunct<_CharT, true> __money_true;
1276       typedef moneypunct<_CharT, false> __money_false;
1277       const __money_true& __mpt = use_facet<__money_true>(__loc); 
1278       const __money_false& __mpf = use_facet<__money_false>(__loc); 
1279       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
1280
1281       // Determine if negative or positive formats are to be used, and
1282       // discard leading negative_sign if it is present.
1283       const char_type* __beg = __digits.data();
1284       const char_type* __end = __beg + __digits.size();
1285       money_base::pattern __p;
1286       string_type __sign;
1287       if (*__beg != __ctype.widen('-'))
1288         {
1289           __p = __intl ? __mpt.pos_format() : __mpf.pos_format();
1290           __sign =__intl ? __mpt.positive_sign() : __mpf.positive_sign();
1291         }
1292       else
1293         {
1294           __p = __intl ? __mpt.neg_format() : __mpf.neg_format();
1295           __sign =__intl ? __mpt.negative_sign() : __mpf.negative_sign();
1296           ++__beg;
1297         }
1298       
1299       // Look for valid numbers in the current ctype facet within input digits.
1300       __end = __ctype.scan_not(ctype_base::digit, __beg, __end);
1301       if (__beg != __end)
1302         {
1303           // Assume valid input, and attempt to format.
1304           // Break down input numbers into base components, as follows:
1305           //   final_value = grouped units + (decimal point) + (digits)
1306           string_type __res;
1307           string_type __value;
1308           const string_type __symbol = __intl ? __mpt.curr_symbol() 
1309                                               : __mpf.curr_symbol();
1310
1311           // Deal with decimal point, decimal digits.
1312           const int __frac = __intl ? __mpt.frac_digits() 
1313                                     : __mpf.frac_digits();
1314           if (__frac > 0)
1315             {
1316               const char_type __d = __intl ? __mpt.decimal_point() 
1317                                            : __mpf.decimal_point();
1318               if (__end - __beg >= __frac)
1319                 {
1320                   __value = string_type(__end - __frac, __end);
1321                   __value.insert(__value.begin(), __d);
1322                   __end -= __frac;
1323                 }
1324               else
1325                 {
1326                   // Have to pad zeros in the decimal position.
1327                   __value = string_type(__beg, __end);
1328                   int __paddec = __frac - (__end - __beg);
1329                   char_type __zero = __ctype.widen('0');
1330                   __value.insert(__value.begin(), __paddec, __zero);
1331                   __value.insert(__value.begin(), __d);
1332                   __beg = __end;
1333                 }
1334             }
1335
1336           // Add thousands separators to non-decimal digits, per
1337           // grouping rules.
1338           if (__beg != __end)
1339             {
1340               const string __grouping = __intl ? __mpt.grouping() 
1341                                                : __mpf.grouping();
1342               if (__grouping.size())
1343                 {
1344                   const char_type __sep = __intl ? __mpt.thousands_sep() 
1345                                                  : __mpf.thousands_sep();
1346                   const char* __gbeg = __grouping.c_str();
1347                   const char* __gend = __gbeg + __grouping.size();
1348                   const int __n = numeric_limits<long double>::digits10 * 2;
1349                   _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __n));
1350                   _CharT* __ws_end = __add_grouping(__ws2, __sep, __gbeg, 
1351                                                     __gend, __beg, __end);
1352                   __value.insert(0, __ws2, __ws_end - __ws2);
1353                 }
1354               else
1355                 __value.insert(0, string_type(__beg, __end));
1356             }
1357
1358           // Calculate length of resulting string.
1359           ios_base::fmtflags __f = __io.flags() & ios_base::adjustfield;
1360           size_type __len = __value.size() + __sign.size();
1361           __len += (__io.flags() & ios_base::showbase) ? __symbol.size() : 0;
1362           bool __testipad = __f == ios_base::internal && __len < __width;
1363
1364           // Fit formatted digits into the required pattern.
1365           for (int __i = 0; __i < 4; ++__i)
1366             {
1367               part __which = static_cast<part>(__p.field[__i]);
1368               switch (__which)
1369                 {
1370                 case money_base::symbol:
1371                   if (__io.flags() & ios_base::showbase)
1372                     __res += __symbol;
1373                   break;
1374                 case money_base::sign:              
1375                   // Sign might not exist, or be more than one
1376                   // charater long. In that case, add in the rest
1377                   // below.
1378                   if (__sign.size())
1379                     __res += __sign[0];
1380                   break;
1381                 case money_base::value:
1382                   __res += __value;
1383                   break;
1384                 case money_base::space:
1385                   // At least one space is required, but if internal
1386                   // formatting is required, an arbitrary number of
1387                   // fill spaces will be necessary.
1388                   if (__testipad)
1389                     __res += string_type(__width - __len, __fill);
1390                   else
1391                     __res += __ctype.widen(' ');
1392                   break;
1393                 case money_base::none:
1394                   if (__testipad)
1395                     __res += string_type(__width - __len, __fill);
1396                   break;
1397                 }
1398             }
1399
1400           // Special case of multi-part sign parts.
1401           if (__sign.size() > 1)
1402             __res += string_type(__sign.begin() + 1, __sign.end());
1403
1404           // Pad, if still necessary.
1405           __len = __res.size();
1406           if (__width > __len)
1407             {
1408               if (__f == ios_base::left)
1409                 // After.
1410                 __res.append(__width - __len, __fill);
1411               else
1412                 // Before.
1413                 __res.insert(0, string_type(__width - __len, __fill));
1414               __len = __width;
1415             }
1416
1417           // Write resulting, fully-formatted string to output iterator.
1418           for (size_type __j = 0; __j < __len; ++__j, ++__s)
1419             *__s = __res[__j];
1420         }
1421       __io.width(0);
1422       return __s; 
1423     }
1424
1425
1426   // NB: Not especially useful. Without an ios_base object or some
1427   // kind of locale reference, we are left clawing at the air where
1428   // the side of the mountain used to be...
1429   template<typename _CharT, typename _InIter>
1430     time_base::dateorder
1431     time_get<_CharT, _InIter>::do_date_order() const
1432     { return time_base::no_order; }
1433
1434   template<typename _CharT, typename _InIter>
1435     void
1436     time_get<_CharT, _InIter>::
1437     _M_extract_via_format(iter_type& __beg, iter_type& __end, ios_base& __io,
1438                           ios_base::iostate& __err, tm* __tm, 
1439                           const _CharT* __format) const
1440     {  
1441       locale __loc = __io.getloc();
1442       __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
1443       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
1444       size_t __len = char_traits<_CharT>::length(__format);
1445
1446       for (size_t __i = 0; __beg != __end && __i < __len && !__err; ++__i)
1447         {
1448           char __c = __format[__i];
1449           if (__c == '%')
1450             {
1451               // Verify valid formatting code, attempt to extract.
1452               __c = __format[++__i];
1453               char __mod = 0;
1454               int __mem = 0; 
1455               if (__c == 'E' || __c == 'O')
1456                 {
1457                   __mod = __c;
1458                   __c = __format[++__i];
1459                 }
1460               switch (__c)
1461                 {
1462                   const char* __cs;
1463                   _CharT __wcs[10];
1464                 case 'a':
1465                   // Abbreviated weekday name [tm_wday]
1466                   const char_type*  __days1[7];
1467                   __tp._M_days_abbreviated(__days1);
1468                   _M_extract_name(__beg, __end, __tm->tm_wday, __days1, 7, 
1469                                   __err);
1470                   break;
1471                 case 'A':
1472                   // Weekday name [tm_wday].
1473                   const char_type*  __days2[7];
1474                   __tp._M_days(__days2);
1475                   _M_extract_name(__beg, __end, __tm->tm_wday, __days2, 7, 
1476                                   __err);
1477                   break;
1478                 case 'h':
1479                 case 'b':
1480                   // Abbreviated month name [tm_mon]
1481                   const char_type*  __months1[12];
1482                   __tp._M_months_abbreviated(__months1);
1483                   _M_extract_name(__beg, __end, __tm->tm_mon, __months1, 12, 
1484                                   __err);
1485                   break;
1486                 case 'B':
1487                   // Month name [tm_mon].
1488                   const char_type*  __months2[12];
1489                   __tp._M_months(__months2);
1490                   _M_extract_name(__beg, __end, __tm->tm_mon, __months2, 12, 
1491                                   __err);
1492                   break;
1493                 case 'c':
1494                   // Default time and date representation.
1495                   const char_type*  __dt[2];
1496                   __tp._M_date_time_formats(__dt);
1497                   _M_extract_via_format(__beg, __end, __io, __err, __tm, 
1498                                         __dt[0]);
1499                   break;
1500                 case 'd':
1501                   // Day [01, 31]. [tm_mday]
1502                   _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2, 
1503                                  __ctype, __err);
1504                   break;
1505                 case 'D':
1506                   // Equivalent to %m/%d/%y.[tm_mon, tm_mday, tm_year]
1507                   __cs = "%m/%d/%y";
1508                   __ctype.widen(__cs, __cs + 9, __wcs);
1509                   _M_extract_via_format(__beg, __end, __io, __err, __tm, 
1510                                         __wcs);
1511                   break;
1512                 case 'H':
1513                   // Hour [00, 23]. [tm_hour]
1514                   _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
1515                                  __ctype, __err);
1516                   break;
1517                 case 'I':
1518                   // Hour [01, 12]. [tm_hour]
1519                   _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2, 
1520                                  __ctype, __err);
1521                   break;
1522                 case 'm':
1523                   // Month [01, 12]. [tm_mon]
1524                   _M_extract_num(__beg, __end, __mem, 1, 12, 2, __ctype, 
1525                                  __err);
1526                   if (!__err)
1527                     __tm->tm_mon = __mem - 1;
1528                   break;
1529                 case 'M':
1530                   // Minute [00, 59]. [tm_min]
1531                   _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
1532                                  __ctype, __err);
1533                   break;
1534                 case 'n':
1535                   if (__ctype.narrow(*__beg, 0) == '\n')
1536                     ++__beg;
1537                   else
1538                     __err |= ios_base::failbit;
1539                   break;
1540                 case 'R':
1541                   // Equivalent to (%H:%M).
1542                   __cs = "%H:%M";
1543                   __ctype.widen(__cs, __cs + 6, __wcs);
1544                   _M_extract_via_format(__beg, __end, __io, __err, __tm, 
1545                                         __wcs);
1546                   break;
1547                 case 'S':
1548                   // Seconds.
1549                   _M_extract_num(__beg, __end, __tm->tm_sec, 0, 59, 2,
1550                                  __ctype, __err);
1551                   break;
1552                 case 't':
1553                   if (__ctype.narrow(*__beg, 0) == '\t')
1554                     ++__beg;
1555                   else
1556                 __err |= ios_base::failbit;
1557                   break;
1558                 case 'T':
1559                   // Equivalent to (%H:%M:%S).
1560                   __cs = "%H:%M:%S";
1561                   __ctype.widen(__cs, __cs + 9, __wcs);
1562                   _M_extract_via_format(__beg, __end, __io, __err, __tm, 
1563                                         __wcs);
1564                   break;
1565                 case 'x':
1566                   // Locale's date.
1567                   const char_type*  __dates[2];
1568                   __tp._M_date_formats(__dates);
1569                   _M_extract_via_format(__beg, __end, __io, __err, __tm, 
1570                                         __dates[0]);
1571                   break;
1572                 case 'X':
1573                   // Locale's time.
1574                   const char_type*  __times[2];
1575                   __tp._M_time_formats(__times);
1576                   _M_extract_via_format(__beg, __end, __io, __err, __tm, 
1577                                         __times[0]);
1578                   break;
1579                 case 'y':
1580                   // Two digit year. [tm_year]
1581                   _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2, 
1582                                  __ctype, __err);
1583                   break;
1584                 case 'Y':
1585                   // Year [1900). [tm_year]
1586                   _M_extract_num(__beg, __end, __mem, 0, 
1587                                  numeric_limits<int>::max(), 4, 
1588                                  __ctype, __err);
1589                   if (!__err)
1590                     __tm->tm_year = __mem - 1900;
1591                   break;
1592                 case 'Z':
1593                   // Timezone info.
1594                   if (__ctype.is(ctype_base::upper, *__beg))
1595                     {
1596                       int __tmp;
1597                       _M_extract_name(__beg, __end, __tmp, 
1598                                       __timepunct<_CharT>::_S_timezones, 
1599                                       14, __err);
1600                       
1601                       // GMT requires special effort.
1602                       char_type __c = *__beg;
1603                       if (!__err && __tmp == 0 
1604                           && (__c == __ctype.widen('-') 
1605                               || __c == __ctype.widen('+')))
1606                         {
1607                           _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
1608                                           __ctype, __err);
1609                           _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
1610                                           __ctype, __err);
1611                         }           
1612                           }
1613                       else
1614                         __err |= ios_base::failbit;
1615                       break;
1616                     default:
1617                       // Not recognized.
1618                       __err |= ios_base::failbit;
1619                     }
1620                 }
1621               else
1622                 {
1623                   // Verify format and input match, extract and discard.
1624                   if (__c == __ctype.narrow(*__beg, 0))
1625                     ++__beg;
1626                   else
1627                     __err |= ios_base::failbit;
1628                 }
1629         }
1630     }
1631
1632   template<typename _CharT, typename _InIter>
1633     void
1634     time_get<_CharT, _InIter>::
1635     _M_extract_num(iter_type& __beg, iter_type& __end, int& __member,
1636                    int __min, int __max, size_t __len, 
1637                    const ctype<_CharT>& __ctype, 
1638                    ios_base::iostate& __err) const
1639     {
1640       size_t __i = 0;
1641       string __digits;
1642       bool __testvalid = true;
1643       char_type __c = *__beg;
1644       while (__beg != __end && __i < __len 
1645              && __ctype.is(ctype_base::digit, __c)) 
1646         {
1647           __digits += __ctype.narrow(__c, 0);
1648           __c = *(++__beg);
1649           ++__i;
1650         }
1651       if (__i == __len)
1652         {
1653           int __value = atoi(__digits.c_str());
1654           if (__min <= __value && __value <= __max)
1655             __member = __value;
1656           else
1657             __testvalid = false;
1658         }
1659       else
1660         __testvalid = false;
1661       if (!__testvalid)
1662         __err |= ios_base::failbit;
1663     }
1664
1665   // Assumptions:
1666   // All elements in __names are unique.
1667   template<typename _CharT, typename _InIter>
1668     void
1669     time_get<_CharT, _InIter>::
1670     _M_extract_name(iter_type& __beg, iter_type& __end, int& __member,
1671                     const _CharT** __names, size_t __indexlen, 
1672                     ios_base::iostate& __err) const
1673     {
1674       typedef char_traits<char_type> __traits_type;
1675       int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int) * __indexlen));
1676       size_t __nmatches = 0;
1677       size_t __pos = 0;
1678       bool __testvalid = true;
1679       const char_type* __name;
1680
1681       char_type __c = *__beg;
1682       // Look for initial matches.
1683       for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
1684         if (__c == __names[__i1][0])
1685           __matches[__nmatches++] = __i1;
1686       
1687       while(__nmatches > 1)
1688         {
1689           // Find smallest matching string.
1690           size_t __minlen = 10;
1691           for (size_t __i2 = 0; __i2 < __nmatches; ++__i2)
1692             __minlen = min(__minlen, 
1693                            __traits_type::length(__names[__matches[__i2]]));
1694           
1695           if (__pos < __minlen && __beg != __end)
1696             {
1697               ++__pos;
1698               __c = *(++__beg);
1699               for (size_t __i3 = 0; __i3 < __nmatches; ++__i3)
1700                 {
1701                   __name = __names[__matches[__i3]];
1702                   if (__name[__pos] != __c)
1703                     __matches[__i3] = __matches[--__nmatches];
1704                 }
1705             }
1706           else
1707             break;
1708         }
1709
1710       if (__nmatches == 1)
1711         {
1712           // Make sure found name is completely extracted.
1713           __name = __names[__matches[0]];
1714           const size_t __len = __traits_type::length(__name);
1715           while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
1716             ++__beg, ++__pos;
1717
1718           if (__len == __pos)
1719             __member = __matches[0];
1720           else
1721             __testvalid = false;
1722         }
1723       else
1724         __testvalid = false;
1725       if (!__testvalid)
1726         __err |= ios_base::failbit;
1727     }
1728
1729   template<typename _CharT, typename _InIter>
1730     _InIter
1731     time_get<_CharT, _InIter>::
1732     do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
1733                 ios_base::iostate& __err, tm* __tm) const
1734     {
1735       _CharT __wcs[3];
1736       const char* __cs = "%X";
1737       locale __loc = __io.getloc();
1738       ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1739       __ctype.widen(__cs, __cs + 3, __wcs);
1740       _M_extract_via_format(__beg, __end, __io, __err, __tm, __wcs);
1741       if (__beg == __end)
1742         __err |= ios_base::eofbit;
1743       return __beg;
1744     }
1745
1746   template<typename _CharT, typename _InIter>
1747     _InIter
1748     time_get<_CharT, _InIter>::
1749     do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
1750                 ios_base::iostate& __err, tm* __tm) const
1751     {
1752       _CharT __wcs[3];
1753       const char* __cs = "%x";
1754       locale __loc = __io.getloc();
1755       ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1756       __ctype.widen(__cs, __cs + 3, __wcs);
1757       _M_extract_via_format(__beg, __end, __io, __err, __tm, __wcs);
1758       if (__beg == __end)
1759         __err |= ios_base::eofbit;
1760       return __beg;
1761     }
1762
1763   template<typename _CharT, typename _InIter>
1764     _InIter
1765     time_get<_CharT, _InIter>::
1766     do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io, 
1767                    ios_base::iostate& __err, tm* __tm) const
1768     {
1769       typedef char_traits<char_type> __traits_type;
1770       locale __loc = __io.getloc();
1771       __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
1772       const char_type*  __days[7];
1773       __tp._M_days_abbreviated(__days);
1774       int __tmpwday;
1775       _M_extract_name(__beg, __end, __tmpwday, __days, 7, __err);
1776
1777       // Check to see if non-abbreviated name exists, and extract.
1778       // NB: Assumes both _M_days and _M_days_abbreviated organized in
1779       // exact same order, first to last, such that the resulting
1780       // __days array with the same index points to a day, and that
1781       // day's abbreviated form.
1782       // NB: Also assumes that an abbreviated name is a subset of the name. 
1783       if (!__err)
1784         {
1785           size_t __pos = __traits_type::length(__days[__tmpwday]);
1786           __tp._M_days(__days);
1787           const char_type* __name = __days[__tmpwday];
1788           if (__name[__pos] == *__beg)
1789             {
1790               // Extract the rest of it.
1791               const size_t __len = __traits_type::length(__name);
1792               while (__pos < __len && __beg != __end 
1793                      && __name[__pos] == *__beg)
1794                 ++__beg, ++__pos;
1795               if (__len != __pos)
1796                 __err |= ios_base::failbit;
1797             }
1798           if (!__err)
1799             __tm->tm_wday = __tmpwday;
1800         }
1801       if (__beg == __end)
1802         __err |= ios_base::eofbit;
1803       return __beg;
1804      }
1805
1806   template<typename _CharT, typename _InIter>
1807     _InIter
1808     time_get<_CharT, _InIter>::
1809     do_get_monthname(iter_type __beg, iter_type __end,
1810                      ios_base& __io, ios_base::iostate& __err, tm* __tm) const
1811     {
1812       typedef char_traits<char_type> __traits_type;
1813       locale __loc = __io.getloc();
1814       __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
1815       const char_type*  __months[12];
1816       __tp._M_months_abbreviated(__months);
1817       int __tmpmon;
1818       _M_extract_name(__beg, __end, __tmpmon, __months, 12, __err);
1819
1820       // Check to see if non-abbreviated name exists, and extract.
1821       // NB: Assumes both _M_months and _M_months_abbreviated organized in
1822       // exact same order, first to last, such that the resulting
1823       // __months array with the same index points to a month, and that
1824       // month's abbreviated form.
1825       // NB: Also assumes that an abbreviated name is a subset of the name. 
1826       if (!__err)
1827         {
1828           size_t __pos = __traits_type::length(__months[__tmpmon]);
1829           __tp._M_months(__months);
1830           const char_type* __name = __months[__tmpmon];
1831           if (__name[__pos] == *__beg)
1832             {
1833               // Extract the rest of it.
1834               const size_t __len = __traits_type::length(__name);
1835               while (__pos < __len && __beg != __end 
1836                      && __name[__pos] == *__beg)
1837                 ++__beg, ++__pos;
1838               if (__len != __pos)
1839                 __err |= ios_base::failbit;
1840             }
1841           if (!__err)
1842             __tm->tm_mon = __tmpmon;
1843         }
1844  
1845       if (__beg == __end)
1846         __err |= ios_base::eofbit;
1847       return __beg;
1848     }
1849
1850   template<typename _CharT, typename _InIter>
1851     _InIter
1852     time_get<_CharT, _InIter>::
1853     do_get_year(iter_type __beg, iter_type __end, ios_base& __io, 
1854                 ios_base::iostate& __err, tm* __tm) const
1855     {
1856       locale __loc = __io.getloc();
1857       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
1858
1859       char_type __c = *__beg;
1860       size_t __i = 0;
1861       string __digits;
1862       while (__i < 4 && __beg != __end && __ctype.is(ctype_base::digit, __c))
1863         {
1864           __digits += __ctype.narrow(__c, 0);
1865           __c = *(++__beg);
1866           ++__i;
1867         }
1868       if (__i == 2 || __i == 4)
1869         {
1870           int __year = atoi(__digits.c_str());
1871           __year = __i == 2 ? __year : __year - 1900; 
1872           __tm->tm_year = __year;
1873         }
1874       else
1875         __err |= ios_base::failbit;
1876       if (__beg == __end)
1877         __err |= ios_base::eofbit;
1878       return __beg;
1879     }
1880
1881   template<typename _CharT, typename _OutIter>
1882     _OutIter
1883     time_put<_CharT, _OutIter>::
1884     put(iter_type __s, ios_base& __io, char_type, const tm* __tm, 
1885         const _CharT* __beg, const _CharT* __end) const
1886     {
1887       locale __loc = __io.getloc();
1888       ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1889       while (__beg != __end)
1890         {
1891           char __c = __ctype.narrow(*__beg, 0);
1892           ++__beg;
1893           if (__c == '%')
1894             {
1895               char __format;
1896               char __mod = 0;
1897               size_t __len = 1; 
1898               __c = __ctype.narrow(*__beg, 0);
1899               ++__beg;
1900               if (__c == 'E' || __c == 'O')
1901                 {
1902                   __mod = __c;
1903                   __format = __ctype.narrow(*__beg, 0);
1904                   ++__beg;
1905                 }
1906               else
1907                 __format = __c;
1908               __s = this->do_put(__s, __io, char_type(), __tm, __format, 
1909                                  __mod);
1910             }
1911           else
1912             {
1913               *__s = __c;
1914               ++__s;
1915             }
1916         }
1917       return __s;
1918     }
1919
1920   template<typename _CharT, typename _OutIter>
1921     _OutIter
1922     time_put<_CharT, _OutIter>::
1923     do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm, 
1924            char __format, char __mod) const
1925     { 
1926       locale __loc = __io.getloc();
1927       ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1928       __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
1929
1930       // NB: This size is arbitrary. Should this be a data member,
1931       // initialized at construction?
1932       const size_t __maxlen = 64;
1933       char_type* __res = static_cast<char_type*>(__builtin_alloca(__maxlen));
1934
1935       // NB: In IEE 1003.1-200x, and perhaps other locale models, it
1936       // is possible that the format character will be longer than one
1937       // character. Possibilities include 'E' or 'O' followed by a
1938       // format character: if __mod is not the default argument, assume
1939       // it's a valid modifier.
1940       char_type __fmt[4];
1941       __fmt[0] = __ctype.widen('%'); 
1942       if (!__mod)
1943         {
1944           __fmt[1] = __format;
1945           __fmt[2] = char_type();
1946         }
1947       else
1948         {
1949           __fmt[1] = __mod;
1950           __fmt[2] = __format;
1951           __fmt[3] = char_type();
1952         }
1953
1954       __tp._M_put_helper(__res, __maxlen, __fmt, __tm);
1955
1956       // Write resulting, fully-formatted string to output iterator.
1957       size_t __len = char_traits<char_type>::length(__res);
1958       for (size_t __i = 0; __i < __len; ++__i, ++__s)
1959         *__s = __res[__i];
1960       return __s;
1961     }
1962
1963
1964   // Generic version does nothing.
1965   template<typename _CharT>
1966     int
1967     collate<_CharT>::_M_compare_helper(const _CharT*, const _CharT*) const
1968     { return 0; }
1969
1970   // Generic version does nothing.
1971   template<typename _CharT>
1972     size_t
1973     collate<_CharT>::_M_transform_helper(_CharT*, const _CharT*, size_t) const
1974     { return 0; }
1975
1976   template<typename _CharT>
1977     int
1978     collate<_CharT>::
1979     do_compare(const _CharT* __lo1, const _CharT* __hi1, 
1980                const _CharT* __lo2, const _CharT* __hi2) const
1981     { 
1982       const string_type __one(__lo1, __hi1);
1983       const string_type __two(__lo2, __hi2);
1984       return _M_compare_helper(__one.c_str(), __two.c_str());
1985     }
1986
1987  template<typename _CharT>
1988     typename collate<_CharT>::string_type
1989     collate<_CharT>::
1990     do_transform(const _CharT* __lo, const _CharT* __hi) const
1991     {
1992       size_t __len = __hi - __lo;
1993       _CharT* __c = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len));
1994       size_t __res = _M_transform_helper(__c, __lo, __len);
1995       if (__res >= __len)
1996         {
1997           // Try to increment size of translated string.
1998           size_t __len2 = __len * 2;
1999           _CharT* __c2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len2));
2000           __res = _M_transform_helper(__c2, __lo, __len);
2001           // XXX Throw exception if still indeterminate?
2002         }
2003       return string_type(__c);
2004     }
2005
2006  template<typename _CharT>
2007     long
2008     collate<_CharT>::
2009     do_hash(const _CharT* __lo, const _CharT* __hi) const
2010     { 
2011       unsigned long __val = 0;
2012       for (; __lo < __hi; ++__lo)
2013         __val = *__lo + ((__val << 7) | 
2014                        (__val >> (numeric_limits<unsigned long>::digits - 1)));
2015       return static_cast<long>(__val);
2016     }
2017
2018   // Construct correctly padded string, as per 22.2.2.2.2
2019   // Assumes 
2020   // __newlen > __oldlen
2021   // __news is allocated for __newlen size
2022   // Used by both num_put and ostream inserters: if __num,
2023   // internal-adjusted objects are padded according to the rules below
2024   // concerning 0[xX] and +-, otherwise, exactly as right-adjusted
2025   // ones are.
2026   template<typename _CharT, typename _Traits>
2027     void
2028     __pad(ios_base& __io, _CharT __fill, _CharT* __news, const _CharT* __olds,
2029           const streamsize __newlen, const streamsize __oldlen, 
2030           const bool __num)
2031     {
2032       typedef _CharT    char_type;
2033       typedef _Traits   traits_type;
2034       typedef typename traits_type::int_type int_type;
2035       
2036       int_type __plen = static_cast<size_t>(__newlen - __oldlen); 
2037       char_type* __pads = static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __plen));
2038       traits_type::assign(__pads, __plen, __fill); 
2039
2040       char_type* __beg;
2041       char_type* __end;
2042       size_t __mod = 0;
2043       size_t __beglen; //either __plen or __oldlen
2044       ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
2045
2046       if (__adjust == ios_base::left)
2047         {
2048           // Padding last.
2049           __beg = const_cast<char_type*>(__olds);
2050           __beglen = __oldlen;
2051           __end = __pads;
2052         }
2053       else if (__adjust == ios_base::internal && __num)
2054         {
2055           // Pad after the sign, if there is one.
2056           // Pad after 0[xX], if there is one.
2057           // Who came up with these rules, anyway? Jeeze.
2058           locale __loc = __io.getloc();
2059           const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
2060           const char_type __minus = __ctype.widen('-');
2061           const char_type __plus = __ctype.widen('+');
2062           bool __testsign = __olds[0] == __minus || __olds[0] == __plus;
2063           bool __testhex = __ctype.widen('0') == __olds[0] 
2064                            && (__ctype.widen('x') == __olds[1] 
2065                                || __ctype.widen('X') == __olds[1]);
2066           if (__testhex)
2067             {
2068               __news[0] = __olds[0]; 
2069               __news[1] = __olds[1];
2070               __mod += 2;
2071               __news += 2;
2072               __beg = __pads;
2073               __beglen = __plen;
2074               __end = const_cast<char_type*>(__olds + __mod);
2075             }
2076           else if (__testsign)
2077             {
2078               __news[0] = __olds[0] == __plus ? __plus : __minus;
2079               ++__mod;
2080               ++__news;
2081               __beg = __pads;
2082               __beglen = __plen;
2083               __end = const_cast<char_type*>(__olds + __mod);
2084             }
2085           else
2086             {
2087               // Padding first.
2088               __beg = __pads;
2089               __beglen = __plen;
2090               __end = const_cast<char_type*>(__olds);
2091             }
2092         }
2093       else
2094         {
2095           // Padding first.
2096           __beg = __pads;
2097           __beglen = __plen;
2098           __end = const_cast<char_type*>(__olds);
2099         }
2100       traits_type::copy(__news, __beg, __beglen);
2101       traits_type::copy(__news + __beglen, __end, __newlen - __beglen - __mod);
2102     }
2103
2104   // NB: Can't have default argument on non-member template, and
2105   // num_put doesn't have a _Traits template parameter, so this
2106   // forwarding template adds in the default template argument.
2107   template<typename _CharT>
2108     void
2109     __pad(ios_base& __io, _CharT __fill, _CharT* __news, const _CharT* __olds,
2110           const streamsize __newlen, const streamsize __oldlen, 
2111           const bool __num)
2112     { 
2113       return __pad<_CharT, char_traits<_CharT> >(__io, __fill, __news, __olds,
2114                                                  __newlen, __oldlen, __num); 
2115     }
2116
2117   // Used by both numeric and monetary facets.
2118   // Check to make sure that the __grouping_tmp string constructed in
2119   // money_get or num_get matches the canonical grouping for a given
2120   // locale.
2121   // __grouping_tmp is parsed L to R
2122   // 1,222,444 == __grouping_tmp of "/1/3/3"
2123   // __grouping is parsed R to L
2124   // 1,222,444 == __grouping of "/3" == "/3/3/3"
2125   template<typename _CharT>
2126     bool
2127     __verify_grouping(const basic_string<_CharT>& __grouping, 
2128                       basic_string<_CharT>& __grouping_tmp)
2129     {         
2130       int __i = 0;
2131       int __j = 0;
2132       const int __len = __grouping.size();
2133       const int __n = __grouping_tmp.size();
2134       bool __test = true;
2135       
2136       // Parsed number groupings have to match the
2137       // numpunct::grouping string exactly, starting at the
2138       // right-most point of the parsed sequence of elements ...
2139       while (__test && __i < __n - 1)
2140         for (__j = 0; __test && __j < __len && __i < __n - 1; ++__j,++__i)
2141           __test &= __grouping[__j] == __grouping_tmp[__n - __i - 1];
2142       // ... but the last parsed grouping can be <= numpunct
2143       // grouping.
2144       __j == __len ? __j = 0 : __j;
2145       __test &= __grouping[__j] >= __grouping_tmp[__n - __i - 1];
2146       return __test;
2147     }
2148
2149   // Used by both numeric and monetary facets.
2150   // Inserts "group separator" characters into an array of characters.
2151   // It's recursive, one iteration per group.  It moves the characters
2152   // in the buffer this way: "xxxx12345" -> "12,345xxx".  Call this
2153   // only with __gbeg != __gend.
2154   template<typename _CharT>
2155     _CharT*
2156     __add_grouping(_CharT* __s, _CharT __sep,  
2157                    const char* __gbeg, const char* __gend, 
2158                    const _CharT* __first, const _CharT* __last)
2159     {
2160       if (__last - __first > *__gbeg)
2161         {
2162           __s = __add_grouping(__s,  __sep, 
2163                                (__gbeg + 1 == __gend ? __gbeg : __gbeg + 1),
2164                                __gend, __first, __last - *__gbeg);
2165           __first = __last - *__gbeg;
2166           *__s++ = __sep;
2167         }
2168       do
2169         *__s++ = *__first++;
2170       while (__first != __last);
2171       return __s;
2172     }
2173 } // namespace std
2174
2175 #endif