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