contrib/gcc-4.4/libstdc++-v3/include/bits/locale_facets_nonio.tcc

   1 // Locale support -*- C++ -*-
   2
   3 // Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file locale_facets_nonio.tcc
  26  *  This is an internal header file, included by other library headers.
  27  *  You should not attempt to use it directly.
  28  */
  29
  30 #ifndef _LOCALE_FACETS_NONIO_TCC
  31 #define _LOCALE_FACETS_NONIO_TCC 1
  32
  33 #pragma GCC system_header
  34
  35 _GLIBCXX_BEGIN_NAMESPACE(std)
  36
  37   template<typename _CharT, bool _Intl>
  38     struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
  39     {
  40       const __moneypunct_cache<_CharT, _Intl>*
  41       operator() (const locale& __loc) const
  42       {
  43         const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
  44         const locale::facet** __caches = __loc._M_impl->_M_caches;
  45         if (!__caches[__i])
  46           {
  47             __moneypunct_cache<_CharT, _Intl>* __tmp = NULL;
  48             __try
  49               {
  50                 __tmp = new __moneypunct_cache<_CharT, _Intl>;
  51                 __tmp->_M_cache(__loc);
  52               }
  53             __catch(...)
  54               {
  55                 delete __tmp;
  56                 __throw_exception_again;
  57               }
  58             __loc._M_impl->_M_install_cache(__tmp, __i);
  59           }
  60         return static_cast<
  61           const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
  62       }
  63     };
  64
  65   template<typename _CharT, bool _Intl>
  66     void
  67     __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
  68     {
  69       _M_allocated = true;
  70
  71       const moneypunct<_CharT, _Intl>& __mp =
  72         use_facet<moneypunct<_CharT, _Intl> >(__loc);
  73
  74       _M_grouping_size = __mp.grouping().size();
  75       char* __grouping = new char[_M_grouping_size];
  76       __mp.grouping().copy(__grouping, _M_grouping_size);
  77       _M_grouping = __grouping;
  78       _M_use_grouping = (_M_grouping_size
  79                          && static_cast<signed char>(_M_grouping[0]) > 0
  80                          && (_M_grouping[0]
  81                              != __gnu_cxx::__numeric_traits<char>::__max));
  82
  83       _M_decimal_point = __mp.decimal_point();
  84       _M_thousands_sep = __mp.thousands_sep();
  85       _M_frac_digits = __mp.frac_digits();
  86
  87       _M_curr_symbol_size = __mp.curr_symbol().size();
  88       _CharT* __curr_symbol = new _CharT[_M_curr_symbol_size];
  89       __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
  90       _M_curr_symbol = __curr_symbol;
  91
  92       _M_positive_sign_size = __mp.positive_sign().size();
  93       _CharT* __positive_sign = new _CharT[_M_positive_sign_size];
  94       __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
  95       _M_positive_sign = __positive_sign;
  96
  97       _M_negative_sign_size = __mp.negative_sign().size();
  98       _CharT* __negative_sign = new _CharT[_M_negative_sign_size];
  99       __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
 100       _M_negative_sign = __negative_sign;
 101
 102       _M_pos_format = __mp.pos_format();
 103       _M_neg_format = __mp.neg_format();
 104
 105       const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
 106       __ct.widen(money_base::_S_atoms,
 107                  money_base::_S_atoms + money_base::_S_end, _M_atoms);
 108     }
 109
 110 _GLIBCXX_BEGIN_LDBL_NAMESPACE
 111
 112   template<typename _CharT, typename _InIter>
 113     template<bool _Intl>
 114       _InIter
 115       money_get<_CharT, _InIter>::
 116       _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
 117                  ios_base::iostate& __err, string& __units) const
 118       {
 119         typedef char_traits<_CharT>                       __traits_type;
 120         typedef typename string_type::size_type           size_type;
 121         typedef money_base::part                          part;
 122         typedef __moneypunct_cache<_CharT, _Intl>         __cache_type;
 123
 124         const locale& __loc = __io._M_getloc();
 125         const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
 126
 127         __use_cache<__cache_type> __uc;
 128         const __cache_type* __lc = __uc(__loc);
 129         const char_type* __lit = __lc->_M_atoms;
 130
 131         // Deduced sign.
 132         bool __negative = false;
 133         // Sign size.
 134         size_type __sign_size = 0;
 135         // True if sign is mandatory.
 136         const bool __mandatory_sign = (__lc->_M_positive_sign_size
 137                                        && __lc->_M_negative_sign_size);
 138         // String of grouping info from thousands_sep plucked from __units.
 139         string __grouping_tmp;
 140         if (__lc->_M_use_grouping)
 141           __grouping_tmp.reserve(32);
 142         // Last position before the decimal point.
 143         int __last_pos = 0;
 144         // Separator positions, then, possibly, fractional digits.
 145         int __n = 0;
 146         // If input iterator is in a valid state.
 147         bool __testvalid = true;
 148         // Flag marking when a decimal point is found.
 149         bool __testdecfound = false;
 150
 151         // The tentative returned string is stored here.
 152         string __res;
 153         __res.reserve(32);
 154
 155         const char_type* __lit_zero = __lit + money_base::_S_zero;
 156         const money_base::pattern __p = __lc->_M_neg_format;
 157         for (int __i = 0; __i < 4 && __testvalid; ++__i)
 158           {
 159             const part __which = static_cast<part>(__p.field[__i]);
 160             switch (__which)
 161               {
 162               case money_base::symbol:
 163                 // According to 22.2.6.1.2, p2, symbol is required
 164                 // if (__io.flags() & ios_base::showbase), otherwise
 165                 // is optional and consumed only if other characters
 166                 // are needed to complete the format.
 167                 if (__io.flags() & ios_base::showbase || __sign_size > 1
 168                     || __i == 0
 169                     || (__i == 1 && (__mandatory_sign
 170                                      || (static_cast<part>(__p.field[0])
 171                                          == money_base::sign)
 172                                      || (static_cast<part>(__p.field[2])
 173                                          == money_base::space)))
 174                     || (__i == 2 && ((static_cast<part>(__p.field[3])
 175                                       == money_base::value)
 176                                      || (__mandatory_sign
 177                                          && (static_cast<part>(__p.field[3])
 178                                              == money_base::sign)))))
 179                   {
 180                     const size_type __len = __lc->_M_curr_symbol_size;
 181                     size_type __j = 0;
 182                     for (; __beg != __end && __j < __len
 183                            && *__beg == __lc->_M_curr_symbol[__j];
 184                          ++__beg, ++__j);
 185                     if (__j != __len
 186                         && (__j || __io.flags() & ios_base::showbase))
 187                       __testvalid = false;
 188                   }
 189                 break;
 190               case money_base::sign:
 191                 // Sign might not exist, or be more than one character long.
 192                 if (__lc->_M_positive_sign_size && __beg != __end
 193                     && *__beg == __lc->_M_positive_sign[0])
 194                   {
 195                     __sign_size = __lc->_M_positive_sign_size;
 196                     ++__beg;
 197                   }
 198                 else if (__lc->_M_negative_sign_size && __beg != __end
 199                          && *__beg == __lc->_M_negative_sign[0])
 200                   {
 201                     __negative = true;
 202                     __sign_size = __lc->_M_negative_sign_size;
 203                     ++__beg;
 204                   }
 205                 else if (__lc->_M_positive_sign_size
 206                          && !__lc->_M_negative_sign_size)
 207                   // "... if no sign is detected, the result is given the sign
 208                   // that corresponds to the source of the empty string"
 209                   __negative = true;
 210                 else if (__mandatory_sign)
 211                   __testvalid = false;
 212                 break;
 213               case money_base::value:
 214                 // Extract digits, remove and stash away the
 215                 // grouping of found thousands separators.
 216                 for (; __beg != __end; ++__beg)
 217                   {
 218                     const char_type __c = *__beg;
 219                     const char_type* __q = __traits_type::find(__lit_zero,
 220                                                                10, __c);
 221                     if (__q != 0)
 222                       {
 223                         __res += money_base::_S_atoms[__q - __lit];
 224                         ++__n;
 225                       }
 226                     else if (__c == __lc->_M_decimal_point
 227                              && !__testdecfound)
 228                       {
 229                         if (__lc->_M_frac_digits <= 0)
 230                           break;
 231
 232                         __last_pos = __n;
 233                         __n = 0;
 234                         __testdecfound = true;
 235                       }
 236                     else if (__lc->_M_use_grouping
 237                              && __c == __lc->_M_thousands_sep
 238                              && !__testdecfound)
 239                       {
 240                         if (__n)
 241                           {
 242                             // Mark position for later analysis.
 243                             __grouping_tmp += static_cast<char>(__n);
 244                             __n = 0;
 245                           }
 246                         else
 247                           {
 248                             __testvalid = false;
 249                             break;
 250                           }
 251                       }
 252                     else
 253                       break;
 254                   }
 255                 if (__res.empty())
 256                   __testvalid = false;
 257                 break;
 258               case money_base::space:
 259                 // At least one space is required.
 260                 if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
 261                   ++__beg;
 262                 else
 263                   __testvalid = false;
 264               case money_base::none:
 265                 // Only if not at the end of the pattern.
 266                 if (__i != 3)
 267                   for (; __beg != __end
 268                          && __ctype.is(ctype_base::space, *__beg); ++__beg);
 269                 break;
 270               }
 271           }
 272
 273         // Need to get the rest of the sign characters, if they exist.
 274         if (__sign_size > 1 && __testvalid)
 275           {
 276             const char_type* __sign = __negative ? __lc->_M_negative_sign
 277                                                  : __lc->_M_positive_sign;
 278             size_type __i = 1;
 279             for (; __beg != __end && __i < __sign_size
 280                    && *__beg == __sign[__i]; ++__beg, ++__i);
 281
 282             if (__i != __sign_size)
 283               __testvalid = false;
 284           }
 285
 286         if (__testvalid)
 287           {
 288             // Strip leading zeros.
 289             if (__res.size() > 1)
 290               {
 291                 const size_type __first = __res.find_first_not_of('0');
 292                 const bool __only_zeros = __first == string::npos;
 293                 if (__first)
 294                   __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
 295               }
 296
 297             // 22.2.6.1.2, p4
 298             if (__negative && __res[0] != '0')
 299               __res.insert(__res.begin(), '-');
 300
 301             // Test for grouping fidelity.
 302             if (__grouping_tmp.size())
 303               {
 304                 // Add the ending grouping.
 305                 __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
 306                                                                    : __n);
 307                 if (!std::__verify_grouping(__lc->_M_grouping,
 308                                             __lc->_M_grouping_size,
 309                                             __grouping_tmp))
 310                   __err |= ios_base::failbit;
 311               }
 312
 313             // Iff not enough digits were supplied after the decimal-point.
 314             if (__testdecfound && __n != __lc->_M_frac_digits)
 315               __testvalid = false;
 316           }
 317
 318         // Iff valid sequence is not recognized.
 319         if (!__testvalid)
 320           __err |= ios_base::failbit;
 321         else
 322           __units.swap(__res);
 323
 324         // Iff no more characters are available.
 325         if (__beg == __end)
 326           __err |= ios_base::eofbit;
 327         return __beg;
 328       }
 329
 330 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
 331   template<typename _CharT, typename _InIter>
 332     _InIter
 333     money_get<_CharT, _InIter>::
 334     __do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
 335              ios_base::iostate& __err, double& __units) const
 336     {
 337       string __str;
 338       __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
 339                      : _M_extract<false>(__beg, __end, __io, __err, __str);
 340       std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
 341       return __beg;
 342     }
 343 #endif
 344
 345   template<typename _CharT, typename _InIter>
 346     _InIter
 347     money_get<_CharT, _InIter>::
 348     do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
 349            ios_base::iostate& __err, long double& __units) const
 350     {
 351       string __str;
 352       __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
 353                      : _M_extract<false>(__beg, __end, __io, __err, __str);
 354       std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
 355       return __beg;
 356     }
 357
 358   template<typename _CharT, typename _InIter>
 359     _InIter
 360     money_get<_CharT, _InIter>::
 361     do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
 362            ios_base::iostate& __err, string_type& __digits) const
 363     {
 364       typedef typename string::size_type                  size_type;
 365
 366       const locale& __loc = __io._M_getloc();
 367       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
 368
 369       string __str;
 370       __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
 371                      : _M_extract<false>(__beg, __end, __io, __err, __str);
 372       const size_type __len = __str.size();
 373       if (__len)
 374         {
 375           __digits.resize(__len);
 376           __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
 377         }
 378       return __beg;
 379     }
 380
 381   template<typename _CharT, typename _OutIter>
 382     template<bool _Intl>
 383       _OutIter
 384       money_put<_CharT, _OutIter>::
 385       _M_insert(iter_type __s, ios_base& __io, char_type __fill,
 386                 const string_type& __digits) const
 387       {
 388         typedef typename string_type::size_type           size_type;
 389         typedef money_base::part                          part;
 390         typedef __moneypunct_cache<_CharT, _Intl>         __cache_type;
 391
 392         const locale& __loc = __io._M_getloc();
 393         const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
 394
 395         __use_cache<__cache_type> __uc;
 396         const __cache_type* __lc = __uc(__loc);
 397         const char_type* __lit = __lc->_M_atoms;
 398
 399         // Determine if negative or positive formats are to be used, and
 400         // discard leading negative_sign if it is present.
 401         const char_type* __beg = __digits.data();
 402
 403         money_base::pattern __p;
 404         const char_type* __sign;
 405         size_type __sign_size;
 406         if (!(*__beg == __lit[money_base::_S_minus]))
 407           {
 408             __p = __lc->_M_pos_format;
 409             __sign = __lc->_M_positive_sign;
 410             __sign_size = __lc->_M_positive_sign_size;
 411           }
 412         else
 413           {
 414             __p = __lc->_M_neg_format;
 415             __sign = __lc->_M_negative_sign;
 416             __sign_size = __lc->_M_negative_sign_size;
 417             if (__digits.size())
 418               ++__beg;
 419           }
 420
 421         // Look for valid numbers in the ctype facet within input digits.
 422         size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
 423                                            __beg + __digits.size()) - __beg;
 424         if (__len)
 425           {
 426             // Assume valid input, and attempt to format.
 427             // Break down input numbers into base components, as follows:
 428             //   final_value = grouped units + (decimal point) + (digits)
 429             string_type __value;
 430             __value.reserve(2 * __len);
 431
 432             // Add thousands separators to non-decimal digits, per
 433             // grouping rules.
 434             long __paddec = __len - __lc->_M_frac_digits;
 435             if (__paddec > 0)
 436               {
 437                 if (__lc->_M_frac_digits < 0)
 438                   __paddec = __len;
 439                 if (__lc->_M_grouping_size)
 440                   {
 441                     __value.assign(2 * __paddec, char_type());
 442                     _CharT* __vend =
 443                       std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
 444                                           __lc->_M_grouping,
 445                                           __lc->_M_grouping_size,
 446                                           __beg, __beg + __paddec);
 447                     __value.erase(__vend - &__value[0]);
 448                   }
 449                 else
 450                   __value.assign(__beg, __paddec);
 451               }
 452
 453             // Deal with decimal point, decimal digits.
 454             if (__lc->_M_frac_digits > 0)
 455               {
 456                 __value += __lc->_M_decimal_point;
 457                 if (__paddec >= 0)
 458                   __value.append(__beg + __paddec, __lc->_M_frac_digits);
 459                 else
 460                   {
 461                     // Have to pad zeros in the decimal position.
 462                     __value.append(-__paddec, __lit[money_base::_S_zero]);
 463                     __value.append(__beg, __len);
 464                   }
 465               }
 466
 467             // Calculate length of resulting string.
 468             const ios_base::fmtflags __f = __io.flags()
 469                                            & ios_base::adjustfield;
 470             __len = __value.size() + __sign_size;
 471             __len += ((__io.flags() & ios_base::showbase)
 472                       ? __lc->_M_curr_symbol_size : 0);
 473
 474             string_type __res;
 475             __res.reserve(2 * __len);
 476
 477             const size_type __width = static_cast<size_type>(__io.width());
 478             const bool __testipad = (__f == ios_base::internal
 479                                      && __len < __width);
 480             // Fit formatted digits into the required pattern.
 481             for (int __i = 0; __i < 4; ++__i)
 482               {
 483                 const part __which = static_cast<part>(__p.field[__i]);
 484                 switch (__which)
 485                   {
 486                   case money_base::symbol:
 487                     if (__io.flags() & ios_base::showbase)
 488                       __res.append(__lc->_M_curr_symbol,
 489                                    __lc->_M_curr_symbol_size);
 490                     break;
 491                   case money_base::sign:
 492                     // Sign might not exist, or be more than one
 493                     // character long. In that case, add in the rest
 494                     // below.
 495                     if (__sign_size)
 496                       __res += __sign[0];
 497                     break;
 498                   case money_base::value:
 499                     __res += __value;
 500                     break;
 501                   case money_base::space:
 502                     // At least one space is required, but if internal
 503                     // formatting is required, an arbitrary number of
 504                     // fill spaces will be necessary.
 505                     if (__testipad)
 506                       __res.append(__width - __len, __fill);
 507                     else
 508                       __res += __fill;
 509                     break;
 510                   case money_base::none:
 511                     if (__testipad)
 512                       __res.append(__width - __len, __fill);
 513                     break;
 514                   }
 515               }
 516
 517             // Special case of multi-part sign parts.
 518             if (__sign_size > 1)
 519               __res.append(__sign + 1, __sign_size - 1);
 520
 521             // Pad, if still necessary.
 522             __len = __res.size();
 523             if (__width > __len)
 524               {
 525                 if (__f == ios_base::left)
 526                   // After.
 527                   __res.append(__width - __len, __fill);
 528                 else
 529                   // Before.
 530                   __res.insert(0, __width - __len, __fill);
 531                 __len = __width;
 532               }
 533
 534             // Write resulting, fully-formatted string to output iterator.
 535             __s = std::__write(__s, __res.data(), __len);
 536           }
 537         __io.width(0);
 538         return __s;
 539       }
 540
 541 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
 542   template<typename _CharT, typename _OutIter>
 543     _OutIter
 544     money_put<_CharT, _OutIter>::
 545     __do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
 546              double __units) const
 547     { return this->do_put(__s, __intl, __io, __fill, (long double) __units); }
 548 #endif
 549
 550   template<typename _CharT, typename _OutIter>
 551     _OutIter
 552     money_put<_CharT, _OutIter>::
 553     do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
 554            long double __units) const
 555     {
 556       const locale __loc = __io.getloc();
 557       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
 558 #ifdef _GLIBCXX_USE_C99
 559       // First try a buffer perhaps big enough.
 560       int __cs_size = 64;
 561       char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
 562       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 563       // 328. Bad sprintf format modifier in money_put<>::do_put()
 564       int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
 565                                         "%.*Lf", 0, __units);
 566       // If the buffer was not large enough, try again with the correct size.
 567       if (__len >= __cs_size)
 568         {
 569           __cs_size = __len + 1;
 570           __cs = static_cast<char*>(__builtin_alloca(__cs_size));
 571           __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
 572                                         "%.*Lf", 0, __units);
 573         }
 574 #else
 575       // max_exponent10 + 1 for the integer part, + 2 for sign and '\0'.
 576       const int __cs_size =
 577         __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 3;
 578       char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
 579       int __len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, "%.*Lf",
 580                                         0, __units);
 581 #endif
 582       string_type __digits(__len, char_type());
 583       __ctype.widen(__cs, __cs + __len, &__digits[0]);
 584       return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
 585                     : _M_insert<false>(__s, __io, __fill, __digits);
 586     }
 587
 588   template<typename _CharT, typename _OutIter>
 589     _OutIter
 590     money_put<_CharT, _OutIter>::
 591     do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
 592            const string_type& __digits) const
 593     { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
 594                     : _M_insert<false>(__s, __io, __fill, __digits); }
 595
 596 _GLIBCXX_END_LDBL_NAMESPACE
 597
 598   // NB: Not especially useful. Without an ios_base object or some
 599   // kind of locale reference, we are left clawing at the air where
 600   // the side of the mountain used to be...
 601   template<typename _CharT, typename _InIter>
 602     time_base::dateorder
 603     time_get<_CharT, _InIter>::do_date_order() const
 604     { return time_base::no_order; }
 605
 606   // Expand a strftime format string and parse it.  E.g., do_get_date() may
 607   // pass %m/%d/%Y => extracted characters.
 608   template<typename _CharT, typename _InIter>
 609     _InIter
 610     time_get<_CharT, _InIter>::
 611     _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
 612                           ios_base::iostate& __err, tm* __tm,
 613                           const _CharT* __format) const
 614     {
 615       const locale& __loc = __io._M_getloc();
 616       const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
 617       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
 618       const size_t __len = char_traits<_CharT>::length(__format);
 619
 620       ios_base::iostate __tmperr = ios_base::goodbit;
 621       for (size_t __i = 0; __beg != __end && __i < __len && !__tmperr; ++__i)
 622         {
 623           if (__ctype.narrow(__format[__i], 0) == '%')
 624             {
 625               // Verify valid formatting code, attempt to extract.
 626               char __c = __ctype.narrow(__format[++__i], 0);
 627               int __mem = 0;
 628               if (__c == 'E' || __c == 'O')
 629                 __c = __ctype.narrow(__format[++__i], 0);
 630               switch (__c)
 631                 {
 632                   const char* __cs;
 633                   _CharT __wcs[10];
 634                 case 'a':
 635                   // Abbreviated weekday name [tm_wday]
 636                   const char_type*  __days1[7];
 637                   __tp._M_days_abbreviated(__days1);
 638                   __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
 639                                           7, __io, __tmperr);
 640                   break;
 641                 case 'A':
 642                   // Weekday name [tm_wday].
 643                   const char_type*  __days2[7];
 644                   __tp._M_days(__days2);
 645                   __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
 646                                           7, __io, __tmperr);
 647                   break;
 648                 case 'h':
 649                 case 'b':
 650                   // Abbreviated month name [tm_mon]
 651                   const char_type*  __months1[12];
 652                   __tp._M_months_abbreviated(__months1);
 653                   __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
 654                                           __months1, 12, __io, __tmperr);
 655                   break;
 656                 case 'B':
 657                   // Month name [tm_mon].
 658                   const char_type*  __months2[12];
 659                   __tp._M_months(__months2);
 660                   __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
 661                                           __months2, 12, __io, __tmperr);
 662                   break;
 663                 case 'c':
 664                   // Default time and date representation.
 665                   const char_type*  __dt[2];
 666                   __tp._M_date_time_formats(__dt);
 667                   __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
 668                                                 __tm, __dt[0]);
 669                   break;
 670                 case 'd':
 671                   // Day [01, 31]. [tm_mday]
 672                   __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
 673                                          __io, __tmperr);
 674                   break;
 675                 case 'e':
 676                   // Day [1, 31], with single digits preceded by
 677                   // space. [tm_mday]
 678                   if (__ctype.is(ctype_base::space, *__beg))
 679                     __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
 680                                            1, __io, __tmperr);
 681                   else
 682                     __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
 683                                            2, __io, __tmperr);
 684                   break;
 685                 case 'D':
 686                   // Equivalent to %m/%d/%y.[tm_mon, tm_mday, tm_year]
 687                   __cs = "%m/%d/%y";
 688                   __ctype.widen(__cs, __cs + 9, __wcs);
 689                   __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
 690                                                 __tm, __wcs);
 691                   break;
 692                 case 'H':
 693                   // Hour [00, 23]. [tm_hour]
 694                   __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
 695                                          __io, __tmperr);
 696                   break;
 697                 case 'I':
 698                   // Hour [01, 12]. [tm_hour]
 699                   __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
 700                                          __io, __tmperr);
 701                   break;
 702                 case 'm':
 703                   // Month [01, 12]. [tm_mon]
 704                   __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
 705                                          __io, __tmperr);
 706                   if (!__tmperr)
 707                     __tm->tm_mon = __mem - 1;
 708                   break;
 709                 case 'M':
 710                   // Minute [00, 59]. [tm_min]
 711                   __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
 712                                          __io, __tmperr);
 713                   break;
 714                 case 'n':
 715                   if (__ctype.narrow(*__beg, 0) == '\n')
 716                     ++__beg;
 717                   else
 718                     __tmperr |= ios_base::failbit;
 719                   break;
 720                 case 'R':
 721                   // Equivalent to (%H:%M).
 722                   __cs = "%H:%M";
 723                   __ctype.widen(__cs, __cs + 6, __wcs);
 724                   __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
 725                                                 __tm, __wcs);
 726                   break;
 727                 case 'S':
 728                   // Seconds. [tm_sec]
 729                   // [00, 60] in C99 (one leap-second), [00, 61] in C89.
 730 #ifdef _GLIBCXX_USE_C99
 731                   __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
 732 #else
 733                   __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 61, 2,
 734 #endif
 735                                          __io, __tmperr);
 736                   break;
 737                 case 't':
 738                   if (__ctype.narrow(*__beg, 0) == '\t')
 739                     ++__beg;
 740                   else
 741                     __tmperr |= ios_base::failbit;
 742                   break;
 743                 case 'T':
 744                   // Equivalent to (%H:%M:%S).
 745                   __cs = "%H:%M:%S";
 746                   __ctype.widen(__cs, __cs + 9, __wcs);
 747                   __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
 748                                                 __tm, __wcs);
 749                   break;
 750                 case 'x':
 751                   // Locale's date.
 752                   const char_type*  __dates[2];
 753                   __tp._M_date_formats(__dates);
 754                   __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
 755                                                 __tm, __dates[0]);
 756                   break;
 757                 case 'X':
 758                   // Locale's time.
 759                   const char_type*  __times[2];
 760                   __tp._M_time_formats(__times);
 761                   __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
 762                                                 __tm, __times[0]);
 763                   break;
 764                 case 'y':
 765                 case 'C': // C99
 766                   // Two digit year. [tm_year]
 767                   __beg = _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2,
 768                                          __io, __tmperr);
 769                   break;
 770                 case 'Y':
 771                   // Year [1900). [tm_year]
 772                   __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
 773                                          __io, __tmperr);
 774                   if (!__tmperr)
 775                     __tm->tm_year = __mem - 1900;
 776                   break;
 777                 case 'Z':
 778                   // Timezone info.
 779                   if (__ctype.is(ctype_base::upper, *__beg))
 780                     {
 781                       int __tmp;
 782                       __beg = _M_extract_name(__beg, __end, __tmp,
 783                                        __timepunct_cache<_CharT>::_S_timezones,
 784                                               14, __io, __tmperr);
 785
 786                       // GMT requires special effort.
 787                       if (__beg != __end && !__tmperr && __tmp == 0
 788                           && (*__beg == __ctype.widen('-')
 789                               || *__beg == __ctype.widen('+')))
 790                         {
 791                           __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
 792                                                  __io, __tmperr);
 793                           __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
 794                                                  __io, __tmperr);
 795                         }
 796                     }
 797                   else
 798                     __tmperr |= ios_base::failbit;
 799                   break;
 800                 default:
 801                   // Not recognized.
 802                   __tmperr |= ios_base::failbit;
 803                 }
 804             }
 805           else
 806             {
 807               // Verify format and input match, extract and discard.
 808               if (__format[__i] == *__beg)
 809                 ++__beg;
 810               else
 811                 __tmperr |= ios_base::failbit;
 812             }
 813         }
 814
 815       if (__tmperr)
 816         __err |= ios_base::failbit;
 817
 818       return __beg;
 819     }
 820
 821   template<typename _CharT, typename _InIter>
 822     _InIter
 823     time_get<_CharT, _InIter>::
 824     _M_extract_num(iter_type __beg, iter_type __end, int& __member,
 825                    int __min, int __max, size_t __len,
 826                    ios_base& __io, ios_base::iostate& __err) const
 827     {
 828       const locale& __loc = __io._M_getloc();
 829       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
 830
 831       // As-is works for __len = 1, 2, 4, the values actually used.
 832       int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
 833
 834       ++__min;
 835       size_t __i = 0;
 836       int __value = 0;
 837       for (; __beg != __end && __i < __len; ++__beg, ++__i)
 838         {
 839           const char __c = __ctype.narrow(*__beg, '*');
 840           if (__c >= '0' && __c <= '9')
 841             {
 842               __value = __value * 10 + (__c - '0');
 843               const int __valuec = __value * __mult;
 844               if (__valuec > __max || __valuec + __mult < __min)
 845                 break;
 846               __mult /= 10;
 847             }
 848           else
 849             break;
 850         }
 851       if (__i == __len)
 852         __member = __value;
 853       else
 854         __err |= ios_base::failbit;
 855
 856       return __beg;
 857     }
 858
 859   // Assumptions:
 860   // All elements in __names are unique.
 861   template<typename _CharT, typename _InIter>
 862     _InIter
 863     time_get<_CharT, _InIter>::
 864     _M_extract_name(iter_type __beg, iter_type __end, int& __member,
 865                     const _CharT** __names, size_t __indexlen,
 866                     ios_base& __io, ios_base::iostate& __err) const
 867     {
 868       typedef char_traits<_CharT>               __traits_type;
 869       const locale& __loc = __io._M_getloc();
 870       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
 871
 872       int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
 873                                                           * __indexlen));
 874       size_t __nmatches = 0;
 875       size_t __pos = 0;
 876       bool __testvalid = true;
 877       const char_type* __name;
 878
 879       // Look for initial matches.
 880       // NB: Some of the locale data is in the form of all lowercase
 881       // names, and some is in the form of initially-capitalized
 882       // names. Look for both.
 883       if (__beg != __end)
 884         {
 885           const char_type __c = *__beg;
 886           for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
 887             if (__c == __names[__i1][0]
 888                 || __c == __ctype.toupper(__names[__i1][0]))
 889               __matches[__nmatches++] = __i1;
 890         }
 891
 892       while (__nmatches > 1)
 893         {
 894           // Find smallest matching string.
 895           size_t __minlen = __traits_type::length(__names[__matches[0]]);
 896           for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
 897             __minlen = std::min(__minlen,
 898                               __traits_type::length(__names[__matches[__i2]]));
 899           ++__beg, ++__pos;
 900           if (__pos < __minlen && __beg != __end)
 901             for (size_t __i3 = 0; __i3 < __nmatches;)
 902               {
 903                 __name = __names[__matches[__i3]];
 904                 if (!(__name[__pos] == *__beg))
 905                   __matches[__i3] = __matches[--__nmatches];
 906                 else
 907                   ++__i3;
 908               }
 909           else
 910             break;
 911         }
 912
 913       if (__nmatches == 1)
 914         {
 915           // Make sure found name is completely extracted.
 916           ++__beg, ++__pos;
 917           __name = __names[__matches[0]];
 918           const size_t __len = __traits_type::length(__name);
 919           while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
 920             ++__beg, ++__pos;
 921
 922           if (__len == __pos)
 923             __member = __matches[0];
 924           else
 925             __testvalid = false;
 926         }
 927       else
 928         __testvalid = false;
 929       if (!__testvalid)
 930         __err |= ios_base::failbit;
 931
 932       return __beg;
 933     }
 934
 935   template<typename _CharT, typename _InIter>
 936     _InIter
 937     time_get<_CharT, _InIter>::
 938     do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
 939                 ios_base::iostate& __err, tm* __tm) const
 940     {
 941       const locale& __loc = __io._M_getloc();
 942       const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
 943       const char_type*  __times[2];
 944       __tp._M_time_formats(__times);
 945       __beg = _M_extract_via_format(__beg, __end, __io, __err,
 946                                     __tm, __times[0]);
 947       if (__beg == __end)
 948         __err |= ios_base::eofbit;
 949       return __beg;
 950     }
 951
 952   template<typename _CharT, typename _InIter>
 953     _InIter
 954     time_get<_CharT, _InIter>::
 955     do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
 956                 ios_base::iostate& __err, tm* __tm) const
 957     {
 958       const locale& __loc = __io._M_getloc();
 959       const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
 960       const char_type*  __dates[2];
 961       __tp._M_date_formats(__dates);
 962       __beg = _M_extract_via_format(__beg, __end, __io, __err,
 963                                     __tm, __dates[0]);
 964       if (__beg == __end)
 965         __err |= ios_base::eofbit;
 966       return __beg;
 967     }
 968
 969   template<typename _CharT, typename _InIter>
 970     _InIter
 971     time_get<_CharT, _InIter>::
 972     do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
 973                    ios_base::iostate& __err, tm* __tm) const
 974     {
 975       typedef char_traits<_CharT>               __traits_type;
 976       const locale& __loc = __io._M_getloc();
 977       const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
 978       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
 979       const char_type*  __days[7];
 980       __tp._M_days_abbreviated(__days);
 981       int __tmpwday;
 982       ios_base::iostate __tmperr = ios_base::goodbit;
 983       __beg = _M_extract_name(__beg, __end, __tmpwday, __days, 7,
 984                               __io, __tmperr);
 985
 986       // Check to see if non-abbreviated name exists, and extract.
 987       // NB: Assumes both _M_days and _M_days_abbreviated organized in
 988       // exact same order, first to last, such that the resulting
 989       // __days array with the same index points to a day, and that
 990       // day's abbreviated form.
 991       // NB: Also assumes that an abbreviated name is a subset of the name.
 992       if (!__tmperr && __beg != __end)
 993         {
 994           size_t __pos = __traits_type::length(__days[__tmpwday]);
 995           __tp._M_days(__days);
 996           const char_type* __name = __days[__tmpwday];
 997           if (__name[__pos] == *__beg)
 998             {
 999               // Extract the rest of it.
1000               const size_t __len = __traits_type::length(__name);
1001               while (__pos < __len && __beg != __end
1002                      && __name[__pos] == *__beg)
1003                 ++__beg, ++__pos;
1004               if (__len != __pos)
1005                 __tmperr |= ios_base::failbit;
1006             }
1007         }
1008       if (!__tmperr)
1009         __tm->tm_wday = __tmpwday;
1010       else
1011         __err |= ios_base::failbit;
1012
1013       if (__beg == __end)
1014         __err |= ios_base::eofbit;
1015       return __beg;
1016      }
1017
1018   template<typename _CharT, typename _InIter>
1019     _InIter
1020     time_get<_CharT, _InIter>::
1021     do_get_monthname(iter_type __beg, iter_type __end,
1022                      ios_base& __io, ios_base::iostate& __err, tm* __tm) const
1023     {
1024       typedef char_traits<_CharT>               __traits_type;
1025       const locale& __loc = __io._M_getloc();
1026       const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
1027       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1028       const char_type*  __months[12];
1029       __tp._M_months_abbreviated(__months);
1030       int __tmpmon;
1031       ios_base::iostate __tmperr = ios_base::goodbit;
1032       __beg = _M_extract_name(__beg, __end, __tmpmon, __months, 12,
1033                               __io, __tmperr);
1034
1035       // Check to see if non-abbreviated name exists, and extract.
1036       // NB: Assumes both _M_months and _M_months_abbreviated organized in
1037       // exact same order, first to last, such that the resulting
1038       // __months array with the same index points to a month, and that
1039       // month's abbreviated form.
1040       // NB: Also assumes that an abbreviated name is a subset of the name.
1041       if (!__tmperr && __beg != __end)
1042         {
1043           size_t __pos = __traits_type::length(__months[__tmpmon]);
1044           __tp._M_months(__months);
1045           const char_type* __name = __months[__tmpmon];
1046           if (__name[__pos] == *__beg)
1047             {
1048               // Extract the rest of it.
1049               const size_t __len = __traits_type::length(__name);
1050               while (__pos < __len && __beg != __end
1051                      && __name[__pos] == *__beg)
1052                 ++__beg, ++__pos;
1053               if (__len != __pos)
1054                 __tmperr |= ios_base::failbit;
1055             }
1056         }
1057       if (!__tmperr)
1058         __tm->tm_mon = __tmpmon;
1059       else
1060         __err |= ios_base::failbit;
1061
1062       if (__beg == __end)
1063         __err |= ios_base::eofbit;
1064       return __beg;
1065     }
1066
1067   template<typename _CharT, typename _InIter>
1068     _InIter
1069     time_get<_CharT, _InIter>::
1070     do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
1071                 ios_base::iostate& __err, tm* __tm) const
1072     {
1073       const locale& __loc = __io._M_getloc();
1074       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1075
1076       size_t __i = 0;
1077       int __value = 0;
1078       for (; __beg != __end && __i < 4; ++__beg, ++__i)
1079         {
1080           const char __c = __ctype.narrow(*__beg, '*');
1081           if (__c >= '0' && __c <= '9')
1082             __value = __value * 10 + (__c - '0');
1083           else
1084             break;
1085         }
1086       if (__i == 2 || __i == 4)
1087         __tm->tm_year = __i == 2 ? __value : __value - 1900;
1088       else
1089         __err |= ios_base::failbit;
1090
1091       if (__beg == __end)
1092         __err |= ios_base::eofbit;
1093       return __beg;
1094     }
1095
1096   template<typename _CharT, typename _OutIter>
1097     _OutIter
1098     time_put<_CharT, _OutIter>::
1099     put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
1100         const _CharT* __beg, const _CharT* __end) const
1101     {
1102       const locale& __loc = __io._M_getloc();
1103       ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1104       for (; __beg != __end; ++__beg)
1105         if (__ctype.narrow(*__beg, 0) != '%')
1106           {
1107             *__s = *__beg;
1108             ++__s;
1109           }
1110         else if (++__beg != __end)
1111           {
1112             char __format;
1113             char __mod = 0;
1114             const char __c = __ctype.narrow(*__beg, 0);
1115             if (__c != 'E' && __c != 'O')
1116               __format = __c;
1117             else if (++__beg != __end)
1118               {
1119                 __mod = __c;
1120                 __format = __ctype.narrow(*__beg, 0);
1121               }
1122             else
1123               break;
1124             __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
1125           }
1126         else
1127           break;
1128       return __s;
1129     }
1130
1131   template<typename _CharT, typename _OutIter>
1132     _OutIter
1133     time_put<_CharT, _OutIter>::
1134     do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
1135            char __format, char __mod) const
1136     {
1137       const locale& __loc = __io._M_getloc();
1138       ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1139       __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
1140
1141       // NB: This size is arbitrary. Should this be a data member,
1142       // initialized at construction?
1143       const size_t __maxlen = 128;
1144       char_type* __res =
1145        static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __maxlen));
1146
1147       // NB: In IEE 1003.1-200x, and perhaps other locale models, it
1148       // is possible that the format character will be longer than one
1149       // character. Possibilities include 'E' or 'O' followed by a
1150       // format character: if __mod is not the default argument, assume
1151       // it's a valid modifier.
1152       char_type __fmt[4];
1153       __fmt[0] = __ctype.widen('%');
1154       if (!__mod)
1155         {
1156           __fmt[1] = __format;
1157           __fmt[2] = char_type();
1158         }
1159       else
1160         {
1161           __fmt[1] = __mod;
1162           __fmt[2] = __format;
1163           __fmt[3] = char_type();
1164         }
1165
1166       __tp._M_put(__res, __maxlen, __fmt, __tm);
1167
1168       // Write resulting, fully-formatted string to output iterator.
1169       return std::__write(__s, __res, char_traits<char_type>::length(__res));
1170     }
1171
1172
1173   // Inhibit implicit instantiations for required instantiations,
1174   // which are defined via explicit instantiations elsewhere.
1175   // NB: This syntax is a GNU extension.
1176 #if _GLIBCXX_EXTERN_TEMPLATE
1177   extern template class moneypunct<char, false>;
1178   extern template class moneypunct<char, true>;
1179   extern template class moneypunct_byname<char, false>;
1180   extern template class moneypunct_byname<char, true>;
1181   extern template class _GLIBCXX_LDBL_NAMESPACE money_get<char>;
1182   extern template class _GLIBCXX_LDBL_NAMESPACE money_put<char>;
1183   extern template class __timepunct<char>;
1184   extern template class time_put<char>;
1185   extern template class time_put_byname<char>;
1186   extern template class time_get<char>;
1187   extern template class time_get_byname<char>;
1188   extern template class messages<char>;
1189   extern template class messages_byname<char>;
1190
1191   extern template
1192     const moneypunct<char, true>&
1193     use_facet<moneypunct<char, true> >(const locale&);
1194
1195   extern template
1196     const moneypunct<char, false>&
1197     use_facet<moneypunct<char, false> >(const locale&);
1198
1199   extern template
1200     const money_put<char>&
1201     use_facet<money_put<char> >(const locale&);
1202
1203   extern template
1204     const money_get<char>&
1205     use_facet<money_get<char> >(const locale&);
1206
1207   extern template
1208     const __timepunct<char>&
1209     use_facet<__timepunct<char> >(const locale&);
1210
1211   extern template
1212     const time_put<char>&
1213     use_facet<time_put<char> >(const locale&);
1214
1215   extern template
1216     const time_get<char>&
1217     use_facet<time_get<char> >(const locale&);
1218
1219   extern template
1220     const messages<char>&
1221     use_facet<messages<char> >(const locale&);
1222
1223   extern template
1224     bool
1225     has_facet<moneypunct<char> >(const locale&);
1226
1227   extern template
1228     bool
1229     has_facet<money_put<char> >(const locale&);
1230
1231   extern template
1232     bool
1233     has_facet<money_get<char> >(const locale&);
1234
1235   extern template
1236     bool
1237     has_facet<__timepunct<char> >(const locale&);
1238
1239   extern template
1240     bool
1241     has_facet<time_put<char> >(const locale&);
1242
1243   extern template
1244     bool
1245     has_facet<time_get<char> >(const locale&);
1246
1247   extern template
1248     bool
1249     has_facet<messages<char> >(const locale&);
1250
1251 #ifdef _GLIBCXX_USE_WCHAR_T
1252   extern template class moneypunct<wchar_t, false>;
1253   extern template class moneypunct<wchar_t, true>;
1254   extern template class moneypunct_byname<wchar_t, false>;
1255   extern template class moneypunct_byname<wchar_t, true>;
1256   extern template class _GLIBCXX_LDBL_NAMESPACE money_get<wchar_t>;
1257   extern template class _GLIBCXX_LDBL_NAMESPACE money_put<wchar_t>;
1258   extern template class __timepunct<wchar_t>;
1259   extern template class time_put<wchar_t>;
1260   extern template class time_put_byname<wchar_t>;
1261   extern template class time_get<wchar_t>;
1262   extern template class time_get_byname<wchar_t>;
1263   extern template class messages<wchar_t>;
1264   extern template class messages_byname<wchar_t>;
1265
1266   extern template
1267     const moneypunct<wchar_t, true>&
1268     use_facet<moneypunct<wchar_t, true> >(const locale&);
1269
1270   extern template
1271     const moneypunct<wchar_t, false>&
1272     use_facet<moneypunct<wchar_t, false> >(const locale&);
1273
1274   extern template
1275     const money_put<wchar_t>&
1276     use_facet<money_put<wchar_t> >(const locale&);
1277
1278   extern template
1279     const money_get<wchar_t>&
1280     use_facet<money_get<wchar_t> >(const locale&);
1281
1282   extern template
1283     const __timepunct<wchar_t>&
1284     use_facet<__timepunct<wchar_t> >(const locale&);
1285
1286   extern template
1287     const time_put<wchar_t>&
1288     use_facet<time_put<wchar_t> >(const locale&);
1289
1290   extern template
1291     const time_get<wchar_t>&
1292     use_facet<time_get<wchar_t> >(const locale&);
1293
1294   extern template
1295     const messages<wchar_t>&
1296     use_facet<messages<wchar_t> >(const locale&);
1297
1298   extern template
1299     bool
1300     has_facet<moneypunct<wchar_t> >(const locale&);
1301
1302   extern template
1303     bool
1304     has_facet<money_put<wchar_t> >(const locale&);
1305
1306   extern template
1307     bool
1308     has_facet<money_get<wchar_t> >(const locale&);
1309
1310   extern template
1311     bool
1312     has_facet<__timepunct<wchar_t> >(const locale&);
1313
1314   extern template
1315     bool
1316     has_facet<time_put<wchar_t> >(const locale&);
1317
1318   extern template
1319     bool
1320     has_facet<time_get<wchar_t> >(const locale&);
1321
1322   extern template
1323     bool
1324     has_facet<messages<wchar_t> >(const locale&);
1325 #endif
1326 #endif
1327
1328 _GLIBCXX_END_NAMESPACE
1329
1330 #endif