1 // Locale support -*- C++ -*-
3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
4 // Free Software Foundation, Inc.
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)
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.
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,
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.
31 // Warning: this file is not meant for user inclusion. Use <locale>.
33 #ifndef _LOCALE_FACETS_TCC
34 #define _LOCALE_FACETS_TCC 1
36 #pragma GCC system_header
38 #include <limits> // For numeric_limits
39 #include <typeinfo> // For bad_cast.
40 #include <bits/streambuf_iterator.h>
44 template<typename _Facet>
46 locale::combine(const locale& __other) const
48 _Impl* __tmp = new _Impl(*_M_impl, 1);
51 __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
55 __tmp->_M_remove_reference();
56 __throw_exception_again;
61 template<typename _CharT, typename _Traits, typename _Alloc>
63 locale::operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
64 const basic_string<_CharT, _Traits, _Alloc>& __s2) const
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);
73 * @brief Test for the presence of a facet.
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.
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.
83 template<typename _Facet>
85 has_facet(const locale& __loc) throw()
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]);
93 * @brief Return a facet.
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.
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.
105 template<typename _Facet>
107 use_facet(const locale& __loc)
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]))
113 return static_cast<const _Facet&>(*__facets[__i]);
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>
122 operator() (const locale& __loc) const;
125 template<typename _CharT>
126 struct __use_cache<__numpunct_cache<_CharT> >
128 const __numpunct_cache<_CharT>*
129 operator() (const locale& __loc) const
131 const size_t __i = numpunct<_CharT>::id._M_id();
132 const locale::facet** __caches = __loc._M_impl->_M_caches;
135 __numpunct_cache<_CharT>* __tmp = NULL;
138 __tmp = new __numpunct_cache<_CharT>;
139 __tmp->_M_cache(__loc);
144 __throw_exception_again;
146 __loc._M_impl->_M_install_cache(__tmp, __i);
148 return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
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
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"
161 __verify_grouping(const char* __grouping, size_t __grouping_size,
162 const string& __grouping_tmp);
164 template<typename _CharT, typename _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
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;
177 // True if a mantissa is found.
178 bool __found_mantissa = false;
180 // First check for sign.
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))
189 __xtrc += __plus ? '+' : '-';
194 // Next, look for leading zeros.
195 while (__beg != __end)
197 const char_type __c = *__beg;
198 if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep
199 || __c == __lc->_M_decimal_point)
201 else if (__c == __lit[_S_izero])
203 if (!__found_mantissa)
206 __found_mantissa = true;
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);
221 const char_type* __lit_zero = __lit + _S_izero;
222 const char_type* __q;
223 while (__beg != __end)
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)
230 if (!__found_dec && !__found_sci)
232 // NB: Thousands separator at the beginning of a string
233 // is a no-no, as is two consecutive thousands separators.
236 __found_grouping += static_cast<char>(__sep_pos);
242 __err |= ios_base::failbit;
249 else if (__c == __lc->_M_decimal_point)
251 if (!__found_dec && !__found_sci)
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);
265 else if (__q = __traits_type::find(__lit_zero, 10, __c))
267 __xtrc += _S_atoms_in[__q - __lit];
268 __found_mantissa = true;
272 else if ((__c == __lit[_S_ie] || __c == __lit[_S_iE])
273 && __found_mantissa && !__found_sci)
275 // Scientific notation.
276 if (__found_grouping.size() && !__found_dec)
277 __found_grouping += static_cast<char>(__sep_pos);
281 // Remove optional plus or minus sign, if they exist.
282 if (++__beg != __end)
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))
290 __xtrc += __plus ? '+' : '-';
296 // Not a valid input item.
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())
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);
308 if (!std::__verify_grouping(__lc->_M_grouping, __lc->_M_grouping_size,
310 __err |= ios_base::failbit;
315 __err |= ios_base::eofbit;
319 template<typename _CharT, typename _InIter>
320 template<typename _ValueT>
322 num_get<_CharT, _InIter>::
323 _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
324 ios_base::iostate& __err, _ValueT& __v) const
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;
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);
339 // True if numeric digits are found.
340 bool __found_num = false;
342 // First check for sign.
343 bool __negative = false;
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))
355 // Next, look for leading zeros and check required digits
357 while (__beg != __end)
359 const char_type __c = *__beg;
360 if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep
361 || __c == __lc->_M_decimal_point)
363 else if (__c == __lit[_S_izero] && (!__found_num || __base == 10))
368 else if (__found_num)
370 if (__c == __lit[_S_ix] || __c == __lit[_S_iX])
372 if (__basefield == 0)
380 else if (__basefield == 0)
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;
393 string __found_grouping;
394 if (__lc->_M_use_grouping)
395 __found_grouping.reserve(32);
397 bool __overflow = false;
398 _ValueT __result = 0;
399 const char_type* __lit_zero = __lit + _S_izero;
400 const char_type* __q;
403 const _ValueT __min = numeric_limits<_ValueT>::min() / __base;
404 for (; __beg != __end; ++__beg)
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)
411 // NB: Thousands separator at the beginning of a string
412 // is a no-no, as is two consecutive thousands separators.
415 __found_grouping += static_cast<char>(__sep_pos);
420 __err |= ios_base::failbit;
424 else if (__c == __lc->_M_decimal_point)
426 else if (__q = __traits_type::find(__lit_zero, __len, __c))
428 int __digit = __q - __lit_zero;
431 if (__result < __min)
435 const _ValueT __new_result = __result * __base
437 __overflow |= __new_result > __result;
438 __result = __new_result;
444 // Not a valid input item.
450 const _ValueT __max = numeric_limits<_ValueT>::max() / __base;
451 for (; __beg != __end; ++__beg)
453 const char_type __c = *__beg;
454 if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
458 __found_grouping += static_cast<char>(__sep_pos);
463 __err |= ios_base::failbit;
467 else if (__c == __lc->_M_decimal_point)
469 else if (__q = __traits_type::find(__lit_zero, __len, __c))
471 int __digit = __q - __lit_zero;
474 if (__result > __max)
478 const _ValueT __new_result = __result * __base
480 __overflow |= __new_result < __result;
481 __result = __new_result;
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())
495 // Add the ending grouping.
496 __found_grouping += static_cast<char>(__sep_pos);
498 if (!std::__verify_grouping(__lc->_M_grouping,
499 __lc->_M_grouping_size,
501 __err |= ios_base::failbit;
504 if (!(__err & ios_base::failbit) && !__overflow
508 __err |= ios_base::failbit;
511 __err |= ios_base::eofbit;
515 // _GLIBCXX_RESOLVE_LIB_DEFECTS
516 // 17. Bad bool parsing
517 template<typename _CharT, typename _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
523 if (!(__io.flags() & ios_base::boolalpha))
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.
529 __beg = _M_extract_int(__beg, __end, __io, __err, __l);
530 if (__l == 0 || __l == 1)
533 __err |= ios_base::failbit;
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);
547 for (__n = 0; __beg != __end; ++__n, ++__beg)
550 if (__n < __lc->_M_falsename_size)
551 __testf = *__beg == __lc->_M_falsename[__n];
556 if (__n < __lc->_M_truename_size)
557 __testt = *__beg == __lc->_M_truename[__n];
561 if (!__testf && !__testt)
564 if (__testf && __n == __lc->_M_falsename_size)
566 else if (__testt && __n == __lc->_M_truename_size)
569 __err |= ios_base::failbit;
572 __err |= ios_base::eofbit;
577 template<typename _CharT, typename _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); }
584 template<typename _CharT, typename _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); }
591 template<typename _CharT, typename _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); }
598 template<typename _CharT, typename _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); }
605 #ifdef _GLIBCXX_USE_LONG_LONG
606 template<typename _CharT, typename _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); }
613 template<typename _CharT, typename _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); }
621 template<typename _CharT, typename _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
629 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
630 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
634 template<typename _CharT, typename _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
642 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
643 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
647 template<typename _CharT, typename _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
655 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
656 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
660 template<typename _CharT, typename _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
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);
672 __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
674 // Reset from hex formatted input.
677 if (!(__err & ios_base::failbit))
678 __v = reinterpret_cast<void*>(__ul);
680 __err |= ios_base::failbit;
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>
688 num_put<_CharT, _OutIter>::
689 _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
690 _CharT* __new, const _CharT* __cs, int& __len) const
692 // [22.2.2.2.2] Stage 3.
693 // If necessary, pad.
694 __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, __cs,
696 __len = static_cast<int>(__w);
699 // Forwarding functions to peel signed from unsigned integer types.
700 template<typename _CharT>
702 __int_to_char(_CharT* __bufend, long __v, const _CharT* __lit,
703 ios_base::fmtflags __flags)
705 unsigned long __ul = static_cast<unsigned long>(__v);
712 return __int_to_char(__bufend, __ul, __lit, __flags, __neg);
715 template<typename _CharT>
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); }
721 #ifdef _GLIBCXX_USE_LONG_LONG
722 template<typename _CharT>
724 __int_to_char(_CharT* __bufend, long long __v, const _CharT* __lit,
725 ios_base::fmtflags __flags)
727 unsigned long long __ull = static_cast<unsigned long long>(__v);
734 return __int_to_char(__bufend, __ull, __lit, __flags, __neg);
737 template<typename _CharT>
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); }
744 template<typename _CharT, typename _ValueT>
746 __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
747 ios_base::fmtflags __flags, bool __neg)
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;
754 if (__builtin_expect(__basefield != ios_base::oct &&
755 __basefield != ios_base::hex, true))
760 *__buf-- = __lit[(__v % 10) + __num_base::_S_odigits];
765 *__buf-- = __lit[__num_base::_S_ominus];
766 else if (__flags & ios_base::showpos)
767 *__buf-- = __lit[__num_base::_S_oplus];
769 else if (__basefield == ios_base::oct)
774 *__buf-- = __lit[(__v & 0x7) + __num_base::_S_odigits];
779 *__buf-- = __lit[__num_base::_S_odigits];
784 const bool __uppercase = __flags & ios_base::uppercase;
785 const int __case_offset = __uppercase ? __num_base::_S_oudigits
786 : __num_base::_S_odigits;
789 *__buf-- = __lit[(__v & 0xf) + __case_offset];
796 *__buf-- = __lit[__num_base::_S_ox + __uppercase];
798 *__buf-- = __lit[__num_base::_S_odigits];
801 return __bufend - __buf - 1;
804 template<typename _CharT, typename _OutIter>
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
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)
824 else if (__basefield == ios_base::hex)
831 __p = std::__add_grouping(__new + __off, __sep, __grouping,
832 __grouping_size, __cs + __off,
837 template<typename _CharT, typename _OutIter>
838 template<typename _ValueT>
840 num_put<_CharT, _OutIter>::
841 _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
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;
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)
855 // [22.2.2.2.2] Stage 1, numeric conversion to character.
856 // Result is returned right-justified in the buffer.
858 __len = __int_to_char(__cs + __ilen, __v, __lit, __io.flags());
859 __cs += __ilen - __len;
861 // Add grouping, if necessary.
862 if (__lc->_M_use_grouping)
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)
868 _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
869 __lc->_M_thousands_sep, __io, __cs2, __cs, __len);
874 const streamsize __w = __io.width();
875 if (__w > static_cast<streamsize>(__len))
877 _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
879 _M_pad(__fill, __w, __io, __cs3, __cs, __len);
884 // [22.2.2.2.2] Stage 4.
885 // Write resulting, fully-formatted string to output iterator.
886 return std::__write(__s, __cs, __len);
889 template<typename _CharT, typename _OutIter>
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
896 // _GLIBCXX_RESOLVE_LIB_DEFECTS
897 // 282. What types does numpunct grouping refer to?
898 // Add grouping, if necessary.
900 const int __declen = __p ? __p - __cs : __len;
901 __p2 = std::__add_grouping(__new, __sep, __grouping, __grouping_size,
902 __cs, __cs + __declen);
904 // Tack on decimal part.
905 int __newlen = __p2 - __new;
908 char_traits<_CharT>::copy(__p2, __p, __len - __declen);
909 __newlen += __len - __declen;
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>
927 num_put<_CharT, _OutIter>::
928 _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
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);
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;
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);
952 // [22.2.2.2.2] Stage 1, numeric conversion to character.
954 // Long enough for the max format spec.
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));
963 _S_format_float(__io, __fbuf, __mod);
964 __len = std::__convert_from_v(__cs, __cs_size, __fbuf, __v,
965 _S_get_c_locale(), __prec);
967 // If the buffer was not large enough, try again with the correct size.
968 if (__len >= __cs_size)
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);
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;
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
988 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
990 _S_format_float(__io, __fbuf, __mod);
991 __len = std::__convert_from_v(__cs, 0, __fbuf, __v,
992 _S_get_c_locale(), __prec);
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);
999 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1001 __ctype.widen(__cs, __cs + __len, __ws);
1003 // Replace decimal point.
1004 const _CharT __cdec = __ctype.widen('.');
1005 const _CharT __dec = __lc->_M_decimal_point;
1007 if (__p = char_traits<_CharT>::find(__ws, __len, __cdec))
1008 __ws[__p - __ws] = __dec;
1010 // Add grouping, if necessary.
1011 if (__lc->_M_use_grouping)
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)
1017 _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
1018 __lc->_M_thousands_sep, __p, __ws2, __ws, __len);
1023 const streamsize __w = __io.width();
1024 if (__w > static_cast<streamsize>(__len))
1026 _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1028 _M_pad(__fill, __w, __io, __ws3, __ws, __len);
1033 // [22.2.2.2.2] Stage 4.
1034 // Write resulting, fully-formatted string to output iterator.
1035 return std::__write(__s, __ws, __len);
1038 template<typename _CharT, typename _OutIter>
1040 num_put<_CharT, _OutIter>::
1041 do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
1043 const ios_base::fmtflags __flags = __io.flags();
1044 if ((__flags & ios_base::boolalpha) == 0)
1046 unsigned long __uv = __v;
1047 __s = _M_insert_int(__s, __io, __fill, __uv);
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);
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;
1061 const streamsize __w = __io.width();
1062 if (__w > static_cast<streamsize>(__len))
1065 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1067 _M_pad(__fill, __w, __io, __cs, __name, __len);
1071 __s = std::__write(__s, __name, __len);
1076 template<typename _CharT, typename _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); }
1082 template<typename _CharT, typename _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); }
1089 #ifdef _GLIBCXX_USE_LONG_LONG
1090 template<typename _CharT, typename _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); }
1096 template<typename _CharT, typename _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); }
1104 template<typename _CharT, typename _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); }
1110 template<typename _CharT, typename _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); }
1117 template<typename _CharT, typename _OutIter>
1119 num_put<_CharT, _OutIter>::
1120 do_put(iter_type __s, ios_base& __io, char_type __fill,
1121 const void* __v) const
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));
1130 __s = _M_insert_int(__s, __io, __fill,
1131 reinterpret_cast<unsigned long>(__v));
1132 __io.flags(__flags);
1136 template<typename _CharT, bool _Intl>
1137 struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
1139 const __moneypunct_cache<_CharT, _Intl>*
1140 operator() (const locale& __loc) const
1142 const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
1143 const locale::facet** __caches = __loc._M_impl->_M_caches;
1146 __moneypunct_cache<_CharT, _Intl>* __tmp = NULL;
1149 __tmp = new __moneypunct_cache<_CharT, _Intl>;
1150 __tmp->_M_cache(__loc);
1155 __throw_exception_again;
1157 __loc._M_impl->_M_install_cache(__tmp, __i);
1160 const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
1164 template<typename _CharT, typename _InIter>
1165 template<bool _Intl>
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
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;
1177 const locale& __loc = __io._M_getloc();
1178 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1180 __use_cache<__cache_type> __uc;
1181 const __cache_type* __lc = __uc(__loc);
1182 const char_type* __lit = __lc->_M_atoms;
1185 bool __negative = false;
1187 size_type __sign_size = 0;
1188 // String of grouping info from thousands_sep plucked from __units.
1189 string __grouping_tmp;
1190 if (__lc->_M_use_grouping)
1191 __grouping_tmp.reserve(32);
1192 // Last position before the decimal point.
1194 // Separator positions, then, possibly, fractional digits.
1196 // If input iterator is in a valid state.
1197 bool __testvalid = true;
1198 // Flag marking when a decimal point is found.
1199 bool __testdecfound = false;
1201 // The tentative returned string is stored here.
1205 const char_type* __lit_zero = __lit + _S_zero;
1206 const char_type* __q;
1207 const money_base::pattern __p = __lc->_M_neg_format;
1208 for (int __i = 0; __i < 4 && __testvalid; ++__i)
1210 const part __which = static_cast<part>(__p.field[__i]);
1213 case money_base::symbol:
1214 if (__io.flags() & ios_base::showbase
1215 || __i < 2 || __sign_size > 1
1216 || ((static_cast<part>(__p.field[3]) != money_base::none)
1219 // According to 22.2.6.1.2, p2, symbol is required
1220 // if (__io.flags() & ios_base::showbase), otherwise
1221 // is optional and consumed only if other characters
1222 // are needed to complete the format.
1223 const size_type __len = __lc->_M_curr_symbol_size;
1225 for (; __beg != __end && __j < __len
1226 && *__beg == __lc->_M_curr_symbol[__j];
1228 if (__j != __len && (__io.flags() & ios_base::showbase))
1229 __testvalid = false;
1232 case money_base::sign:
1233 // Sign might not exist, or be more than one character long.
1234 if (__lc->_M_positive_sign_size && __beg != __end
1235 && *__beg == __lc->_M_positive_sign[0])
1237 __sign_size = __lc->_M_positive_sign_size;
1240 else if (__lc->_M_negative_sign_size && __beg != __end
1241 && *__beg == __lc->_M_negative_sign[0])
1244 __sign_size = __lc->_M_negative_sign_size;
1247 else if (__lc->_M_positive_sign_size
1248 && !__lc->_M_negative_sign_size)
1249 // "... if no sign is detected, the result is given the sign
1250 // that corresponds to the source of the empty string"
1252 else if (__lc->_M_positive_sign_size
1253 && __lc->_M_negative_sign_size)
1255 // Sign is mandatory.
1256 __testvalid = false;
1259 case money_base::value:
1260 // Extract digits, remove and stash away the
1261 // grouping of found thousands separators.
1262 for (; __beg != __end; ++__beg)
1263 if (__q = __traits_type::find(__lit_zero, 10, *__beg))
1265 __res += _S_atoms[__q - __lit];
1268 else if (*__beg == __lc->_M_decimal_point && !__testdecfound)
1272 __testdecfound = true;
1274 else if (__lc->_M_use_grouping
1275 && *__beg == __lc->_M_thousands_sep
1280 // Mark position for later analysis.
1281 __grouping_tmp += static_cast<char>(__n);
1286 __testvalid = false;
1293 __testvalid = false;
1295 case money_base::space:
1296 case money_base::none:
1297 // Only if not at the end of the pattern.
1299 for (; __beg != __end
1300 && __ctype.is(ctype_base::space, *__beg); ++__beg);
1305 // Need to get the rest of the sign characters, if they exist.
1306 if (__sign_size > 1 && __testvalid)
1308 const char_type* __sign = __negative ? __lc->_M_negative_sign
1309 : __lc->_M_positive_sign;
1311 for (; __beg != __end && __i < __sign_size
1312 && *__beg == __sign[__i]; ++__beg, ++__i);
1314 if (__i != __sign_size)
1315 __testvalid = false;
1320 // Strip leading zeros.
1321 if (__res.size() > 1)
1323 const size_type __first = __res.find_first_not_of('0');
1324 const bool __only_zeros = __first == string::npos;
1326 __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
1330 if (__negative && __res[0] != '0')
1331 __res.insert(__res.begin(), '-');
1333 // Test for grouping fidelity.
1334 if (__grouping_tmp.size())
1336 // Add the ending grouping.
1337 __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
1339 if (!std::__verify_grouping(__lc->_M_grouping,
1340 __lc->_M_grouping_size,
1342 __testvalid = false;
1345 // Iff not enough digits were supplied after the decimal-point.
1346 if (__testdecfound && __lc->_M_frac_digits > 0
1347 && __n != __lc->_M_frac_digits)
1348 __testvalid = false;
1351 // Iff no more characters are available.
1353 __err |= ios_base::eofbit;
1355 // Iff valid sequence is not recognized.
1357 __err |= ios_base::failbit;
1359 __units.swap(__res);
1364 template<typename _CharT, typename _InIter>
1366 money_get<_CharT, _InIter>::
1367 do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
1368 ios_base::iostate& __err, long double& __units) const
1372 __beg = _M_extract<true>(__beg, __end, __io, __err, __str);
1374 __beg = _M_extract<false>(__beg, __end, __io, __err, __str);
1377 std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
1382 template<typename _CharT, typename _InIter>
1384 money_get<_CharT, _InIter>::
1385 do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
1386 ios_base::iostate& __err, string_type& __units) const
1388 typedef typename string::size_type size_type;
1390 const locale& __loc = __io._M_getloc();
1391 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1394 const iter_type __ret = __intl ? _M_extract<true>(__beg, __end, __io,
1396 : _M_extract<false>(__beg, __end, __io,
1398 const size_type __len = __str.size();
1401 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1403 __ctype.widen(__str.data(), __str.data() + __len, __ws);
1404 __units.assign(__ws, __len);
1410 template<typename _CharT, typename _OutIter>
1411 template<bool _Intl>
1413 money_put<_CharT, _OutIter>::
1414 _M_insert(iter_type __s, ios_base& __io, char_type __fill,
1415 const string_type& __digits) const
1417 typedef typename string_type::size_type size_type;
1418 typedef money_base::part part;
1419 typedef moneypunct<_CharT, _Intl> __moneypunct_type;
1420 typedef typename __moneypunct_type::__cache_type __cache_type;
1422 const locale& __loc = __io._M_getloc();
1423 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1425 __use_cache<__cache_type> __uc;
1426 const __cache_type* __lc = __uc(__loc);
1427 const char_type* __lit = __lc->_M_atoms;
1429 // Determine if negative or positive formats are to be used, and
1430 // discard leading negative_sign if it is present.
1431 const char_type* __beg = __digits.data();
1433 money_base::pattern __p;
1434 const char_type* __sign;
1435 size_type __sign_size;
1436 if (*__beg != __lit[_S_minus])
1438 __p = __lc->_M_pos_format;
1439 __sign = __lc->_M_positive_sign;
1440 __sign_size = __lc->_M_positive_sign_size;
1444 __p = __lc->_M_neg_format;
1445 __sign = __lc->_M_negative_sign;
1446 __sign_size = __lc->_M_negative_sign_size;
1447 if (__digits.size())
1451 // Look for valid numbers in the ctype facet within input digits.
1452 size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
1453 __beg + __digits.size()) - __beg;
1456 // Assume valid input, and attempt to format.
1457 // Break down input numbers into base components, as follows:
1458 // final_value = grouped units + (decimal point) + (digits)
1459 string_type __value;
1460 __value.reserve(2 * __len);
1462 // Add thousands separators to non-decimal digits, per
1464 int __paddec = __len - __lc->_M_frac_digits;
1467 if (__lc->_M_frac_digits < 0)
1469 if (__lc->_M_grouping_size)
1472 static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1475 std::__add_grouping(__ws, __lc->_M_thousands_sep,
1477 __lc->_M_grouping_size,
1478 __beg, __beg + __paddec);
1479 __value.assign(__ws, __ws_end - __ws);
1482 __value.assign(__beg, __paddec);
1485 // Deal with decimal point, decimal digits.
1486 if (__lc->_M_frac_digits > 0)
1488 __value += __lc->_M_decimal_point;
1490 __value.append(__beg + __paddec, __lc->_M_frac_digits);
1493 // Have to pad zeros in the decimal position.
1494 __value.append(-__paddec, __lit[_S_zero]);
1495 __value.append(__beg, __len);
1499 // Calculate length of resulting string.
1500 const ios_base::fmtflags __f = __io.flags() & ios_base::adjustfield;
1501 __len = __value.size() + __sign_size;
1502 __len += ((__io.flags() & ios_base::showbase)
1503 ? __lc->_M_curr_symbol_size : 0);
1506 __res.reserve(2 * __len);
1508 const size_type __width = static_cast<size_type>(__io.width());
1509 const bool __testipad = (__f == ios_base::internal
1510 && __len < __width);
1511 // Fit formatted digits into the required pattern.
1512 for (int __i = 0; __i < 4; ++__i)
1514 const part __which = static_cast<part>(__p.field[__i]);
1517 case money_base::symbol:
1518 if (__io.flags() & ios_base::showbase)
1519 __res.append(__lc->_M_curr_symbol,
1520 __lc->_M_curr_symbol_size);
1522 case money_base::sign:
1523 // Sign might not exist, or be more than one
1524 // charater long. In that case, add in the rest
1529 case money_base::value:
1532 case money_base::space:
1533 // At least one space is required, but if internal
1534 // formatting is required, an arbitrary number of
1535 // fill spaces will be necessary.
1537 __res.append(__width - __len, __fill);
1541 case money_base::none:
1543 __res.append(__width - __len, __fill);
1548 // Special case of multi-part sign parts.
1549 if (__sign_size > 1)
1550 __res.append(__sign + 1, __sign_size - 1);
1552 // Pad, if still necessary.
1553 __len = __res.size();
1554 if (__width > __len)
1556 if (__f == ios_base::left)
1558 __res.append(__width - __len, __fill);
1561 __res.insert(0, __width - __len, __fill);
1565 // Write resulting, fully-formatted string to output iterator.
1566 __s = std::__write(__s, __res.data(), __len);
1572 template<typename _CharT, typename _OutIter>
1574 money_put<_CharT, _OutIter>::
1575 do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
1576 long double __units) const
1578 const locale __loc = __io.getloc();
1579 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1580 #ifdef _GLIBCXX_USE_C99
1581 // First try a buffer perhaps big enough.
1583 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1584 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1585 // 328. Bad sprintf format modifier in money_put<>::do_put()
1586 int __len = std::__convert_from_v(__cs, __cs_size, "%.0Lf", __units,
1588 // If the buffer was not large enough, try again with the correct size.
1589 if (__len >= __cs_size)
1591 __cs_size = __len + 1;
1592 __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1593 __len = std::__convert_from_v(__cs, __cs_size, "%.0Lf", __units,
1597 // max_exponent10 + 1 for the integer part, + 2 for sign and '\0'.
1598 const int __cs_size = numeric_limits<long double>::max_exponent10 + 3;
1599 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1600 int __len = std::__convert_from_v(__cs, 0, "%.0Lf", __units,
1603 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1605 __ctype.widen(__cs, __cs + __len, __ws);
1606 const string_type __digits(__ws, __len);
1607 return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
1608 : _M_insert<false>(__s, __io, __fill, __digits);
1611 template<typename _CharT, typename _OutIter>
1613 money_put<_CharT, _OutIter>::
1614 do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
1615 const string_type& __digits) const
1616 { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
1617 : _M_insert<false>(__s, __io, __fill, __digits); }
1619 // NB: Not especially useful. Without an ios_base object or some
1620 // kind of locale reference, we are left clawing at the air where
1621 // the side of the mountain used to be...
1622 template<typename _CharT, typename _InIter>
1623 time_base::dateorder
1624 time_get<_CharT, _InIter>::do_date_order() const
1625 { return time_base::no_order; }
1627 // Recursively expand a strftime format string and parse it. Starts w/ %x
1628 // and %X from do_get_time() and do_get_date(), which translate to a more
1629 // specific string, which may contain yet more strings. I.e. %x => %r =>
1630 // %H:%M:%S => extracted characters.
1631 template<typename _CharT, typename _InIter>
1633 time_get<_CharT, _InIter>::
1634 _M_extract_via_format(iter_type& __beg, iter_type& __end, ios_base& __io,
1635 ios_base::iostate& __err, tm* __tm,
1636 const _CharT* __format) const
1638 const locale __loc = __io.getloc();
1639 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
1640 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1641 const size_t __len = char_traits<_CharT>::length(__format);
1643 for (size_t __i = 0; __beg != __end && __i < __len && !__err; ++__i)
1645 if (__ctype.narrow(__format[__i], 0) == '%')
1647 // Verify valid formatting code, attempt to extract.
1648 char __c = __ctype.narrow(__format[++__i], 0);
1650 if (__c == 'E' || __c == 'O')
1651 __c = __ctype.narrow(__format[++__i], 0);
1657 // Abbreviated weekday name [tm_wday]
1658 const char_type* __days1[7];
1659 __tp._M_days_abbreviated(__days1);
1660 _M_extract_name(__beg, __end, __tm->tm_wday, __days1, 7,
1664 // Weekday name [tm_wday].
1665 const char_type* __days2[7];
1666 __tp._M_days(__days2);
1667 _M_extract_name(__beg, __end, __tm->tm_wday, __days2, 7,
1672 // Abbreviated month name [tm_mon]
1673 const char_type* __months1[12];
1674 __tp._M_months_abbreviated(__months1);
1675 _M_extract_name(__beg, __end, __tm->tm_mon, __months1, 12,
1679 // Month name [tm_mon].
1680 const char_type* __months2[12];
1681 __tp._M_months(__months2);
1682 _M_extract_name(__beg, __end, __tm->tm_mon, __months2, 12,
1686 // Default time and date representation.
1687 const char_type* __dt[2];
1688 __tp._M_date_time_formats(__dt);
1689 _M_extract_via_format(__beg, __end, __io, __err, __tm,
1693 // Day [01, 31]. [tm_mday]
1694 _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
1698 // Day [1, 31], with single digits preceded by
1700 if (__ctype.is(ctype_base::space, *__beg))
1701 _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9, 1,
1704 _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31, 2,
1708 // Equivalent to %m/%d/%y.[tm_mon, tm_mday, tm_year]
1710 __ctype.widen(__cs, __cs + 9, __wcs);
1711 _M_extract_via_format(__beg, __end, __io, __err, __tm,
1715 // Hour [00, 23]. [tm_hour]
1716 _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
1720 // Hour [01, 12]. [tm_hour]
1721 _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
1725 // Month [01, 12]. [tm_mon]
1726 _M_extract_num(__beg, __end, __mem, 1, 12, 2, __ctype,
1729 __tm->tm_mon = __mem - 1;
1732 // Minute [00, 59]. [tm_min]
1733 _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
1737 if (__ctype.narrow(*__beg, 0) == '\n')
1740 __err |= ios_base::failbit;
1743 // Equivalent to (%H:%M).
1745 __ctype.widen(__cs, __cs + 6, __wcs);
1746 _M_extract_via_format(__beg, __end, __io, __err, __tm,
1751 _M_extract_num(__beg, __end, __tm->tm_sec, 0, 59, 2,
1755 if (__ctype.narrow(*__beg, 0) == '\t')
1758 __err |= ios_base::failbit;
1761 // Equivalent to (%H:%M:%S).
1763 __ctype.widen(__cs, __cs + 9, __wcs);
1764 _M_extract_via_format(__beg, __end, __io, __err, __tm,
1769 const char_type* __dates[2];
1770 __tp._M_date_formats(__dates);
1771 _M_extract_via_format(__beg, __end, __io, __err, __tm,
1776 const char_type* __times[2];
1777 __tp._M_time_formats(__times);
1778 _M_extract_via_format(__beg, __end, __io, __err, __tm,
1783 // Two digit year. [tm_year]
1784 _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2,
1788 // Year [1900). [tm_year]
1789 _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
1792 __tm->tm_year = __mem - 1900;
1796 if (__ctype.is(ctype_base::upper, *__beg))
1799 _M_extract_name(__beg, __end, __tmp,
1800 __timepunct_cache<_CharT>::_S_timezones,
1801 14, __ctype, __err);
1803 // GMT requires special effort.
1804 if (__beg != __end && !__err && __tmp == 0
1805 && (*__beg == __ctype.widen('-')
1806 || *__beg == __ctype.widen('+')))
1808 _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
1810 _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
1815 __err |= ios_base::failbit;
1819 __err |= ios_base::failbit;
1824 // Verify format and input match, extract and discard.
1825 if (__format[__i] == *__beg)
1828 __err |= ios_base::failbit;
1833 template<typename _CharT, typename _InIter>
1835 time_get<_CharT, _InIter>::
1836 _M_extract_num(iter_type& __beg, iter_type& __end, int& __member,
1837 int __min, int __max, size_t __len,
1838 const ctype<_CharT>& __ctype,
1839 ios_base::iostate& __err) const
1841 // As-is works for __len = 1, 2, 4, the values actually used.
1842 int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
1847 for (; __beg != __end && __i < __len; ++__beg, ++__i)
1849 const char __c = __ctype.narrow(*__beg, '*');
1850 if (__c >= '0' && __c <= '9')
1852 __value = __value * 10 + (__c - '0');
1853 const int __valuec = __value * __mult;
1854 if (__valuec > __max || __valuec + __mult < __min)
1864 __err |= ios_base::failbit;
1868 // All elements in __names are unique.
1869 template<typename _CharT, typename _InIter>
1871 time_get<_CharT, _InIter>::
1872 _M_extract_name(iter_type& __beg, iter_type& __end, int& __member,
1873 const _CharT** __names, size_t __indexlen,
1874 const ctype<_CharT>& __ctype,
1875 ios_base::iostate& __err) const
1877 typedef char_traits<_CharT> __traits_type;
1878 int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
1880 size_t __nmatches = 0;
1882 bool __testvalid = true;
1883 const char_type* __name;
1885 // Look for initial matches.
1886 // NB: Some of the locale data is in the form of all lowercase
1887 // names, and some is in the form of initially-capitalized
1888 // names. Look for both.
1891 const char_type __c = *__beg;
1892 for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
1893 if (__c == __names[__i1][0]
1894 || __c == __ctype.toupper(__names[__i1][0]))
1895 __matches[__nmatches++] = __i1;
1898 while (__nmatches > 1)
1900 // Find smallest matching string.
1901 size_t __minlen = 10;
1902 for (size_t __i2 = 0; __i2 < __nmatches; ++__i2)
1903 __minlen = std::min(__minlen,
1904 __traits_type::length(__names[__matches[__i2]]));
1906 if (__pos < __minlen && __beg != __end)
1909 for (size_t __i3 = 0; __i3 < __nmatches; ++__i3)
1911 __name = __names[__matches[__i3]];
1912 if (__name[__pos] != *__beg)
1913 __matches[__i3] = __matches[--__nmatches];
1920 if (__nmatches == 1)
1922 // If there was only one match, the first compare is redundant.
1929 // Make sure found name is completely extracted.
1930 __name = __names[__matches[0]];
1931 const size_t __len = __traits_type::length(__name);
1932 while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
1936 __member = __matches[0];
1938 __testvalid = false;
1941 __testvalid = false;
1943 __err |= ios_base::failbit;
1946 template<typename _CharT, typename _InIter>
1948 time_get<_CharT, _InIter>::
1949 do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
1950 ios_base::iostate& __err, tm* __tm) const
1953 const char* __cs = "%X";
1954 const locale __loc = __io.getloc();
1955 ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1956 __ctype.widen(__cs, __cs + 3, __wcs);
1957 _M_extract_via_format(__beg, __end, __io, __err, __tm, __wcs);
1959 __err |= ios_base::eofbit;
1963 template<typename _CharT, typename _InIter>
1965 time_get<_CharT, _InIter>::
1966 do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
1967 ios_base::iostate& __err, tm* __tm) const
1970 const char* __cs = "%x";
1971 const locale __loc = __io.getloc();
1972 ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1973 __ctype.widen(__cs, __cs + 3, __wcs);
1974 _M_extract_via_format(__beg, __end, __io, __err, __tm, __wcs);
1976 __err |= ios_base::eofbit;
1980 template<typename _CharT, typename _InIter>
1982 time_get<_CharT, _InIter>::
1983 do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
1984 ios_base::iostate& __err, tm* __tm) const
1986 typedef char_traits<_CharT> __traits_type;
1987 const locale __loc = __io.getloc();
1988 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
1989 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1990 const char_type* __days[7];
1991 __tp._M_days_abbreviated(__days);
1993 _M_extract_name(__beg, __end, __tmpwday, __days, 7, __ctype, __err);
1995 // Check to see if non-abbreviated name exists, and extract.
1996 // NB: Assumes both _M_days and _M_days_abbreviated organized in
1997 // exact same order, first to last, such that the resulting
1998 // __days array with the same index points to a day, and that
1999 // day's abbreviated form.
2000 // NB: Also assumes that an abbreviated name is a subset of the name.
2003 size_t __pos = __traits_type::length(__days[__tmpwday]);
2004 __tp._M_days(__days);
2005 const char_type* __name = __days[__tmpwday];
2006 if (__name[__pos] == *__beg)
2008 // Extract the rest of it.
2009 const size_t __len = __traits_type::length(__name);
2010 while (__pos < __len && __beg != __end
2011 && __name[__pos] == *__beg)
2014 __err |= ios_base::failbit;
2017 __tm->tm_wday = __tmpwday;
2020 __err |= ios_base::eofbit;
2024 template<typename _CharT, typename _InIter>
2026 time_get<_CharT, _InIter>::
2027 do_get_monthname(iter_type __beg, iter_type __end,
2028 ios_base& __io, ios_base::iostate& __err, tm* __tm) const
2030 typedef char_traits<_CharT> __traits_type;
2031 const locale __loc = __io.getloc();
2032 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
2033 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2034 const char_type* __months[12];
2035 __tp._M_months_abbreviated(__months);
2037 _M_extract_name(__beg, __end, __tmpmon, __months, 12, __ctype, __err);
2039 // Check to see if non-abbreviated name exists, and extract.
2040 // NB: Assumes both _M_months and _M_months_abbreviated organized in
2041 // exact same order, first to last, such that the resulting
2042 // __months array with the same index points to a month, and that
2043 // month's abbreviated form.
2044 // NB: Also assumes that an abbreviated name is a subset of the name.
2047 size_t __pos = __traits_type::length(__months[__tmpmon]);
2048 __tp._M_months(__months);
2049 const char_type* __name = __months[__tmpmon];
2050 if (__name[__pos] == *__beg)
2052 // Extract the rest of it.
2053 const size_t __len = __traits_type::length(__name);
2054 while (__pos < __len && __beg != __end
2055 && __name[__pos] == *__beg)
2058 __err |= ios_base::failbit;
2061 __tm->tm_mon = __tmpmon;
2065 __err |= ios_base::eofbit;
2069 template<typename _CharT, typename _InIter>
2071 time_get<_CharT, _InIter>::
2072 do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
2073 ios_base::iostate& __err, tm* __tm) const
2075 const locale __loc = __io.getloc();
2076 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2080 for (; __beg != __end && __i < 4; ++__beg, ++__i)
2082 const char __c = __ctype.narrow(*__beg, '*');
2083 if (__c >= '0' && __c <= '9')
2084 __value = __value * 10 + (__c - '0');
2088 if (__i == 2 || __i == 4)
2089 __tm->tm_year = __i == 2 ? __value : __value - 1900;
2091 __err |= ios_base::failbit;
2093 __err |= ios_base::eofbit;
2097 template<typename _CharT, typename _OutIter>
2099 time_put<_CharT, _OutIter>::
2100 put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
2101 const _CharT* __beg, const _CharT* __end) const
2103 const locale __loc = __io.getloc();
2104 ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
2105 for (; __beg != __end; ++__beg)
2106 if (__ctype.narrow(*__beg, 0) != '%')
2111 else if (++__beg != __end)
2115 const char __c = __ctype.narrow(*__beg, 0);
2116 if (__c != 'E' && __c != 'O')
2118 else if (++__beg != __end)
2121 __format = __ctype.narrow(*__beg, 0);
2125 __s = this->do_put(__s, __io, __fill, __tm,
2133 template<typename _CharT, typename _OutIter>
2135 time_put<_CharT, _OutIter>::
2136 do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
2137 char __format, char __mod) const
2139 const locale __loc = __io.getloc();
2140 ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
2141 __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
2143 // NB: This size is arbitrary. Should this be a data member,
2144 // initialized at construction?
2145 const size_t __maxlen = 64;
2147 static_cast<char_type*>(__builtin_alloca(sizeof(char_type)
2150 // NB: In IEE 1003.1-200x, and perhaps other locale models, it
2151 // is possible that the format character will be longer than one
2152 // character. Possibilities include 'E' or 'O' followed by a
2153 // format character: if __mod is not the default argument, assume
2154 // it's a valid modifier.
2156 __fmt[0] = __ctype.widen('%');
2159 __fmt[1] = __format;
2160 __fmt[2] = char_type();
2165 __fmt[2] = __format;
2166 __fmt[3] = char_type();
2169 __tp._M_put(__res, __maxlen, __fmt, __tm);
2171 // Write resulting, fully-formatted string to output iterator.
2172 return std::__write(__s, __res, char_traits<char_type>::length(__res));
2176 // Generic version does nothing.
2177 template<typename _CharT>
2179 collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const
2182 // Generic version does nothing.
2183 template<typename _CharT>
2185 collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const
2188 template<typename _CharT>
2191 do_compare(const _CharT* __lo1, const _CharT* __hi1,
2192 const _CharT* __lo2, const _CharT* __hi2) const
2194 // strcoll assumes zero-terminated strings so we make a copy
2195 // and then put a zero at the end.
2196 const string_type __one(__lo1, __hi1);
2197 const string_type __two(__lo2, __hi2);
2199 const _CharT* __p = __one.c_str();
2200 const _CharT* __pend = __one.data() + __one.length();
2201 const _CharT* __q = __two.c_str();
2202 const _CharT* __qend = __two.data() + __two.length();
2204 // strcoll stops when it sees a nul character so we break
2205 // the strings into zero-terminated substrings and pass those
2209 const int __res = _M_compare(__p, __q);
2213 __p += char_traits<_CharT>::length(__p);
2214 __q += char_traits<_CharT>::length(__q);
2215 if (__p == __pend && __q == __qend)
2217 else if (__p == __pend)
2219 else if (__q == __qend)
2227 template<typename _CharT>
2228 typename collate<_CharT>::string_type
2230 do_transform(const _CharT* __lo, const _CharT* __hi) const
2232 // strxfrm assumes zero-terminated strings so we make a copy
2233 string_type __str(__lo, __hi);
2235 const _CharT* __p = __str.c_str();
2236 const _CharT* __pend = __str.data() + __str.length();
2238 size_t __len = (__hi - __lo) * 2;
2242 // strxfrm stops when it sees a nul character so we break
2243 // the string into zero-terminated substrings and pass those
2247 // First try a buffer perhaps big enough.
2249 static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len));
2250 size_t __res = _M_transform(__c, __p, __len);
2251 // If the buffer was not large enough, try again with the
2256 __c = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
2258 __res = _M_transform(__c, __p, __res + 1);
2261 __ret.append(__c, __res);
2262 __p += char_traits<_CharT>::length(__p);
2267 __ret.push_back(_CharT());
2271 template<typename _CharT>
2274 do_hash(const _CharT* __lo, const _CharT* __hi) const
2276 unsigned long __val = 0;
2277 for (; __lo < __hi; ++__lo)
2278 __val = *__lo + ((__val << 7) |
2279 (__val >> (numeric_limits<unsigned long>::digits - 7)));
2280 return static_cast<long>(__val);
2283 // Construct correctly padded string, as per 22.2.2.2.2
2285 // __newlen > __oldlen
2286 // __news is allocated for __newlen size
2287 // Used by both num_put and ostream inserters: if __num,
2288 // internal-adjusted objects are padded according to the rules below
2289 // concerning 0[xX] and +-, otherwise, exactly as right-adjusted
2292 // NB: Of the two parameters, _CharT can be deduced from the
2293 // function arguments. The other (_Traits) has to be explicitly specified.
2294 template<typename _CharT, typename _Traits>
2296 __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
2297 _CharT* __news, const _CharT* __olds,
2298 const streamsize __newlen,
2299 const streamsize __oldlen, const bool __num)
2301 const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
2302 const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
2305 if (__adjust == ios_base::left)
2307 _Traits::copy(__news, const_cast<_CharT*>(__olds), __oldlen);
2308 _Traits::assign(__news + __oldlen, __plen, __fill);
2313 if (__adjust == ios_base::internal && __num)
2315 // Pad after the sign, if there is one.
2316 // Pad after 0[xX], if there is one.
2317 // Who came up with these rules, anyway? Jeeze.
2318 const locale& __loc = __io._M_getloc();
2319 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2321 const bool __testsign = (__ctype.widen('-') == __olds[0]
2322 || __ctype.widen('+') == __olds[0]);
2323 const bool __testhex = (__ctype.widen('0') == __olds[0]
2325 && (__ctype.widen('x') == __olds[1]
2326 || __ctype.widen('X') == __olds[1]));
2329 __news[0] = __olds[0];
2330 __news[1] = __olds[1];
2334 else if (__testsign)
2336 __news[0] = __olds[0];
2340 // else Padding first.
2342 _Traits::assign(__news, __plen, __fill);
2343 _Traits::copy(__news + __plen, const_cast<_CharT*>(__olds + __mod),
2348 __verify_grouping(const char* __grouping, size_t __grouping_size,
2349 const string& __grouping_tmp)
2351 const size_t __n = __grouping_tmp.size() - 1;
2352 const size_t __min = std::min(__n, __grouping_size - 1);
2356 // Parsed number groupings have to match the
2357 // numpunct::grouping string exactly, starting at the
2358 // right-most point of the parsed sequence of elements ...
2359 for (size_t __j = 0; __j < __min && __test; --__i, ++__j)
2360 __test = __grouping_tmp[__i] == __grouping[__j];
2361 for (; __i && __test; --__i)
2362 __test = __grouping_tmp[__i] == __grouping[__min];
2363 // ... but the last parsed grouping can be <= numpunct
2365 __test &= __grouping_tmp[0] <= __grouping[__min];
2369 template<typename _CharT>
2371 __add_grouping(_CharT* __s, _CharT __sep,
2372 const char* __gbeg, size_t __gsize,
2373 const _CharT* __first, const _CharT* __last)
2375 if (__last - __first > *__gbeg)
2377 const bool __bump = __gsize != 1;
2378 __s = std::__add_grouping(__s, __sep, __gbeg + __bump,
2379 __gsize - __bump, __first,
2381 __first = __last - *__gbeg;
2385 *__s++ = *__first++;
2386 while (__first != __last);
2390 // Inhibit implicit instantiations for required instantiations,
2391 // which are defined via explicit instantiations elsewhere.
2392 // NB: This syntax is a GNU extension.
2393 #if _GLIBCXX_EXTERN_TEMPLATE
2394 extern template class moneypunct<char, false>;
2395 extern template class moneypunct<char, true>;
2396 extern template class moneypunct_byname<char, false>;
2397 extern template class moneypunct_byname<char, true>;
2398 extern template class money_get<char>;
2399 extern template class money_put<char>;
2400 extern template class numpunct<char>;
2401 extern template class numpunct_byname<char>;
2402 extern template class num_get<char>;
2403 extern template class num_put<char>;
2404 extern template class __timepunct<char>;
2405 extern template class time_put<char>;
2406 extern template class time_put_byname<char>;
2407 extern template class time_get<char>;
2408 extern template class time_get_byname<char>;
2409 extern template class messages<char>;
2410 extern template class messages_byname<char>;
2411 extern template class ctype_byname<char>;
2412 extern template class codecvt_byname<char, char, mbstate_t>;
2413 extern template class collate<char>;
2414 extern template class collate_byname<char>;
2417 const codecvt<char, char, mbstate_t>&
2418 use_facet<codecvt<char, char, mbstate_t> >(const locale&);
2421 const collate<char>&
2422 use_facet<collate<char> >(const locale&);
2425 const numpunct<char>&
2426 use_facet<numpunct<char> >(const locale&);
2429 const num_put<char>&
2430 use_facet<num_put<char> >(const locale&);
2433 const num_get<char>&
2434 use_facet<num_get<char> >(const locale&);
2437 const moneypunct<char, true>&
2438 use_facet<moneypunct<char, true> >(const locale&);
2441 const moneypunct<char, false>&
2442 use_facet<moneypunct<char, false> >(const locale&);
2445 const money_put<char>&
2446 use_facet<money_put<char> >(const locale&);
2449 const money_get<char>&
2450 use_facet<money_get<char> >(const locale&);
2453 const __timepunct<char>&
2454 use_facet<__timepunct<char> >(const locale&);
2457 const time_put<char>&
2458 use_facet<time_put<char> >(const locale&);
2461 const time_get<char>&
2462 use_facet<time_get<char> >(const locale&);
2465 const messages<char>&
2466 use_facet<messages<char> >(const locale&);
2470 has_facet<ctype<char> >(const locale&);
2474 has_facet<codecvt<char, char, mbstate_t> >(const locale&);
2478 has_facet<collate<char> >(const locale&);
2482 has_facet<numpunct<char> >(const locale&);
2486 has_facet<num_put<char> >(const locale&);
2490 has_facet<num_get<char> >(const locale&);
2494 has_facet<moneypunct<char> >(const locale&);
2498 has_facet<money_put<char> >(const locale&);
2502 has_facet<money_get<char> >(const locale&);
2506 has_facet<__timepunct<char> >(const locale&);
2510 has_facet<time_put<char> >(const locale&);
2514 has_facet<time_get<char> >(const locale&);
2518 has_facet<messages<char> >(const locale&);
2520 #ifdef _GLIBCXX_USE_WCHAR_T
2521 extern template class moneypunct<wchar_t, false>;
2522 extern template class moneypunct<wchar_t, true>;
2523 extern template class moneypunct_byname<wchar_t, false>;
2524 extern template class moneypunct_byname<wchar_t, true>;
2525 extern template class money_get<wchar_t>;
2526 extern template class money_put<wchar_t>;
2527 extern template class numpunct<wchar_t>;
2528 extern template class numpunct_byname<wchar_t>;
2529 extern template class num_get<wchar_t>;
2530 extern template class num_put<wchar_t>;
2531 extern template class __timepunct<wchar_t>;
2532 extern template class time_put<wchar_t>;
2533 extern template class time_put_byname<wchar_t>;
2534 extern template class time_get<wchar_t>;
2535 extern template class time_get_byname<wchar_t>;
2536 extern template class messages<wchar_t>;
2537 extern template class messages_byname<wchar_t>;
2538 extern template class ctype_byname<wchar_t>;
2539 extern template class codecvt_byname<wchar_t, char, mbstate_t>;
2540 extern template class collate<wchar_t>;
2541 extern template class collate_byname<wchar_t>;
2544 const codecvt<wchar_t, char, mbstate_t>&
2545 use_facet<codecvt<wchar_t, char, mbstate_t> >(locale const&);
2548 const collate<wchar_t>&
2549 use_facet<collate<wchar_t> >(const locale&);
2552 const numpunct<wchar_t>&
2553 use_facet<numpunct<wchar_t> >(const locale&);
2556 const num_put<wchar_t>&
2557 use_facet<num_put<wchar_t> >(const locale&);
2560 const num_get<wchar_t>&
2561 use_facet<num_get<wchar_t> >(const locale&);
2564 const moneypunct<wchar_t, true>&
2565 use_facet<moneypunct<wchar_t, true> >(const locale&);
2568 const moneypunct<wchar_t, false>&
2569 use_facet<moneypunct<wchar_t, false> >(const locale&);
2572 const money_put<wchar_t>&
2573 use_facet<money_put<wchar_t> >(const locale&);
2576 const money_get<wchar_t>&
2577 use_facet<money_get<wchar_t> >(const locale&);
2580 const __timepunct<wchar_t>&
2581 use_facet<__timepunct<wchar_t> >(const locale&);
2584 const time_put<wchar_t>&
2585 use_facet<time_put<wchar_t> >(const locale&);
2588 const time_get<wchar_t>&
2589 use_facet<time_get<wchar_t> >(const locale&);
2592 const messages<wchar_t>&
2593 use_facet<messages<wchar_t> >(const locale&);
2597 has_facet<ctype<wchar_t> >(const locale&);
2601 has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
2605 has_facet<collate<wchar_t> >(const locale&);
2609 has_facet<numpunct<wchar_t> >(const locale&);
2613 has_facet<num_put<wchar_t> >(const locale&);
2617 has_facet<num_get<wchar_t> >(const locale&);
2621 has_facet<moneypunct<wchar_t> >(const locale&);
2625 has_facet<money_put<wchar_t> >(const locale&);
2629 has_facet<money_get<wchar_t> >(const locale&);
2633 has_facet<__timepunct<wchar_t> >(const locale&);
2637 has_facet<time_put<wchar_t> >(const locale&);
2641 has_facet<time_get<wchar_t> >(const locale&);
2645 has_facet<messages<wchar_t> >(const locale&);