1 // Locale support -*- C++ -*-
3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
5 // Free Software Foundation, Inc.
7 // This file is part of the GNU ISO C++ Library. This library is free
8 // software; you can redistribute it and/or modify it under the
9 // terms of the GNU General Public License as published by the
10 // Free Software Foundation; either version 2, or (at your option)
13 // This library is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License along
19 // with this library; see the file COPYING. If not, write to the Free
20 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
23 // As a special exception, you may use this file as part of a free software
24 // library without restriction. Specifically, if other files instantiate
25 // templates or use macros or inline functions from this file, or you compile
26 // this file and link it with other files to produce an executable, this
27 // file does not by itself cause the resulting executable to be covered by
28 // the GNU General Public License. This exception does not however
29 // invalidate any other reasons why the executable file might be covered by
30 // the GNU General Public License.
32 /** @file locale_facets.tcc
33 * This is an internal header file, included by other library headers.
34 * You should not attempt to use it directly.
37 #ifndef _LOCALE_FACETS_TCC
38 #define _LOCALE_FACETS_TCC 1
40 #pragma GCC system_header
42 #include <limits> // For numeric_limits
43 #include <typeinfo> // For bad_cast.
44 #include <bits/streambuf_iterator.h>
45 #include <ext/type_traits.h>
47 _GLIBCXX_BEGIN_NAMESPACE(std)
49 template<typename _Facet>
51 locale::combine(const locale& __other) const
53 _Impl* __tmp = new _Impl(*_M_impl, 1);
56 __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
60 __tmp->_M_remove_reference();
61 __throw_exception_again;
66 template<typename _CharT, typename _Traits, typename _Alloc>
68 locale::operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
69 const basic_string<_CharT, _Traits, _Alloc>& __s2) const
71 typedef std::collate<_CharT> __collate_type;
72 const __collate_type& __collate = use_facet<__collate_type>(*this);
73 return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
74 __s2.data(), __s2.data() + __s2.length()) < 0);
78 * @brief Test for the presence of a facet.
80 * has_facet tests the locale argument for the presence of the facet type
81 * provided as the template parameter. Facets derived from the facet
82 * parameter will also return true.
84 * @param Facet The facet type to test the presence of.
85 * @param locale The locale to test.
86 * @return true if locale contains a facet of type Facet, else false.
88 template<typename _Facet>
90 has_facet(const locale& __loc) throw()
92 const size_t __i = _Facet::id._M_id();
93 const locale::facet** __facets = __loc._M_impl->_M_facets;
94 return (__i < __loc._M_impl->_M_facets_size && __facets[__i]);
98 * @brief Return a facet.
100 * use_facet looks for and returns a reference to a facet of type Facet
101 * where Facet is the template parameter. If has_facet(locale) is true,
102 * there is a suitable facet to return. It throws std::bad_cast if the
103 * locale doesn't contain a facet of type Facet.
105 * @param Facet The facet type to access.
106 * @param locale The locale to use.
107 * @return Reference to facet of type Facet.
108 * @throw std::bad_cast if locale doesn't contain a facet of type Facet.
110 template<typename _Facet>
112 use_facet(const locale& __loc)
114 const size_t __i = _Facet::id._M_id();
115 const locale::facet** __facets = __loc._M_impl->_M_facets;
116 if (!(__i < __loc._M_impl->_M_facets_size && __facets[__i]))
118 return static_cast<const _Facet&>(*__facets[__i]);
122 // Routine to access a cache for the facet. If the cache didn't
123 // exist before, it gets constructed on the fly.
124 template<typename _Facet>
128 operator() (const locale& __loc) const;
132 template<typename _CharT>
133 struct __use_cache<__numpunct_cache<_CharT> >
135 const __numpunct_cache<_CharT>*
136 operator() (const locale& __loc) const
138 const size_t __i = numpunct<_CharT>::id._M_id();
139 const locale::facet** __caches = __loc._M_impl->_M_caches;
142 __numpunct_cache<_CharT>* __tmp = NULL;
145 __tmp = new __numpunct_cache<_CharT>;
146 __tmp->_M_cache(__loc);
151 __throw_exception_again;
153 __loc._M_impl->_M_install_cache(__tmp, __i);
155 return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
159 template<typename _CharT, bool _Intl>
160 struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
162 const __moneypunct_cache<_CharT, _Intl>*
163 operator() (const locale& __loc) const
165 const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
166 const locale::facet** __caches = __loc._M_impl->_M_caches;
169 __moneypunct_cache<_CharT, _Intl>* __tmp = NULL;
172 __tmp = new __moneypunct_cache<_CharT, _Intl>;
173 __tmp->_M_cache(__loc);
178 __throw_exception_again;
180 __loc._M_impl->_M_install_cache(__tmp, __i);
183 const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
187 template<typename _CharT>
189 __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
193 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
195 _M_grouping_size = __np.grouping().size();
196 char* __grouping = new char[_M_grouping_size];
197 __np.grouping().copy(__grouping, _M_grouping_size);
198 _M_grouping = __grouping;
199 _M_use_grouping = (_M_grouping_size
200 && static_cast<signed char>(__np.grouping()[0]) > 0);
202 _M_truename_size = __np.truename().size();
203 _CharT* __truename = new _CharT[_M_truename_size];
204 __np.truename().copy(__truename, _M_truename_size);
205 _M_truename = __truename;
207 _M_falsename_size = __np.falsename().size();
208 _CharT* __falsename = new _CharT[_M_falsename_size];
209 __np.falsename().copy(__falsename, _M_falsename_size);
210 _M_falsename = __falsename;
212 _M_decimal_point = __np.decimal_point();
213 _M_thousands_sep = __np.thousands_sep();
215 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
216 __ct.widen(__num_base::_S_atoms_out,
217 __num_base::_S_atoms_out + __num_base::_S_oend, _M_atoms_out);
218 __ct.widen(__num_base::_S_atoms_in,
219 __num_base::_S_atoms_in + __num_base::_S_iend, _M_atoms_in);
222 template<typename _CharT, bool _Intl>
224 __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
228 const moneypunct<_CharT, _Intl>& __mp =
229 use_facet<moneypunct<_CharT, _Intl> >(__loc);
231 _M_grouping_size = __mp.grouping().size();
232 char* __grouping = new char[_M_grouping_size];
233 __mp.grouping().copy(__grouping, _M_grouping_size);
234 _M_grouping = __grouping;
235 _M_use_grouping = (_M_grouping_size
236 && static_cast<signed char>(__mp.grouping()[0]) > 0);
238 _M_decimal_point = __mp.decimal_point();
239 _M_thousands_sep = __mp.thousands_sep();
240 _M_frac_digits = __mp.frac_digits();
242 _M_curr_symbol_size = __mp.curr_symbol().size();
243 _CharT* __curr_symbol = new _CharT[_M_curr_symbol_size];
244 __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
245 _M_curr_symbol = __curr_symbol;
247 _M_positive_sign_size = __mp.positive_sign().size();
248 _CharT* __positive_sign = new _CharT[_M_positive_sign_size];
249 __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
250 _M_positive_sign = __positive_sign;
252 _M_negative_sign_size = __mp.negative_sign().size();
253 _CharT* __negative_sign = new _CharT[_M_negative_sign_size];
254 __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
255 _M_negative_sign = __negative_sign;
257 _M_pos_format = __mp.pos_format();
258 _M_neg_format = __mp.neg_format();
260 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
261 __ct.widen(money_base::_S_atoms,
262 money_base::_S_atoms + money_base::_S_end, _M_atoms);
266 // Used by both numeric and monetary facets.
267 // Check to make sure that the __grouping_tmp string constructed in
268 // money_get or num_get matches the canonical grouping for a given
270 // __grouping_tmp is parsed L to R
271 // 1,222,444 == __grouping_tmp of "\1\3\3"
272 // __grouping is parsed R to L
273 // 1,222,444 == __grouping of "\3" == "\3\3\3"
275 __verify_grouping(const char* __grouping, size_t __grouping_size,
276 const string& __grouping_tmp);
278 _GLIBCXX_BEGIN_LDBL_NAMESPACE
280 template<typename _CharT, typename _InIter>
282 num_get<_CharT, _InIter>::
283 _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
284 ios_base::iostate& __err, string& __xtrc) const
286 typedef char_traits<_CharT> __traits_type;
287 typedef __numpunct_cache<_CharT> __cache_type;
288 __use_cache<__cache_type> __uc;
289 const locale& __loc = __io._M_getloc();
290 const __cache_type* __lc = __uc(__loc);
291 const _CharT* __lit = __lc->_M_atoms_in;
292 char_type __c = char_type();
294 // True if __beg becomes equal to __end.
295 bool __testeof = __beg == __end;
297 // First check for sign.
301 const bool __plus = __c == __lit[__num_base::_S_iplus];
302 if ((__plus || __c == __lit[__num_base::_S_iminus])
303 && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
304 && !(__c == __lc->_M_decimal_point))
306 __xtrc += __plus ? '+' : '-';
307 if (++__beg != __end)
314 // Next, look for leading zeros.
315 bool __found_mantissa = false;
319 if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
320 || __c == __lc->_M_decimal_point)
322 else if (__c == __lit[__num_base::_S_izero])
324 if (!__found_mantissa)
327 __found_mantissa = true;
331 if (++__beg != __end)
340 // Only need acceptable digits for floating point numbers.
341 bool __found_dec = false;
342 bool __found_sci = false;
343 string __found_grouping;
344 if (__lc->_M_use_grouping)
345 __found_grouping.reserve(32);
346 const char_type* __lit_zero = __lit + __num_base::_S_izero;
348 if (!__lc->_M_allocated)
352 const int __digit = _M_find(__lit_zero, 10, __c);
355 __xtrc += '0' + __digit;
356 __found_mantissa = true;
358 else if (__c == __lc->_M_decimal_point
359 && !__found_dec && !__found_sci)
364 else if ((__c == __lit[__num_base::_S_ie]
365 || __c == __lit[__num_base::_S_iE])
366 && !__found_sci && __found_mantissa)
368 // Scientific notation.
372 // Remove optional plus or minus sign, if they exist.
373 if (++__beg != __end)
376 const bool __plus = __c == __lit[__num_base::_S_iplus];
377 if (__plus || __c == __lit[__num_base::_S_iminus])
378 __xtrc += __plus ? '+' : '-';
391 if (++__beg != __end)
399 // According to 22.2.2.1.2, p8-9, first look for thousands_sep
400 // and decimal_point.
401 if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
403 if (!__found_dec && !__found_sci)
405 // NB: Thousands separator at the beginning of a string
406 // is a no-no, as is two consecutive thousands separators.
409 __found_grouping += static_cast<char>(__sep_pos);
414 // NB: __convert_to_v will not assign __v and will
423 else if (__c == __lc->_M_decimal_point)
425 if (!__found_dec && !__found_sci)
427 // If no grouping chars are seen, no grouping check
428 // is applied. Therefore __found_grouping is adjusted
429 // only if decimal_point comes after some thousands_sep.
430 if (__found_grouping.size())
431 __found_grouping += static_cast<char>(__sep_pos);
440 const char_type* __q =
441 __traits_type::find(__lit_zero, 10, __c);
444 __xtrc += '0' + (__q - __lit_zero);
445 __found_mantissa = true;
448 else if ((__c == __lit[__num_base::_S_ie]
449 || __c == __lit[__num_base::_S_iE])
450 && !__found_sci && __found_mantissa)
452 // Scientific notation.
453 if (__found_grouping.size() && !__found_dec)
454 __found_grouping += static_cast<char>(__sep_pos);
458 // Remove optional plus or minus sign, if they exist.
459 if (++__beg != __end)
462 const bool __plus = __c == __lit[__num_base::_S_iplus];
463 if ((__plus || __c == __lit[__num_base::_S_iminus])
464 && !(__lc->_M_use_grouping
465 && __c == __lc->_M_thousands_sep)
466 && !(__c == __lc->_M_decimal_point))
467 __xtrc += __plus ? '+' : '-';
481 if (++__beg != __end)
487 // Digit grouping is checked. If grouping and found_grouping don't
488 // match, then get very very upset, and set failbit.
489 if (__found_grouping.size())
491 // Add the ending grouping if a decimal or 'e'/'E' wasn't found.
492 if (!__found_dec && !__found_sci)
493 __found_grouping += static_cast<char>(__sep_pos);
495 if (!std::__verify_grouping(__lc->_M_grouping,
496 __lc->_M_grouping_size,
498 __err |= ios_base::failbit;
503 __err |= ios_base::eofbit;
507 _GLIBCXX_END_LDBL_NAMESPACE
509 _GLIBCXX_BEGIN_LDBL_NAMESPACE
511 template<typename _CharT, typename _InIter>
512 template<typename _ValueT>
514 num_get<_CharT, _InIter>::
515 _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
516 ios_base::iostate& __err, _ValueT& __v) const
518 typedef char_traits<_CharT> __traits_type;
519 using __gnu_cxx::__add_unsigned;
520 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
521 typedef __numpunct_cache<_CharT> __cache_type;
522 __use_cache<__cache_type> __uc;
523 const locale& __loc = __io._M_getloc();
524 const __cache_type* __lc = __uc(__loc);
525 const _CharT* __lit = __lc->_M_atoms_in;
526 char_type __c = char_type();
528 // NB: Iff __basefield == 0, __base can change based on contents.
529 const ios_base::fmtflags __basefield = __io.flags()
530 & ios_base::basefield;
531 const bool __oct = __basefield == ios_base::oct;
532 int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
534 // True if __beg becomes equal to __end.
535 bool __testeof = __beg == __end;
537 // First check for sign.
538 bool __negative = false;
542 if (numeric_limits<_ValueT>::is_signed)
543 __negative = __c == __lit[__num_base::_S_iminus];
544 if ((__negative || __c == __lit[__num_base::_S_iplus])
545 && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
546 && !(__c == __lc->_M_decimal_point))
548 if (++__beg != __end)
555 // Next, look for leading zeros and check required digits
557 bool __found_zero = false;
561 if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
562 || __c == __lc->_M_decimal_point)
564 else if (__c == __lit[__num_base::_S_izero]
565 && (!__found_zero || __base == 10))
569 if (__basefield == 0)
574 else if (__found_zero
575 && (__c == __lit[__num_base::_S_ix]
576 || __c == __lit[__num_base::_S_iX]))
578 if (__basefield == 0)
582 __found_zero = false;
591 if (++__beg != __end)
601 // At this point, base is determined. If not hex, only allow
602 // base digits as valid input.
603 const size_t __len = (__base == 16 ? __num_base::_S_iend
604 - __num_base::_S_izero : __base);
607 string __found_grouping;
608 if (__lc->_M_use_grouping)
609 __found_grouping.reserve(32);
610 bool __testfail = false;
611 const __unsigned_type __max = __negative ?
612 -numeric_limits<_ValueT>::min() : numeric_limits<_ValueT>::max();
613 const __unsigned_type __smax = __max / __base;
614 __unsigned_type __result = 0;
616 const char_type* __lit_zero = __lit + __num_base::_S_izero;
618 if (!__lc->_M_allocated)
622 __digit = _M_find(__lit_zero, __len, __c);
626 if (__result > __smax)
631 __testfail |= __result > __max - __digit;
636 if (++__beg != __end)
644 // According to 22.2.2.1.2, p8-9, first look for thousands_sep
645 // and decimal_point.
646 if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
648 // NB: Thousands separator at the beginning of a string
649 // is a no-no, as is two consecutive thousands separators.
652 __found_grouping += static_cast<char>(__sep_pos);
661 else if (__c == __lc->_M_decimal_point)
665 const char_type* __q =
666 __traits_type::find(__lit_zero, __len, __c);
670 __digit = __q - __lit_zero;
673 if (__result > __smax)
678 __testfail |= __result > __max - __digit;
684 if (++__beg != __end)
690 // Digit grouping is checked. If grouping and found_grouping don't
691 // match, then get very very upset, and set failbit.
692 if (__found_grouping.size())
694 // Add the ending grouping.
695 __found_grouping += static_cast<char>(__sep_pos);
697 if (!std::__verify_grouping(__lc->_M_grouping,
698 __lc->_M_grouping_size,
700 __err |= ios_base::failbit;
703 if (!__testfail && (__sep_pos || __found_zero
704 || __found_grouping.size()))
705 __v = __negative ? -__result : __result;
707 __err |= ios_base::failbit;
710 __err |= ios_base::eofbit;
714 // _GLIBCXX_RESOLVE_LIB_DEFECTS
715 // 17. Bad bool parsing
716 template<typename _CharT, typename _InIter>
718 num_get<_CharT, _InIter>::
719 do_get(iter_type __beg, iter_type __end, ios_base& __io,
720 ios_base::iostate& __err, bool& __v) const
722 if (!(__io.flags() & ios_base::boolalpha))
724 // Parse bool values as long.
725 // NB: We can't just call do_get(long) here, as it might
726 // refer to a derived class.
728 __beg = _M_extract_int(__beg, __end, __io, __err, __l);
729 if (__l == 0 || __l == 1)
732 __err |= ios_base::failbit;
736 // Parse bool values as alphanumeric.
737 typedef __numpunct_cache<_CharT> __cache_type;
738 __use_cache<__cache_type> __uc;
739 const locale& __loc = __io._M_getloc();
740 const __cache_type* __lc = __uc(__loc);
745 bool __testeof = __beg == __end;
746 for (__n = 0; !__testeof; ++__n)
748 const char_type __c = *__beg;
752 if (__n < __lc->_M_falsename_size)
753 __testf = __c == __lc->_M_falsename[__n];
760 if (__n < __lc->_M_truename_size)
761 __testt = __c == __lc->_M_truename[__n];
766 if (!__testf && !__testt)
769 if (++__beg == __end)
772 if (__testf && __n == __lc->_M_falsename_size)
774 else if (__testt && __n == __lc->_M_truename_size)
777 __err |= ios_base::failbit;
780 __err |= ios_base::eofbit;
785 template<typename _CharT, typename _InIter>
787 num_get<_CharT, _InIter>::
788 do_get(iter_type __beg, iter_type __end, ios_base& __io,
789 ios_base::iostate& __err, long& __v) const
790 { return _M_extract_int(__beg, __end, __io, __err, __v); }
792 template<typename _CharT, typename _InIter>
794 num_get<_CharT, _InIter>::
795 do_get(iter_type __beg, iter_type __end, ios_base& __io,
796 ios_base::iostate& __err, unsigned short& __v) const
797 { return _M_extract_int(__beg, __end, __io, __err, __v); }
799 template<typename _CharT, typename _InIter>
801 num_get<_CharT, _InIter>::
802 do_get(iter_type __beg, iter_type __end, ios_base& __io,
803 ios_base::iostate& __err, unsigned int& __v) const
804 { return _M_extract_int(__beg, __end, __io, __err, __v); }
806 template<typename _CharT, typename _InIter>
808 num_get<_CharT, _InIter>::
809 do_get(iter_type __beg, iter_type __end, ios_base& __io,
810 ios_base::iostate& __err, unsigned long& __v) const
811 { return _M_extract_int(__beg, __end, __io, __err, __v); }
813 #ifdef _GLIBCXX_USE_LONG_LONG
814 template<typename _CharT, typename _InIter>
816 num_get<_CharT, _InIter>::
817 do_get(iter_type __beg, iter_type __end, ios_base& __io,
818 ios_base::iostate& __err, long long& __v) const
819 { return _M_extract_int(__beg, __end, __io, __err, __v); }
821 template<typename _CharT, typename _InIter>
823 num_get<_CharT, _InIter>::
824 do_get(iter_type __beg, iter_type __end, ios_base& __io,
825 ios_base::iostate& __err, unsigned long long& __v) const
826 { return _M_extract_int(__beg, __end, __io, __err, __v); }
829 template<typename _CharT, typename _InIter>
831 num_get<_CharT, _InIter>::
832 do_get(iter_type __beg, iter_type __end, ios_base& __io,
833 ios_base::iostate& __err, float& __v) const
837 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
838 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
842 template<typename _CharT, typename _InIter>
844 num_get<_CharT, _InIter>::
845 do_get(iter_type __beg, iter_type __end, ios_base& __io,
846 ios_base::iostate& __err, double& __v) const
850 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
851 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
855 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
856 template<typename _CharT, typename _InIter>
858 num_get<_CharT, _InIter>::
859 __do_get(iter_type __beg, iter_type __end, ios_base& __io,
860 ios_base::iostate& __err, double& __v) const
864 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
865 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
870 template<typename _CharT, typename _InIter>
872 num_get<_CharT, _InIter>::
873 do_get(iter_type __beg, iter_type __end, ios_base& __io,
874 ios_base::iostate& __err, long double& __v) const
878 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
879 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
883 template<typename _CharT, typename _InIter>
885 num_get<_CharT, _InIter>::
886 do_get(iter_type __beg, iter_type __end, ios_base& __io,
887 ios_base::iostate& __err, void*& __v) const
889 // Prepare for hex formatted input.
890 typedef ios_base::fmtflags fmtflags;
891 const fmtflags __fmt = __io.flags();
892 __io.flags(__fmt & ~ios_base::basefield | ios_base::hex);
894 typedef __gnu_cxx::__conditional_type<(sizeof(void*)
895 <= sizeof(unsigned long)),
896 unsigned long, unsigned long long>::__type _UIntPtrType;
899 __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
901 // Reset from hex formatted input.
904 if (!(__err & ios_base::failbit))
905 __v = reinterpret_cast<void*>(__ul);
909 // For use by integer and floating-point types after they have been
910 // converted into a char_type string.
911 template<typename _CharT, typename _OutIter>
913 num_put<_CharT, _OutIter>::
914 _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
915 _CharT* __new, const _CharT* __cs, int& __len) const
917 // [22.2.2.2.2] Stage 3.
918 // If necessary, pad.
919 __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, __cs,
921 __len = static_cast<int>(__w);
924 _GLIBCXX_END_LDBL_NAMESPACE
926 template<typename _CharT, typename _ValueT>
928 __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
929 ios_base::fmtflags __flags, bool __dec)
931 _CharT* __buf = __bufend;
932 if (__builtin_expect(__dec, true))
937 *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
942 else if ((__flags & ios_base::basefield) == ios_base::oct)
947 *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
955 const bool __uppercase = __flags & ios_base::uppercase;
956 const int __case_offset = __uppercase ? __num_base::_S_oudigits
957 : __num_base::_S_odigits;
960 *--__buf = __lit[(__v & 0xf) + __case_offset];
965 return __bufend - __buf;
968 _GLIBCXX_BEGIN_LDBL_NAMESPACE
970 template<typename _CharT, typename _OutIter>
972 num_put<_CharT, _OutIter>::
973 _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
974 ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
976 _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
977 __grouping_size, __cs, __cs + __len);
981 template<typename _CharT, typename _OutIter>
982 template<typename _ValueT>
984 num_put<_CharT, _OutIter>::
985 _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
988 using __gnu_cxx::__add_unsigned;
989 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
990 typedef __numpunct_cache<_CharT> __cache_type;
991 __use_cache<__cache_type> __uc;
992 const locale& __loc = __io._M_getloc();
993 const __cache_type* __lc = __uc(__loc);
994 const _CharT* __lit = __lc->_M_atoms_out;
995 const ios_base::fmtflags __flags = __io.flags();
997 // Long enough to hold hex, dec, and octal representations.
998 const int __ilen = 5 * sizeof(_ValueT);
999 _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1002 // [22.2.2.2.2] Stage 1, numeric conversion to character.
1003 // Result is returned right-justified in the buffer.
1004 const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
1005 const bool __dec = (__basefield != ios_base::oct
1006 && __basefield != ios_base::hex);
1007 const __unsigned_type __u = (__v > 0 || !__dec) ? __v : -__v;
1008 int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
1009 __cs += __ilen - __len;
1011 // Add grouping, if necessary.
1012 if (__lc->_M_use_grouping)
1014 // Grouping can add (almost) as many separators as the number
1015 // of digits + space is reserved for numeric base or sign.
1016 _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1019 _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
1020 __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
1024 // Complete Stage 1, prepend numeric base or sign.
1025 if (__builtin_expect(__dec, true))
1030 if (__flags & ios_base::showpos
1031 && numeric_limits<_ValueT>::is_signed)
1032 *--__cs = __lit[__num_base::_S_oplus], ++__len;
1035 *--__cs = __lit[__num_base::_S_ominus], ++__len;
1037 else if (__flags & ios_base::showbase && __v)
1039 if (__basefield == ios_base::oct)
1040 *--__cs = __lit[__num_base::_S_odigits], ++__len;
1044 const bool __uppercase = __flags & ios_base::uppercase;
1045 *--__cs = __lit[__num_base::_S_ox + __uppercase];
1047 *--__cs = __lit[__num_base::_S_odigits];
1053 const streamsize __w = __io.width();
1054 if (__w > static_cast<streamsize>(__len))
1056 _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1058 _M_pad(__fill, __w, __io, __cs3, __cs, __len);
1063 // [22.2.2.2.2] Stage 4.
1064 // Write resulting, fully-formatted string to output iterator.
1065 return std::__write(__s, __cs, __len);
1068 template<typename _CharT, typename _OutIter>
1070 num_put<_CharT, _OutIter>::
1071 _M_group_float(const char* __grouping, size_t __grouping_size,
1072 _CharT __sep, const _CharT* __p, _CharT* __new,
1073 _CharT* __cs, int& __len) const
1075 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1076 // 282. What types does numpunct grouping refer to?
1077 // Add grouping, if necessary.
1078 const int __declen = __p ? __p - __cs : __len;
1079 _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
1081 __cs, __cs + __declen);
1083 // Tack on decimal part.
1084 int __newlen = __p2 - __new;
1087 char_traits<_CharT>::copy(__p2, __p, __len - __declen);
1088 __newlen += __len - __declen;
1093 // The following code uses vsnprintf (or vsprintf(), when
1094 // _GLIBCXX_USE_C99 is not defined) to convert floating point values
1095 // for insertion into a stream. An optimization would be to replace
1096 // them with code that works directly on a wide buffer and then use
1097 // __pad to do the padding. It would be good to replace them anyway
1098 // to gain back the efficiency that C++ provides by knowing up front
1099 // the type of the values to insert. Also, sprintf is dangerous
1100 // since may lead to accidental buffer overruns. This
1101 // implementation follows the C++ standard fairly directly as
1102 // outlined in 22.2.2.2 [lib.locale.num.put]
1103 template<typename _CharT, typename _OutIter>
1104 template<typename _ValueT>
1106 num_put<_CharT, _OutIter>::
1107 _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
1110 typedef __numpunct_cache<_CharT> __cache_type;
1111 __use_cache<__cache_type> __uc;
1112 const locale& __loc = __io._M_getloc();
1113 const __cache_type* __lc = __uc(__loc);
1115 // Use default precision if out of range.
1116 const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
1118 const int __max_digits = numeric_limits<_ValueT>::digits10;
1120 // [22.2.2.2.2] Stage 1, numeric conversion to character.
1122 // Long enough for the max format spec.
1124 __num_base::_S_format_float(__io, __fbuf, __mod);
1126 #ifdef _GLIBCXX_USE_C99
1127 // First try a buffer perhaps big enough (most probably sufficient
1128 // for non-ios_base::fixed outputs)
1129 int __cs_size = __max_digits * 3;
1130 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1131 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
1132 __fbuf, __prec, __v);
1134 // If the buffer was not large enough, try again with the correct size.
1135 if (__len >= __cs_size)
1137 __cs_size = __len + 1;
1138 __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1139 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
1140 __fbuf, __prec, __v);
1143 // Consider the possibility of long ios_base::fixed outputs
1144 const bool __fixed = __io.flags() & ios_base::fixed;
1145 const int __max_exp = numeric_limits<_ValueT>::max_exponent10;
1147 // The size of the output string is computed as follows.
1148 // ios_base::fixed outputs may need up to __max_exp + 1 chars
1149 // for the integer part + __prec chars for the fractional part
1150 // + 3 chars for sign, decimal point, '\0'. On the other hand,
1151 // for non-fixed outputs __max_digits * 2 + __prec chars are
1152 // largely sufficient.
1153 const int __cs_size = __fixed ? __max_exp + __prec + 4
1154 : __max_digits * 2 + __prec;
1155 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1156 __len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, __fbuf,
1160 // [22.2.2.2.2] Stage 2, convert to char_type, using correct
1161 // numpunct.decimal_point() values for '.' and adding grouping.
1162 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1164 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1166 __ctype.widen(__cs, __cs + __len, __ws);
1168 // Replace decimal point.
1170 const char* __p = char_traits<char>::find(__cs, __len, '.');
1173 __wp = __ws + (__p - __cs);
1174 *__wp = __lc->_M_decimal_point;
1177 // Add grouping, if necessary.
1178 // N.B. Make sure to not group things like 2e20, i.e., no decimal
1179 // point, scientific notation.
1180 if (__lc->_M_use_grouping
1181 && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
1182 && __cs[1] >= '0' && __cs[2] >= '0')))
1184 // Grouping can add (almost) as many separators as the
1185 // number of digits, but no more.
1186 _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1189 streamsize __off = 0;
1190 if (__cs[0] == '-' || __cs[0] == '+')
1197 _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
1198 __lc->_M_thousands_sep, __wp, __ws2 + __off,
1199 __ws + __off, __len);
1206 const streamsize __w = __io.width();
1207 if (__w > static_cast<streamsize>(__len))
1209 _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1211 _M_pad(__fill, __w, __io, __ws3, __ws, __len);
1216 // [22.2.2.2.2] Stage 4.
1217 // Write resulting, fully-formatted string to output iterator.
1218 return std::__write(__s, __ws, __len);
1221 template<typename _CharT, typename _OutIter>
1223 num_put<_CharT, _OutIter>::
1224 do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
1226 const ios_base::fmtflags __flags = __io.flags();
1227 if ((__flags & ios_base::boolalpha) == 0)
1229 const long __l = __v;
1230 __s = _M_insert_int(__s, __io, __fill, __l);
1234 typedef __numpunct_cache<_CharT> __cache_type;
1235 __use_cache<__cache_type> __uc;
1236 const locale& __loc = __io._M_getloc();
1237 const __cache_type* __lc = __uc(__loc);
1239 const _CharT* __name = __v ? __lc->_M_truename
1240 : __lc->_M_falsename;
1241 int __len = __v ? __lc->_M_truename_size
1242 : __lc->_M_falsename_size;
1244 const streamsize __w = __io.width();
1245 if (__w > static_cast<streamsize>(__len))
1248 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1250 _M_pad(__fill, __w, __io, __cs, __name, __len);
1254 __s = std::__write(__s, __name, __len);
1259 template<typename _CharT, typename _OutIter>
1261 num_put<_CharT, _OutIter>::
1262 do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
1263 { return _M_insert_int(__s, __io, __fill, __v); }
1265 template<typename _CharT, typename _OutIter>
1267 num_put<_CharT, _OutIter>::
1268 do_put(iter_type __s, ios_base& __io, char_type __fill,
1269 unsigned long __v) const
1270 { return _M_insert_int(__s, __io, __fill, __v); }
1272 #ifdef _GLIBCXX_USE_LONG_LONG
1273 template<typename _CharT, typename _OutIter>
1275 num_put<_CharT, _OutIter>::
1276 do_put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
1277 { return _M_insert_int(__s, __io, __fill, __v); }
1279 template<typename _CharT, typename _OutIter>
1281 num_put<_CharT, _OutIter>::
1282 do_put(iter_type __s, ios_base& __io, char_type __fill,
1283 unsigned long long __v) const
1284 { return _M_insert_int(__s, __io, __fill, __v); }
1287 template<typename _CharT, typename _OutIter>
1289 num_put<_CharT, _OutIter>::
1290 do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
1291 { return _M_insert_float(__s, __io, __fill, char(), __v); }
1293 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
1294 template<typename _CharT, typename _OutIter>
1296 num_put<_CharT, _OutIter>::
1297 __do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
1298 { return _M_insert_float(__s, __io, __fill, char(), __v); }
1301 template<typename _CharT, typename _OutIter>
1303 num_put<_CharT, _OutIter>::
1304 do_put(iter_type __s, ios_base& __io, char_type __fill,
1305 long double __v) const
1306 { return _M_insert_float(__s, __io, __fill, 'L', __v); }
1308 template<typename _CharT, typename _OutIter>
1310 num_put<_CharT, _OutIter>::
1311 do_put(iter_type __s, ios_base& __io, char_type __fill,
1312 const void* __v) const
1314 const ios_base::fmtflags __flags = __io.flags();
1315 const ios_base::fmtflags __fmt = ~(ios_base::basefield
1316 | ios_base::uppercase
1317 | ios_base::internal);
1318 __io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase));
1320 typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
1321 <= sizeof(unsigned long)),
1322 unsigned long, unsigned long long>::__type _UIntPtrType;
1324 __s = _M_insert_int(__s, __io, __fill,
1325 reinterpret_cast<_UIntPtrType>(__v));
1326 __io.flags(__flags);
1330 template<typename _CharT, typename _InIter>
1331 template<bool _Intl>
1333 money_get<_CharT, _InIter>::
1334 _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
1335 ios_base::iostate& __err, string& __units) const
1337 typedef char_traits<_CharT> __traits_type;
1338 typedef typename string_type::size_type size_type;
1339 typedef money_base::part part;
1340 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
1342 const locale& __loc = __io._M_getloc();
1343 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1345 __use_cache<__cache_type> __uc;
1346 const __cache_type* __lc = __uc(__loc);
1347 const char_type* __lit = __lc->_M_atoms;
1350 bool __negative = false;
1352 size_type __sign_size = 0;
1353 // True if sign is mandatory.
1354 const bool __mandatory_sign = (__lc->_M_positive_sign_size
1355 && __lc->_M_negative_sign_size);
1356 // String of grouping info from thousands_sep plucked from __units.
1357 string __grouping_tmp;
1358 if (__lc->_M_use_grouping)
1359 __grouping_tmp.reserve(32);
1360 // Last position before the decimal point.
1362 // Separator positions, then, possibly, fractional digits.
1364 // If input iterator is in a valid state.
1365 bool __testvalid = true;
1366 // Flag marking when a decimal point is found.
1367 bool __testdecfound = false;
1369 // The tentative returned string is stored here.
1373 const char_type* __lit_zero = __lit + money_base::_S_zero;
1374 const money_base::pattern __p = __lc->_M_neg_format;
1375 for (int __i = 0; __i < 4 && __testvalid; ++__i)
1377 const part __which = static_cast<part>(__p.field[__i]);
1380 case money_base::symbol:
1381 // According to 22.2.6.1.2, p2, symbol is required
1382 // if (__io.flags() & ios_base::showbase), otherwise
1383 // is optional and consumed only if other characters
1384 // are needed to complete the format.
1385 if (__io.flags() & ios_base::showbase || __sign_size > 1
1387 || (__i == 1 && (__mandatory_sign
1388 || (static_cast<part>(__p.field[0])
1389 == money_base::sign)
1390 || (static_cast<part>(__p.field[2])
1391 == money_base::space)))
1392 || (__i == 2 && ((static_cast<part>(__p.field[3])
1393 == money_base::value)
1394 || (__mandatory_sign
1395 && (static_cast<part>(__p.field[3])
1396 == money_base::sign)))))
1398 const size_type __len = __lc->_M_curr_symbol_size;
1400 for (; __beg != __end && __j < __len
1401 && *__beg == __lc->_M_curr_symbol[__j];
1404 && (__j || __io.flags() & ios_base::showbase))
1405 __testvalid = false;
1408 case money_base::sign:
1409 // Sign might not exist, or be more than one character long.
1410 if (__lc->_M_positive_sign_size && __beg != __end
1411 && *__beg == __lc->_M_positive_sign[0])
1413 __sign_size = __lc->_M_positive_sign_size;
1416 else if (__lc->_M_negative_sign_size && __beg != __end
1417 && *__beg == __lc->_M_negative_sign[0])
1420 __sign_size = __lc->_M_negative_sign_size;
1423 else if (__lc->_M_positive_sign_size
1424 && !__lc->_M_negative_sign_size)
1425 // "... if no sign is detected, the result is given the sign
1426 // that corresponds to the source of the empty string"
1428 else if (__mandatory_sign)
1429 __testvalid = false;
1431 case money_base::value:
1432 // Extract digits, remove and stash away the
1433 // grouping of found thousands separators.
1434 for (; __beg != __end; ++__beg)
1436 const char_type __c = *__beg;
1437 const char_type* __q = __traits_type::find(__lit_zero,
1441 __res += money_base::_S_atoms[__q - __lit];
1444 else if (__c == __lc->_M_decimal_point
1449 __testdecfound = true;
1451 else if (__lc->_M_use_grouping
1452 && __c == __lc->_M_thousands_sep
1457 // Mark position for later analysis.
1458 __grouping_tmp += static_cast<char>(__n);
1463 __testvalid = false;
1471 __testvalid = false;
1473 case money_base::space:
1474 // At least one space is required.
1475 if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
1478 __testvalid = false;
1479 case money_base::none:
1480 // Only if not at the end of the pattern.
1482 for (; __beg != __end
1483 && __ctype.is(ctype_base::space, *__beg); ++__beg);
1488 // Need to get the rest of the sign characters, if they exist.
1489 if (__sign_size > 1 && __testvalid)
1491 const char_type* __sign = __negative ? __lc->_M_negative_sign
1492 : __lc->_M_positive_sign;
1494 for (; __beg != __end && __i < __sign_size
1495 && *__beg == __sign[__i]; ++__beg, ++__i);
1497 if (__i != __sign_size)
1498 __testvalid = false;
1503 // Strip leading zeros.
1504 if (__res.size() > 1)
1506 const size_type __first = __res.find_first_not_of('0');
1507 const bool __only_zeros = __first == string::npos;
1509 __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
1513 if (__negative && __res[0] != '0')
1514 __res.insert(__res.begin(), '-');
1516 // Test for grouping fidelity.
1517 if (__grouping_tmp.size())
1519 // Add the ending grouping.
1520 __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
1522 if (!std::__verify_grouping(__lc->_M_grouping,
1523 __lc->_M_grouping_size,
1525 __err |= ios_base::failbit;
1528 // Iff not enough digits were supplied after the decimal-point.
1529 if (__testdecfound && __lc->_M_frac_digits > 0
1530 && __n != __lc->_M_frac_digits)
1531 __testvalid = false;
1534 // Iff valid sequence is not recognized.
1536 __err |= ios_base::failbit;
1538 __units.swap(__res);
1540 // Iff no more characters are available.
1542 __err |= ios_base::eofbit;
1546 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
1547 template<typename _CharT, typename _InIter>
1549 money_get<_CharT, _InIter>::
1550 __do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
1551 ios_base::iostate& __err, double& __units) const
1554 __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
1555 : _M_extract<false>(__beg, __end, __io, __err, __str);
1556 std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
1561 template<typename _CharT, typename _InIter>
1563 money_get<_CharT, _InIter>::
1564 do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
1565 ios_base::iostate& __err, long double& __units) const
1568 __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
1569 : _M_extract<false>(__beg, __end, __io, __err, __str);
1570 std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
1574 template<typename _CharT, typename _InIter>
1576 money_get<_CharT, _InIter>::
1577 do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
1578 ios_base::iostate& __err, string_type& __digits) const
1580 typedef typename string::size_type size_type;
1582 const locale& __loc = __io._M_getloc();
1583 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1586 __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
1587 : _M_extract<false>(__beg, __end, __io, __err, __str);
1588 const size_type __len = __str.size();
1591 __digits.resize(__len);
1592 __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
1597 template<typename _CharT, typename _OutIter>
1598 template<bool _Intl>
1600 money_put<_CharT, _OutIter>::
1601 _M_insert(iter_type __s, ios_base& __io, char_type __fill,
1602 const string_type& __digits) const
1604 typedef typename string_type::size_type size_type;
1605 typedef money_base::part part;
1606 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
1608 const locale& __loc = __io._M_getloc();
1609 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1611 __use_cache<__cache_type> __uc;
1612 const __cache_type* __lc = __uc(__loc);
1613 const char_type* __lit = __lc->_M_atoms;
1615 // Determine if negative or positive formats are to be used, and
1616 // discard leading negative_sign if it is present.
1617 const char_type* __beg = __digits.data();
1619 money_base::pattern __p;
1620 const char_type* __sign;
1621 size_type __sign_size;
1622 if (!(*__beg == __lit[money_base::_S_minus]))
1624 __p = __lc->_M_pos_format;
1625 __sign = __lc->_M_positive_sign;
1626 __sign_size = __lc->_M_positive_sign_size;
1630 __p = __lc->_M_neg_format;
1631 __sign = __lc->_M_negative_sign;
1632 __sign_size = __lc->_M_negative_sign_size;
1633 if (__digits.size())
1637 // Look for valid numbers in the ctype facet within input digits.
1638 size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
1639 __beg + __digits.size()) - __beg;
1642 // Assume valid input, and attempt to format.
1643 // Break down input numbers into base components, as follows:
1644 // final_value = grouped units + (decimal point) + (digits)
1645 string_type __value;
1646 __value.reserve(2 * __len);
1648 // Add thousands separators to non-decimal digits, per
1650 long __paddec = __len - __lc->_M_frac_digits;
1653 if (__lc->_M_frac_digits < 0)
1655 if (__lc->_M_grouping_size)
1657 __value.assign(2 * __paddec, char_type());
1659 std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
1661 __lc->_M_grouping_size,
1662 __beg, __beg + __paddec);
1663 __value.erase(__vend - &__value[0]);
1666 __value.assign(__beg, __paddec);
1669 // Deal with decimal point, decimal digits.
1670 if (__lc->_M_frac_digits > 0)
1672 __value += __lc->_M_decimal_point;
1674 __value.append(__beg + __paddec, __lc->_M_frac_digits);
1677 // Have to pad zeros in the decimal position.
1678 __value.append(-__paddec, __lit[money_base::_S_zero]);
1679 __value.append(__beg, __len);
1683 // Calculate length of resulting string.
1684 const ios_base::fmtflags __f = __io.flags()
1685 & ios_base::adjustfield;
1686 __len = __value.size() + __sign_size;
1687 __len += ((__io.flags() & ios_base::showbase)
1688 ? __lc->_M_curr_symbol_size : 0);
1691 __res.reserve(2 * __len);
1693 const size_type __width = static_cast<size_type>(__io.width());
1694 const bool __testipad = (__f == ios_base::internal
1695 && __len < __width);
1696 // Fit formatted digits into the required pattern.
1697 for (int __i = 0; __i < 4; ++__i)
1699 const part __which = static_cast<part>(__p.field[__i]);
1702 case money_base::symbol:
1703 if (__io.flags() & ios_base::showbase)
1704 __res.append(__lc->_M_curr_symbol,
1705 __lc->_M_curr_symbol_size);
1707 case money_base::sign:
1708 // Sign might not exist, or be more than one
1709 // charater long. In that case, add in the rest
1714 case money_base::value:
1717 case money_base::space:
1718 // At least one space is required, but if internal
1719 // formatting is required, an arbitrary number of
1720 // fill spaces will be necessary.
1722 __res.append(__width - __len, __fill);
1726 case money_base::none:
1728 __res.append(__width - __len, __fill);
1733 // Special case of multi-part sign parts.
1734 if (__sign_size > 1)
1735 __res.append(__sign + 1, __sign_size - 1);
1737 // Pad, if still necessary.
1738 __len = __res.size();
1739 if (__width > __len)
1741 if (__f == ios_base::left)
1743 __res.append(__width - __len, __fill);
1746 __res.insert(0, __width - __len, __fill);
1750 // Write resulting, fully-formatted string to output iterator.
1751 __s = std::__write(__s, __res.data(), __len);
1757 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
1758 template<typename _CharT, typename _OutIter>
1760 money_put<_CharT, _OutIter>::
1761 __do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
1762 double __units) const
1763 { return this->do_put(__s, __intl, __io, __fill, (long double) __units); }
1766 template<typename _CharT, typename _OutIter>
1768 money_put<_CharT, _OutIter>::
1769 do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
1770 long double __units) const
1772 const locale __loc = __io.getloc();
1773 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1774 #ifdef _GLIBCXX_USE_C99
1775 // First try a buffer perhaps big enough.
1777 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1778 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1779 // 328. Bad sprintf format modifier in money_put<>::do_put()
1780 int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
1781 "%.*Lf", 0, __units);
1782 // If the buffer was not large enough, try again with the correct size.
1783 if (__len >= __cs_size)
1785 __cs_size = __len + 1;
1786 __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1787 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
1788 "%.*Lf", 0, __units);
1791 // max_exponent10 + 1 for the integer part, + 2 for sign and '\0'.
1792 const int __cs_size = numeric_limits<long double>::max_exponent10 + 3;
1793 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1794 int __len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, "%.*Lf",
1797 string_type __digits(__len, char_type());
1798 __ctype.widen(__cs, __cs + __len, &__digits[0]);
1799 return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
1800 : _M_insert<false>(__s, __io, __fill, __digits);
1803 template<typename _CharT, typename _OutIter>
1805 money_put<_CharT, _OutIter>::
1806 do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
1807 const string_type& __digits) const
1808 { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
1809 : _M_insert<false>(__s, __io, __fill, __digits); }
1811 _GLIBCXX_END_LDBL_NAMESPACE
1813 // NB: Not especially useful. Without an ios_base object or some
1814 // kind of locale reference, we are left clawing at the air where
1815 // the side of the mountain used to be...
1816 template<typename _CharT, typename _InIter>
1817 time_base::dateorder
1818 time_get<_CharT, _InIter>::do_date_order() const
1819 { return time_base::no_order; }
1821 // Expand a strftime format string and parse it. E.g., do_get_date() may
1822 // pass %m/%d/%Y => extracted characters.
1823 template<typename _CharT, typename _InIter>
1825 time_get<_CharT, _InIter>::
1826 _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
1827 ios_base::iostate& __err, tm* __tm,
1828 const _CharT* __format) const
1830 const locale& __loc = __io._M_getloc();
1831 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
1832 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1833 const size_t __len = char_traits<_CharT>::length(__format);
1835 ios_base::iostate __tmperr = ios_base::goodbit;
1836 for (size_t __i = 0; __beg != __end && __i < __len && !__tmperr; ++__i)
1838 if (__ctype.narrow(__format[__i], 0) == '%')
1840 // Verify valid formatting code, attempt to extract.
1841 char __c = __ctype.narrow(__format[++__i], 0);
1843 if (__c == 'E' || __c == 'O')
1844 __c = __ctype.narrow(__format[++__i], 0);
1850 // Abbreviated weekday name [tm_wday]
1851 const char_type* __days1[7];
1852 __tp._M_days_abbreviated(__days1);
1853 __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
1857 // Weekday name [tm_wday].
1858 const char_type* __days2[7];
1859 __tp._M_days(__days2);
1860 __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
1865 // Abbreviated month name [tm_mon]
1866 const char_type* __months1[12];
1867 __tp._M_months_abbreviated(__months1);
1868 __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
1869 __months1, 12, __io, __tmperr);
1872 // Month name [tm_mon].
1873 const char_type* __months2[12];
1874 __tp._M_months(__months2);
1875 __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
1876 __months2, 12, __io, __tmperr);
1879 // Default time and date representation.
1880 const char_type* __dt[2];
1881 __tp._M_date_time_formats(__dt);
1882 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
1886 // Day [01, 31]. [tm_mday]
1887 __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
1891 // Day [1, 31], with single digits preceded by
1893 if (__ctype.is(ctype_base::space, *__beg))
1894 __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
1897 __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
1901 // Equivalent to %m/%d/%y.[tm_mon, tm_mday, tm_year]
1903 __ctype.widen(__cs, __cs + 9, __wcs);
1904 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
1908 // Hour [00, 23]. [tm_hour]
1909 __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
1913 // Hour [01, 12]. [tm_hour]
1914 __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
1918 // Month [01, 12]. [tm_mon]
1919 __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
1922 __tm->tm_mon = __mem - 1;
1925 // Minute [00, 59]. [tm_min]
1926 __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
1930 if (__ctype.narrow(*__beg, 0) == '\n')
1933 __tmperr |= ios_base::failbit;
1936 // Equivalent to (%H:%M).
1938 __ctype.widen(__cs, __cs + 6, __wcs);
1939 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
1943 // Seconds. [tm_sec]
1944 // [00, 60] in C99 (one leap-second), [00, 61] in C89.
1945 #ifdef _GLIBCXX_USE_C99
1946 __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
1948 __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 61, 2,
1953 if (__ctype.narrow(*__beg, 0) == '\t')
1956 __tmperr |= ios_base::failbit;
1959 // Equivalent to (%H:%M:%S).
1961 __ctype.widen(__cs, __cs + 9, __wcs);
1962 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
1967 const char_type* __dates[2];
1968 __tp._M_date_formats(__dates);
1969 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
1974 const char_type* __times[2];
1975 __tp._M_time_formats(__times);
1976 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
1981 // Two digit year. [tm_year]
1982 __beg = _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2,
1986 // Year [1900). [tm_year]
1987 __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
1990 __tm->tm_year = __mem - 1900;
1994 if (__ctype.is(ctype_base::upper, *__beg))
1997 __beg = _M_extract_name(__beg, __end, __tmp,
1998 __timepunct_cache<_CharT>::_S_timezones,
1999 14, __io, __tmperr);
2001 // GMT requires special effort.
2002 if (__beg != __end && !__tmperr && __tmp == 0
2003 && (*__beg == __ctype.widen('-')
2004 || *__beg == __ctype.widen('+')))
2006 __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
2008 __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
2013 __tmperr |= ios_base::failbit;
2017 __tmperr |= ios_base::failbit;
2022 // Verify format and input match, extract and discard.
2023 if (__format[__i] == *__beg)
2026 __tmperr |= ios_base::failbit;
2031 __err |= ios_base::failbit;
2036 template<typename _CharT, typename _InIter>
2038 time_get<_CharT, _InIter>::
2039 _M_extract_num(iter_type __beg, iter_type __end, int& __member,
2040 int __min, int __max, size_t __len,
2041 ios_base& __io, ios_base::iostate& __err) const
2043 const locale& __loc = __io._M_getloc();
2044 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2046 // As-is works for __len = 1, 2, 4, the values actually used.
2047 int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
2052 for (; __beg != __end && __i < __len; ++__beg, ++__i)
2054 const char __c = __ctype.narrow(*__beg, '*');
2055 if (__c >= '0' && __c <= '9')
2057 __value = __value * 10 + (__c - '0');
2058 const int __valuec = __value * __mult;
2059 if (__valuec > __max || __valuec + __mult < __min)
2069 __err |= ios_base::failbit;
2075 // All elements in __names are unique.
2076 template<typename _CharT, typename _InIter>
2078 time_get<_CharT, _InIter>::
2079 _M_extract_name(iter_type __beg, iter_type __end, int& __member,
2080 const _CharT** __names, size_t __indexlen,
2081 ios_base& __io, ios_base::iostate& __err) const
2083 typedef char_traits<_CharT> __traits_type;
2084 const locale& __loc = __io._M_getloc();
2085 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2087 int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
2089 size_t __nmatches = 0;
2091 bool __testvalid = true;
2092 const char_type* __name;
2094 // Look for initial matches.
2095 // NB: Some of the locale data is in the form of all lowercase
2096 // names, and some is in the form of initially-capitalized
2097 // names. Look for both.
2100 const char_type __c = *__beg;
2101 for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
2102 if (__c == __names[__i1][0]
2103 || __c == __ctype.toupper(__names[__i1][0]))
2104 __matches[__nmatches++] = __i1;
2107 while (__nmatches > 1)
2109 // Find smallest matching string.
2110 size_t __minlen = __traits_type::length(__names[__matches[0]]);
2111 for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
2112 __minlen = std::min(__minlen,
2113 __traits_type::length(__names[__matches[__i2]]));
2115 if (__pos < __minlen && __beg != __end)
2116 for (size_t __i3 = 0; __i3 < __nmatches;)
2118 __name = __names[__matches[__i3]];
2119 if (!(__name[__pos] == *__beg))
2120 __matches[__i3] = __matches[--__nmatches];
2128 if (__nmatches == 1)
2130 // Make sure found name is completely extracted.
2132 __name = __names[__matches[0]];
2133 const size_t __len = __traits_type::length(__name);
2134 while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
2138 __member = __matches[0];
2140 __testvalid = false;
2143 __testvalid = false;
2145 __err |= ios_base::failbit;
2150 template<typename _CharT, typename _InIter>
2152 time_get<_CharT, _InIter>::
2153 do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
2154 ios_base::iostate& __err, tm* __tm) const
2156 const locale& __loc = __io._M_getloc();
2157 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
2158 const char_type* __times[2];
2159 __tp._M_time_formats(__times);
2160 __beg = _M_extract_via_format(__beg, __end, __io, __err,
2163 __err |= ios_base::eofbit;
2167 template<typename _CharT, typename _InIter>
2169 time_get<_CharT, _InIter>::
2170 do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
2171 ios_base::iostate& __err, tm* __tm) const
2173 const locale& __loc = __io._M_getloc();
2174 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
2175 const char_type* __dates[2];
2176 __tp._M_date_formats(__dates);
2177 __beg = _M_extract_via_format(__beg, __end, __io, __err,
2180 __err |= ios_base::eofbit;
2184 template<typename _CharT, typename _InIter>
2186 time_get<_CharT, _InIter>::
2187 do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
2188 ios_base::iostate& __err, tm* __tm) const
2190 typedef char_traits<_CharT> __traits_type;
2191 const locale& __loc = __io._M_getloc();
2192 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
2193 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2194 const char_type* __days[7];
2195 __tp._M_days_abbreviated(__days);
2197 ios_base::iostate __tmperr = ios_base::goodbit;
2198 __beg = _M_extract_name(__beg, __end, __tmpwday, __days, 7,
2201 // Check to see if non-abbreviated name exists, and extract.
2202 // NB: Assumes both _M_days and _M_days_abbreviated organized in
2203 // exact same order, first to last, such that the resulting
2204 // __days array with the same index points to a day, and that
2205 // day's abbreviated form.
2206 // NB: Also assumes that an abbreviated name is a subset of the name.
2207 if (!__tmperr && __beg != __end)
2209 size_t __pos = __traits_type::length(__days[__tmpwday]);
2210 __tp._M_days(__days);
2211 const char_type* __name = __days[__tmpwday];
2212 if (__name[__pos] == *__beg)
2214 // Extract the rest of it.
2215 const size_t __len = __traits_type::length(__name);
2216 while (__pos < __len && __beg != __end
2217 && __name[__pos] == *__beg)
2220 __tmperr |= ios_base::failbit;
2224 __tm->tm_wday = __tmpwday;
2226 __err |= ios_base::failbit;
2229 __err |= ios_base::eofbit;
2233 template<typename _CharT, typename _InIter>
2235 time_get<_CharT, _InIter>::
2236 do_get_monthname(iter_type __beg, iter_type __end,
2237 ios_base& __io, ios_base::iostate& __err, tm* __tm) const
2239 typedef char_traits<_CharT> __traits_type;
2240 const locale& __loc = __io._M_getloc();
2241 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
2242 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2243 const char_type* __months[12];
2244 __tp._M_months_abbreviated(__months);
2246 ios_base::iostate __tmperr = ios_base::goodbit;
2247 __beg = _M_extract_name(__beg, __end, __tmpmon, __months, 12,
2250 // Check to see if non-abbreviated name exists, and extract.
2251 // NB: Assumes both _M_months and _M_months_abbreviated organized in
2252 // exact same order, first to last, such that the resulting
2253 // __months array with the same index points to a month, and that
2254 // month's abbreviated form.
2255 // NB: Also assumes that an abbreviated name is a subset of the name.
2256 if (!__tmperr && __beg != __end)
2258 size_t __pos = __traits_type::length(__months[__tmpmon]);
2259 __tp._M_months(__months);
2260 const char_type* __name = __months[__tmpmon];
2261 if (__name[__pos] == *__beg)
2263 // Extract the rest of it.
2264 const size_t __len = __traits_type::length(__name);
2265 while (__pos < __len && __beg != __end
2266 && __name[__pos] == *__beg)
2269 __tmperr |= ios_base::failbit;
2273 __tm->tm_mon = __tmpmon;
2275 __err |= ios_base::failbit;
2278 __err |= ios_base::eofbit;
2282 template<typename _CharT, typename _InIter>
2284 time_get<_CharT, _InIter>::
2285 do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
2286 ios_base::iostate& __err, tm* __tm) const
2288 const locale& __loc = __io._M_getloc();
2289 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2293 for (; __beg != __end && __i < 4; ++__beg, ++__i)
2295 const char __c = __ctype.narrow(*__beg, '*');
2296 if (__c >= '0' && __c <= '9')
2297 __value = __value * 10 + (__c - '0');
2301 if (__i == 2 || __i == 4)
2302 __tm->tm_year = __i == 2 ? __value : __value - 1900;
2304 __err |= ios_base::failbit;
2307 __err |= ios_base::eofbit;
2311 template<typename _CharT, typename _OutIter>
2313 time_put<_CharT, _OutIter>::
2314 put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
2315 const _CharT* __beg, const _CharT* __end) const
2317 const locale& __loc = __io._M_getloc();
2318 ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
2319 for (; __beg != __end; ++__beg)
2320 if (__ctype.narrow(*__beg, 0) != '%')
2325 else if (++__beg != __end)
2329 const char __c = __ctype.narrow(*__beg, 0);
2330 if (__c != 'E' && __c != 'O')
2332 else if (++__beg != __end)
2335 __format = __ctype.narrow(*__beg, 0);
2339 __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
2346 template<typename _CharT, typename _OutIter>
2348 time_put<_CharT, _OutIter>::
2349 do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
2350 char __format, char __mod) const
2352 const locale& __loc = __io._M_getloc();
2353 ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
2354 __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
2356 // NB: This size is arbitrary. Should this be a data member,
2357 // initialized at construction?
2358 const size_t __maxlen = 128;
2360 static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __maxlen));
2362 // NB: In IEE 1003.1-200x, and perhaps other locale models, it
2363 // is possible that the format character will be longer than one
2364 // character. Possibilities include 'E' or 'O' followed by a
2365 // format character: if __mod is not the default argument, assume
2366 // it's a valid modifier.
2368 __fmt[0] = __ctype.widen('%');
2371 __fmt[1] = __format;
2372 __fmt[2] = char_type();
2377 __fmt[2] = __format;
2378 __fmt[3] = char_type();
2381 __tp._M_put(__res, __maxlen, __fmt, __tm);
2383 // Write resulting, fully-formatted string to output iterator.
2384 return std::__write(__s, __res, char_traits<char_type>::length(__res));
2387 // Generic version does nothing.
2388 template<typename _CharT>
2390 collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const
2393 // Generic version does nothing.
2394 template<typename _CharT>
2396 collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const
2399 template<typename _CharT>
2402 do_compare(const _CharT* __lo1, const _CharT* __hi1,
2403 const _CharT* __lo2, const _CharT* __hi2) const
2405 // strcoll assumes zero-terminated strings so we make a copy
2406 // and then put a zero at the end.
2407 const string_type __one(__lo1, __hi1);
2408 const string_type __two(__lo2, __hi2);
2410 const _CharT* __p = __one.c_str();
2411 const _CharT* __pend = __one.data() + __one.length();
2412 const _CharT* __q = __two.c_str();
2413 const _CharT* __qend = __two.data() + __two.length();
2415 // strcoll stops when it sees a nul character so we break
2416 // the strings into zero-terminated substrings and pass those
2420 const int __res = _M_compare(__p, __q);
2424 __p += char_traits<_CharT>::length(__p);
2425 __q += char_traits<_CharT>::length(__q);
2426 if (__p == __pend && __q == __qend)
2428 else if (__p == __pend)
2430 else if (__q == __qend)
2438 template<typename _CharT>
2439 typename collate<_CharT>::string_type
2441 do_transform(const _CharT* __lo, const _CharT* __hi) const
2445 // strxfrm assumes zero-terminated strings so we make a copy
2446 const string_type __str(__lo, __hi);
2448 const _CharT* __p = __str.c_str();
2449 const _CharT* __pend = __str.data() + __str.length();
2451 size_t __len = (__hi - __lo) * 2;
2453 _CharT* __c = new _CharT[__len];
2457 // strxfrm stops when it sees a nul character so we break
2458 // the string into zero-terminated substrings and pass those
2462 // First try a buffer perhaps big enough.
2463 size_t __res = _M_transform(__c, __p, __len);
2464 // If the buffer was not large enough, try again with the
2469 delete [] __c, __c = 0;
2470 __c = new _CharT[__len];
2471 __res = _M_transform(__c, __p, __len);
2474 __ret.append(__c, __res);
2475 __p += char_traits<_CharT>::length(__p);
2480 __ret.push_back(_CharT());
2486 __throw_exception_again;
2494 template<typename _CharT>
2497 do_hash(const _CharT* __lo, const _CharT* __hi) const
2499 unsigned long __val = 0;
2500 for (; __lo < __hi; ++__lo)
2501 __val = *__lo + ((__val << 7) |
2502 (__val >> (numeric_limits<unsigned long>::digits - 7)));
2503 return static_cast<long>(__val);
2506 // Construct correctly padded string, as per 22.2.2.2.2
2508 // __newlen > __oldlen
2509 // __news is allocated for __newlen size
2510 // Used by both num_put and ostream inserters: if __num,
2511 // internal-adjusted objects are padded according to the rules below
2512 // concerning 0[xX] and +-, otherwise, exactly as right-adjusted
2515 // NB: Of the two parameters, _CharT can be deduced from the
2516 // function arguments. The other (_Traits) has to be explicitly specified.
2517 template<typename _CharT, typename _Traits>
2519 __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
2520 _CharT* __news, const _CharT* __olds,
2521 const streamsize __newlen,
2522 const streamsize __oldlen, const bool __num)
2524 const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
2525 const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
2528 if (__adjust == ios_base::left)
2530 _Traits::copy(__news, const_cast<_CharT*>(__olds), __oldlen);
2531 _Traits::assign(__news + __oldlen, __plen, __fill);
2536 if (__adjust == ios_base::internal && __num)
2538 // Pad after the sign, if there is one.
2539 // Pad after 0[xX], if there is one.
2540 // Who came up with these rules, anyway? Jeeze.
2541 const locale& __loc = __io._M_getloc();
2542 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
2544 const bool __testsign = (__ctype.widen('-') == __olds[0]
2545 || __ctype.widen('+') == __olds[0]);
2546 const bool __testhex = (__ctype.widen('0') == __olds[0]
2548 && (__ctype.widen('x') == __olds[1]
2549 || __ctype.widen('X') == __olds[1]));
2552 __news[0] = __olds[0];
2553 __news[1] = __olds[1];
2557 else if (__testsign)
2559 __news[0] = __olds[0];
2563 // else Padding first.
2565 _Traits::assign(__news, __plen, __fill);
2566 _Traits::copy(__news + __plen, const_cast<_CharT*>(__olds + __mod),
2571 __verify_grouping(const char* __grouping, size_t __grouping_size,
2572 const string& __grouping_tmp)
2574 const size_t __n = __grouping_tmp.size() - 1;
2575 const size_t __min = std::min(__n, size_t(__grouping_size - 1));
2579 // Parsed number groupings have to match the
2580 // numpunct::grouping string exactly, starting at the
2581 // right-most point of the parsed sequence of elements ...
2582 for (size_t __j = 0; __j < __min && __test; --__i, ++__j)
2583 __test = __grouping_tmp[__i] == __grouping[__j];
2584 for (; __i && __test; --__i)
2585 __test = __grouping_tmp[__i] == __grouping[__min];
2586 // ... but the first parsed grouping can be <= numpunct
2587 // grouping (only do the check if the numpunct char is > 0
2588 // because <= 0 means any size is ok).
2589 if (static_cast<signed char>(__grouping[__min]) > 0)
2590 __test &= __grouping_tmp[0] <= __grouping[__min];
2594 template<typename _CharT>
2596 __add_grouping(_CharT* __s, _CharT __sep,
2597 const char* __gbeg, size_t __gsize,
2598 const _CharT* __first, const _CharT* __last)
2603 while (__last - __first > __gbeg[__idx]
2604 && static_cast<signed char>(__gbeg[__idx]) > 0)
2606 __last -= __gbeg[__idx];
2607 __idx < __gsize - 1 ? ++__idx : ++__ctr;
2610 while (__first != __last)
2611 *__s++ = *__first++;
2616 for (char __i = __gbeg[__idx]; __i > 0; --__i)
2617 *__s++ = *__first++;
2623 for (char __i = __gbeg[__idx]; __i > 0; --__i)
2624 *__s++ = *__first++;
2630 // Inhibit implicit instantiations for required instantiations,
2631 // which are defined via explicit instantiations elsewhere.
2632 // NB: This syntax is a GNU extension.
2633 #if _GLIBCXX_EXTERN_TEMPLATE
2634 extern template class moneypunct<char, false>;
2635 extern template class moneypunct<char, true>;
2636 extern template class moneypunct_byname<char, false>;
2637 extern template class moneypunct_byname<char, true>;
2638 extern template class _GLIBCXX_LDBL_NAMESPACE money_get<char>;
2639 extern template class _GLIBCXX_LDBL_NAMESPACE money_put<char>;
2640 extern template class numpunct<char>;
2641 extern template class numpunct_byname<char>;
2642 extern template class _GLIBCXX_LDBL_NAMESPACE num_get<char>;
2643 extern template class _GLIBCXX_LDBL_NAMESPACE num_put<char>;
2644 extern template class __timepunct<char>;
2645 extern template class time_put<char>;
2646 extern template class time_put_byname<char>;
2647 extern template class time_get<char>;
2648 extern template class time_get_byname<char>;
2649 extern template class messages<char>;
2650 extern template class messages_byname<char>;
2651 extern template class ctype_byname<char>;
2652 extern template class codecvt_byname<char, char, mbstate_t>;
2653 extern template class collate<char>;
2654 extern template class collate_byname<char>;
2657 const codecvt<char, char, mbstate_t>&
2658 use_facet<codecvt<char, char, mbstate_t> >(const locale&);
2661 const collate<char>&
2662 use_facet<collate<char> >(const locale&);
2665 const numpunct<char>&
2666 use_facet<numpunct<char> >(const locale&);
2669 const num_put<char>&
2670 use_facet<num_put<char> >(const locale&);
2673 const num_get<char>&
2674 use_facet<num_get<char> >(const locale&);
2677 const moneypunct<char, true>&
2678 use_facet<moneypunct<char, true> >(const locale&);
2681 const moneypunct<char, false>&
2682 use_facet<moneypunct<char, false> >(const locale&);
2685 const money_put<char>&
2686 use_facet<money_put<char> >(const locale&);
2689 const money_get<char>&
2690 use_facet<money_get<char> >(const locale&);
2693 const __timepunct<char>&
2694 use_facet<__timepunct<char> >(const locale&);
2697 const time_put<char>&
2698 use_facet<time_put<char> >(const locale&);
2701 const time_get<char>&
2702 use_facet<time_get<char> >(const locale&);
2705 const messages<char>&
2706 use_facet<messages<char> >(const locale&);
2710 has_facet<ctype<char> >(const locale&);
2714 has_facet<codecvt<char, char, mbstate_t> >(const locale&);
2718 has_facet<collate<char> >(const locale&);
2722 has_facet<numpunct<char> >(const locale&);
2726 has_facet<num_put<char> >(const locale&);
2730 has_facet<num_get<char> >(const locale&);
2734 has_facet<moneypunct<char> >(const locale&);
2738 has_facet<money_put<char> >(const locale&);
2742 has_facet<money_get<char> >(const locale&);
2746 has_facet<__timepunct<char> >(const locale&);
2750 has_facet<time_put<char> >(const locale&);
2754 has_facet<time_get<char> >(const locale&);
2758 has_facet<messages<char> >(const locale&);
2760 #ifdef _GLIBCXX_USE_WCHAR_T
2761 extern template class moneypunct<wchar_t, false>;
2762 extern template class moneypunct<wchar_t, true>;
2763 extern template class moneypunct_byname<wchar_t, false>;
2764 extern template class moneypunct_byname<wchar_t, true>;
2765 extern template class _GLIBCXX_LDBL_NAMESPACE money_get<wchar_t>;
2766 extern template class _GLIBCXX_LDBL_NAMESPACE money_put<wchar_t>;
2767 extern template class numpunct<wchar_t>;
2768 extern template class numpunct_byname<wchar_t>;
2769 extern template class _GLIBCXX_LDBL_NAMESPACE num_get<wchar_t>;
2770 extern template class _GLIBCXX_LDBL_NAMESPACE num_put<wchar_t>;
2771 extern template class __timepunct<wchar_t>;
2772 extern template class time_put<wchar_t>;
2773 extern template class time_put_byname<wchar_t>;
2774 extern template class time_get<wchar_t>;
2775 extern template class time_get_byname<wchar_t>;
2776 extern template class messages<wchar_t>;
2777 extern template class messages_byname<wchar_t>;
2778 extern template class ctype_byname<wchar_t>;
2779 extern template class codecvt_byname<wchar_t, char, mbstate_t>;
2780 extern template class collate<wchar_t>;
2781 extern template class collate_byname<wchar_t>;
2784 const codecvt<wchar_t, char, mbstate_t>&
2785 use_facet<codecvt<wchar_t, char, mbstate_t> >(locale const&);
2788 const collate<wchar_t>&
2789 use_facet<collate<wchar_t> >(const locale&);
2792 const numpunct<wchar_t>&
2793 use_facet<numpunct<wchar_t> >(const locale&);
2796 const num_put<wchar_t>&
2797 use_facet<num_put<wchar_t> >(const locale&);
2800 const num_get<wchar_t>&
2801 use_facet<num_get<wchar_t> >(const locale&);
2804 const moneypunct<wchar_t, true>&
2805 use_facet<moneypunct<wchar_t, true> >(const locale&);
2808 const moneypunct<wchar_t, false>&
2809 use_facet<moneypunct<wchar_t, false> >(const locale&);
2812 const money_put<wchar_t>&
2813 use_facet<money_put<wchar_t> >(const locale&);
2816 const money_get<wchar_t>&
2817 use_facet<money_get<wchar_t> >(const locale&);
2820 const __timepunct<wchar_t>&
2821 use_facet<__timepunct<wchar_t> >(const locale&);
2824 const time_put<wchar_t>&
2825 use_facet<time_put<wchar_t> >(const locale&);
2828 const time_get<wchar_t>&
2829 use_facet<time_get<wchar_t> >(const locale&);
2832 const messages<wchar_t>&
2833 use_facet<messages<wchar_t> >(const locale&);
2837 has_facet<ctype<wchar_t> >(const locale&);
2841 has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
2845 has_facet<collate<wchar_t> >(const locale&);
2849 has_facet<numpunct<wchar_t> >(const locale&);
2853 has_facet<num_put<wchar_t> >(const locale&);
2857 has_facet<num_get<wchar_t> >(const locale&);
2861 has_facet<moneypunct<wchar_t> >(const locale&);
2865 has_facet<money_put<wchar_t> >(const locale&);
2869 has_facet<money_get<wchar_t> >(const locale&);
2873 has_facet<__timepunct<wchar_t> >(const locale&);
2877 has_facet<time_put<wchar_t> >(const locale&);
2881 has_facet<time_get<wchar_t> >(const locale&);
2885 has_facet<messages<wchar_t> >(const locale&);
2889 _GLIBCXX_END_NAMESPACE