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 _GLIBCXX_BEGIN_NAMESPACE(std)
44 // Routine to access a cache for the facet. If the cache didn't
45 // exist before, it gets constructed on the fly.
46 template<typename _Facet>
50 operator() (const locale& __loc) const;
54 template<typename _CharT>
55 struct __use_cache<__numpunct_cache<_CharT> >
57 const __numpunct_cache<_CharT>*
58 operator() (const locale& __loc) const
60 const size_t __i = numpunct<_CharT>::id._M_id();
61 const locale::facet** __caches = __loc._M_impl->_M_caches;
64 __numpunct_cache<_CharT>* __tmp = NULL;
67 __tmp = new __numpunct_cache<_CharT>;
68 __tmp->_M_cache(__loc);
73 __throw_exception_again;
75 __loc._M_impl->_M_install_cache(__tmp, __i);
77 return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
81 template<typename _CharT>
83 __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
87 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
89 _M_grouping_size = __np.grouping().size();
90 char* __grouping = new char[_M_grouping_size];
91 __np.grouping().copy(__grouping, _M_grouping_size);
92 _M_grouping = __grouping;
93 _M_use_grouping = (_M_grouping_size
94 && static_cast<signed char>(__np.grouping()[0]) > 0);
96 _M_truename_size = __np.truename().size();
97 _CharT* __truename = new _CharT[_M_truename_size];
98 __np.truename().copy(__truename, _M_truename_size);
99 _M_truename = __truename;
101 _M_falsename_size = __np.falsename().size();
102 _CharT* __falsename = new _CharT[_M_falsename_size];
103 __np.falsename().copy(__falsename, _M_falsename_size);
104 _M_falsename = __falsename;
106 _M_decimal_point = __np.decimal_point();
107 _M_thousands_sep = __np.thousands_sep();
109 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
110 __ct.widen(__num_base::_S_atoms_out,
111 __num_base::_S_atoms_out + __num_base::_S_oend, _M_atoms_out);
112 __ct.widen(__num_base::_S_atoms_in,
113 __num_base::_S_atoms_in + __num_base::_S_iend, _M_atoms_in);
116 // Used by both numeric and monetary facets.
117 // Check to make sure that the __grouping_tmp string constructed in
118 // money_get or num_get matches the canonical grouping for a given
120 // __grouping_tmp is parsed L to R
121 // 1,222,444 == __grouping_tmp of "\1\3\3"
122 // __grouping is parsed R to L
123 // 1,222,444 == __grouping of "\3" == "\3\3\3"
125 __verify_grouping(const char* __grouping, size_t __grouping_size,
126 const string& __grouping_tmp);
128 _GLIBCXX_BEGIN_LDBL_NAMESPACE
130 template<typename _CharT, typename _InIter>
132 num_get<_CharT, _InIter>::
133 _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
134 ios_base::iostate& __err, string& __xtrc) const
136 typedef char_traits<_CharT> __traits_type;
137 typedef __numpunct_cache<_CharT> __cache_type;
138 __use_cache<__cache_type> __uc;
139 const locale& __loc = __io._M_getloc();
140 const __cache_type* __lc = __uc(__loc);
141 const _CharT* __lit = __lc->_M_atoms_in;
142 char_type __c = char_type();
144 // True if __beg becomes equal to __end.
145 bool __testeof = __beg == __end;
147 // First check for sign.
151 const bool __plus = __c == __lit[__num_base::_S_iplus];
152 if ((__plus || __c == __lit[__num_base::_S_iminus])
153 && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
154 && !(__c == __lc->_M_decimal_point))
156 __xtrc += __plus ? '+' : '-';
157 if (++__beg != __end)
164 // Next, look for leading zeros.
165 bool __found_mantissa = false;
169 if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
170 || __c == __lc->_M_decimal_point)
172 else if (__c == __lit[__num_base::_S_izero])
174 if (!__found_mantissa)
177 __found_mantissa = true;
181 if (++__beg != __end)
190 // Only need acceptable digits for floating point numbers.
191 bool __found_dec = false;
192 bool __found_sci = false;
193 string __found_grouping;
194 if (__lc->_M_use_grouping)
195 __found_grouping.reserve(32);
196 const char_type* __lit_zero = __lit + __num_base::_S_izero;
198 if (!__lc->_M_allocated)
202 const int __digit = _M_find(__lit_zero, 10, __c);
205 __xtrc += '0' + __digit;
206 __found_mantissa = true;
208 else if (__c == __lc->_M_decimal_point
209 && !__found_dec && !__found_sci)
214 else if ((__c == __lit[__num_base::_S_ie]
215 || __c == __lit[__num_base::_S_iE])
216 && !__found_sci && __found_mantissa)
218 // Scientific notation.
222 // Remove optional plus or minus sign, if they exist.
223 if (++__beg != __end)
226 const bool __plus = __c == __lit[__num_base::_S_iplus];
227 if (__plus || __c == __lit[__num_base::_S_iminus])
228 __xtrc += __plus ? '+' : '-';
241 if (++__beg != __end)
249 // According to 22.2.2.1.2, p8-9, first look for thousands_sep
250 // and decimal_point.
251 if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
253 if (!__found_dec && !__found_sci)
255 // NB: Thousands separator at the beginning of a string
256 // is a no-no, as is two consecutive thousands separators.
259 __found_grouping += static_cast<char>(__sep_pos);
264 // NB: __convert_to_v will not assign __v and will
273 else if (__c == __lc->_M_decimal_point)
275 if (!__found_dec && !__found_sci)
277 // If no grouping chars are seen, no grouping check
278 // is applied. Therefore __found_grouping is adjusted
279 // only if decimal_point comes after some thousands_sep.
280 if (__found_grouping.size())
281 __found_grouping += static_cast<char>(__sep_pos);
290 const char_type* __q =
291 __traits_type::find(__lit_zero, 10, __c);
294 __xtrc += '0' + (__q - __lit_zero);
295 __found_mantissa = true;
298 else if ((__c == __lit[__num_base::_S_ie]
299 || __c == __lit[__num_base::_S_iE])
300 && !__found_sci && __found_mantissa)
302 // Scientific notation.
303 if (__found_grouping.size() && !__found_dec)
304 __found_grouping += static_cast<char>(__sep_pos);
308 // Remove optional plus or minus sign, if they exist.
309 if (++__beg != __end)
312 const bool __plus = __c == __lit[__num_base::_S_iplus];
313 if ((__plus || __c == __lit[__num_base::_S_iminus])
314 && !(__lc->_M_use_grouping
315 && __c == __lc->_M_thousands_sep)
316 && !(__c == __lc->_M_decimal_point))
317 __xtrc += __plus ? '+' : '-';
331 if (++__beg != __end)
337 // Digit grouping is checked. If grouping and found_grouping don't
338 // match, then get very very upset, and set failbit.
339 if (__found_grouping.size())
341 // Add the ending grouping if a decimal or 'e'/'E' wasn't found.
342 if (!__found_dec && !__found_sci)
343 __found_grouping += static_cast<char>(__sep_pos);
345 if (!std::__verify_grouping(__lc->_M_grouping,
346 __lc->_M_grouping_size,
348 __err |= ios_base::failbit;
353 __err |= ios_base::eofbit;
357 template<typename _CharT, typename _InIter>
358 template<typename _ValueT>
360 num_get<_CharT, _InIter>::
361 _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
362 ios_base::iostate& __err, _ValueT& __v) const
364 typedef char_traits<_CharT> __traits_type;
365 using __gnu_cxx::__add_unsigned;
366 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
367 typedef __numpunct_cache<_CharT> __cache_type;
368 __use_cache<__cache_type> __uc;
369 const locale& __loc = __io._M_getloc();
370 const __cache_type* __lc = __uc(__loc);
371 const _CharT* __lit = __lc->_M_atoms_in;
372 char_type __c = char_type();
374 // NB: Iff __basefield == 0, __base can change based on contents.
375 const ios_base::fmtflags __basefield = __io.flags()
376 & ios_base::basefield;
377 const bool __oct = __basefield == ios_base::oct;
378 int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
380 // True if __beg becomes equal to __end.
381 bool __testeof = __beg == __end;
383 // First check for sign.
384 bool __negative = false;
388 if (__gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
389 __negative = __c == __lit[__num_base::_S_iminus];
390 if ((__negative || __c == __lit[__num_base::_S_iplus])
391 && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
392 && !(__c == __lc->_M_decimal_point))
394 if (++__beg != __end)
401 // Next, look for leading zeros and check required digits
403 bool __found_zero = false;
407 if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
408 || __c == __lc->_M_decimal_point)
410 else if (__c == __lit[__num_base::_S_izero]
411 && (!__found_zero || __base == 10))
415 if (__basefield == 0)
420 else if (__found_zero
421 && (__c == __lit[__num_base::_S_ix]
422 || __c == __lit[__num_base::_S_iX]))
424 if (__basefield == 0)
428 __found_zero = false;
437 if (++__beg != __end)
447 // At this point, base is determined. If not hex, only allow
448 // base digits as valid input.
449 const size_t __len = (__base == 16 ? __num_base::_S_iend
450 - __num_base::_S_izero : __base);
453 string __found_grouping;
454 if (__lc->_M_use_grouping)
455 __found_grouping.reserve(32);
456 bool __testfail = false;
457 const __unsigned_type __max = __negative
458 ? -__gnu_cxx::__numeric_traits<_ValueT>::__min
459 : __gnu_cxx::__numeric_traits<_ValueT>::__max;
460 const __unsigned_type __smax = __max / __base;
461 __unsigned_type __result = 0;
463 const char_type* __lit_zero = __lit + __num_base::_S_izero;
465 if (!__lc->_M_allocated)
469 __digit = _M_find(__lit_zero, __len, __c);
473 if (__result > __smax)
478 __testfail |= __result > __max - __digit;
483 if (++__beg != __end)
491 // According to 22.2.2.1.2, p8-9, first look for thousands_sep
492 // and decimal_point.
493 if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
495 // NB: Thousands separator at the beginning of a string
496 // is a no-no, as is two consecutive thousands separators.
499 __found_grouping += static_cast<char>(__sep_pos);
508 else if (__c == __lc->_M_decimal_point)
512 const char_type* __q =
513 __traits_type::find(__lit_zero, __len, __c);
517 __digit = __q - __lit_zero;
520 if (__result > __smax)
525 __testfail |= __result > __max - __digit;
531 if (++__beg != __end)
537 // Digit grouping is checked. If grouping and found_grouping don't
538 // match, then get very very upset, and set failbit.
539 if (__found_grouping.size())
541 // Add the ending grouping.
542 __found_grouping += static_cast<char>(__sep_pos);
544 if (!std::__verify_grouping(__lc->_M_grouping,
545 __lc->_M_grouping_size,
547 __err |= ios_base::failbit;
550 if (!__testfail && (__sep_pos || __found_zero
551 || __found_grouping.size()))
552 __v = __negative ? -__result : __result;
554 __err |= ios_base::failbit;
557 __err |= ios_base::eofbit;
561 // _GLIBCXX_RESOLVE_LIB_DEFECTS
562 // 17. Bad bool parsing
563 template<typename _CharT, typename _InIter>
565 num_get<_CharT, _InIter>::
566 do_get(iter_type __beg, iter_type __end, ios_base& __io,
567 ios_base::iostate& __err, bool& __v) const
569 if (!(__io.flags() & ios_base::boolalpha))
571 // Parse bool values as long.
572 // NB: We can't just call do_get(long) here, as it might
573 // refer to a derived class.
575 __beg = _M_extract_int(__beg, __end, __io, __err, __l);
576 if (__l == 0 || __l == 1)
579 __err |= ios_base::failbit;
583 // Parse bool values as alphanumeric.
584 typedef __numpunct_cache<_CharT> __cache_type;
585 __use_cache<__cache_type> __uc;
586 const locale& __loc = __io._M_getloc();
587 const __cache_type* __lc = __uc(__loc);
592 bool __testeof = __beg == __end;
593 for (__n = 0; !__testeof; ++__n)
595 const char_type __c = *__beg;
599 if (__n < __lc->_M_falsename_size)
600 __testf = __c == __lc->_M_falsename[__n];
607 if (__n < __lc->_M_truename_size)
608 __testt = __c == __lc->_M_truename[__n];
613 if (!__testf && !__testt)
616 if (++__beg == __end)
619 if (__testf && __n == __lc->_M_falsename_size)
621 else if (__testt && __n == __lc->_M_truename_size)
624 __err |= ios_base::failbit;
627 __err |= ios_base::eofbit;
632 template<typename _CharT, typename _InIter>
634 num_get<_CharT, _InIter>::
635 do_get(iter_type __beg, iter_type __end, ios_base& __io,
636 ios_base::iostate& __err, long& __v) const
637 { return _M_extract_int(__beg, __end, __io, __err, __v); }
639 template<typename _CharT, typename _InIter>
641 num_get<_CharT, _InIter>::
642 do_get(iter_type __beg, iter_type __end, ios_base& __io,
643 ios_base::iostate& __err, unsigned short& __v) const
644 { return _M_extract_int(__beg, __end, __io, __err, __v); }
646 template<typename _CharT, typename _InIter>
648 num_get<_CharT, _InIter>::
649 do_get(iter_type __beg, iter_type __end, ios_base& __io,
650 ios_base::iostate& __err, unsigned int& __v) const
651 { return _M_extract_int(__beg, __end, __io, __err, __v); }
653 template<typename _CharT, typename _InIter>
655 num_get<_CharT, _InIter>::
656 do_get(iter_type __beg, iter_type __end, ios_base& __io,
657 ios_base::iostate& __err, unsigned long& __v) const
658 { return _M_extract_int(__beg, __end, __io, __err, __v); }
660 #ifdef _GLIBCXX_USE_LONG_LONG
661 template<typename _CharT, typename _InIter>
663 num_get<_CharT, _InIter>::
664 do_get(iter_type __beg, iter_type __end, ios_base& __io,
665 ios_base::iostate& __err, long long& __v) const
666 { return _M_extract_int(__beg, __end, __io, __err, __v); }
668 template<typename _CharT, typename _InIter>
670 num_get<_CharT, _InIter>::
671 do_get(iter_type __beg, iter_type __end, ios_base& __io,
672 ios_base::iostate& __err, unsigned long long& __v) const
673 { return _M_extract_int(__beg, __end, __io, __err, __v); }
676 template<typename _CharT, typename _InIter>
678 num_get<_CharT, _InIter>::
679 do_get(iter_type __beg, iter_type __end, ios_base& __io,
680 ios_base::iostate& __err, float& __v) const
684 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
685 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
689 template<typename _CharT, typename _InIter>
691 num_get<_CharT, _InIter>::
692 do_get(iter_type __beg, iter_type __end, ios_base& __io,
693 ios_base::iostate& __err, double& __v) const
697 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
698 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
702 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
703 template<typename _CharT, typename _InIter>
705 num_get<_CharT, _InIter>::
706 __do_get(iter_type __beg, iter_type __end, ios_base& __io,
707 ios_base::iostate& __err, double& __v) const
711 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
712 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
717 template<typename _CharT, typename _InIter>
719 num_get<_CharT, _InIter>::
720 do_get(iter_type __beg, iter_type __end, ios_base& __io,
721 ios_base::iostate& __err, long double& __v) const
725 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
726 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
730 template<typename _CharT, typename _InIter>
732 num_get<_CharT, _InIter>::
733 do_get(iter_type __beg, iter_type __end, ios_base& __io,
734 ios_base::iostate& __err, void*& __v) const
736 // Prepare for hex formatted input.
737 typedef ios_base::fmtflags fmtflags;
738 const fmtflags __fmt = __io.flags();
739 __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
741 typedef __gnu_cxx::__conditional_type<(sizeof(void*)
742 <= sizeof(unsigned long)),
743 unsigned long, unsigned long long>::__type _UIntPtrType;
746 __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
748 // Reset from hex formatted input.
751 if (!(__err & ios_base::failbit))
752 __v = reinterpret_cast<void*>(__ul);
756 // For use by integer and floating-point types after they have been
757 // converted into a char_type string.
758 template<typename _CharT, typename _OutIter>
760 num_put<_CharT, _OutIter>::
761 _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
762 _CharT* __new, const _CharT* __cs, int& __len) const
764 // [22.2.2.2.2] Stage 3.
765 // If necessary, pad.
766 __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
768 __len = static_cast<int>(__w);
771 _GLIBCXX_END_LDBL_NAMESPACE
773 template<typename _CharT, typename _ValueT>
775 __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
776 ios_base::fmtflags __flags, bool __dec)
778 _CharT* __buf = __bufend;
779 if (__builtin_expect(__dec, true))
784 *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
789 else if ((__flags & ios_base::basefield) == ios_base::oct)
794 *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
802 const bool __uppercase = __flags & ios_base::uppercase;
803 const int __case_offset = __uppercase ? __num_base::_S_oudigits
804 : __num_base::_S_odigits;
807 *--__buf = __lit[(__v & 0xf) + __case_offset];
812 return __bufend - __buf;
815 _GLIBCXX_BEGIN_LDBL_NAMESPACE
817 template<typename _CharT, typename _OutIter>
819 num_put<_CharT, _OutIter>::
820 _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
821 ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
823 _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
824 __grouping_size, __cs, __cs + __len);
828 template<typename _CharT, typename _OutIter>
829 template<typename _ValueT>
831 num_put<_CharT, _OutIter>::
832 _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
835 using __gnu_cxx::__add_unsigned;
836 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
837 typedef __numpunct_cache<_CharT> __cache_type;
838 __use_cache<__cache_type> __uc;
839 const locale& __loc = __io._M_getloc();
840 const __cache_type* __lc = __uc(__loc);
841 const _CharT* __lit = __lc->_M_atoms_out;
842 const ios_base::fmtflags __flags = __io.flags();
844 // Long enough to hold hex, dec, and octal representations.
845 const int __ilen = 5 * sizeof(_ValueT);
846 _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
849 // [22.2.2.2.2] Stage 1, numeric conversion to character.
850 // Result is returned right-justified in the buffer.
851 const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
852 const bool __dec = (__basefield != ios_base::oct
853 && __basefield != ios_base::hex);
854 const __unsigned_type __u = ((__v > 0 || !__dec)
855 ? __unsigned_type(__v)
856 : -__unsigned_type(__v));
857 int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
858 __cs += __ilen - __len;
860 // Add grouping, if necessary.
861 if (__lc->_M_use_grouping)
863 // Grouping can add (almost) as many separators as the number
864 // of digits + space is reserved for numeric base or sign.
865 _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 + 2, __cs, __len);
873 // Complete Stage 1, prepend numeric base or sign.
874 if (__builtin_expect(__dec, true))
879 if (bool(__flags & ios_base::showpos)
880 && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
881 *--__cs = __lit[__num_base::_S_oplus], ++__len;
884 *--__cs = __lit[__num_base::_S_ominus], ++__len;
886 else if (bool(__flags & ios_base::showbase) && __v)
888 if (__basefield == ios_base::oct)
889 *--__cs = __lit[__num_base::_S_odigits], ++__len;
893 const bool __uppercase = __flags & ios_base::uppercase;
894 *--__cs = __lit[__num_base::_S_ox + __uppercase];
896 *--__cs = __lit[__num_base::_S_odigits];
902 const streamsize __w = __io.width();
903 if (__w > static_cast<streamsize>(__len))
905 _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
907 _M_pad(__fill, __w, __io, __cs3, __cs, __len);
912 // [22.2.2.2.2] Stage 4.
913 // Write resulting, fully-formatted string to output iterator.
914 return std::__write(__s, __cs, __len);
917 template<typename _CharT, typename _OutIter>
919 num_put<_CharT, _OutIter>::
920 _M_group_float(const char* __grouping, size_t __grouping_size,
921 _CharT __sep, const _CharT* __p, _CharT* __new,
922 _CharT* __cs, int& __len) const
924 // _GLIBCXX_RESOLVE_LIB_DEFECTS
925 // 282. What types does numpunct grouping refer to?
926 // Add grouping, if necessary.
927 const int __declen = __p ? __p - __cs : __len;
928 _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
930 __cs, __cs + __declen);
932 // Tack on decimal part.
933 int __newlen = __p2 - __new;
936 char_traits<_CharT>::copy(__p2, __p, __len - __declen);
937 __newlen += __len - __declen;
942 // The following code uses vsnprintf (or vsprintf(), when
943 // _GLIBCXX_USE_C99 is not defined) to convert floating point values
944 // for insertion into a stream. An optimization would be to replace
945 // them with code that works directly on a wide buffer and then use
946 // __pad to do the padding. It would be good to replace them anyway
947 // to gain back the efficiency that C++ provides by knowing up front
948 // the type of the values to insert. Also, sprintf is dangerous
949 // since may lead to accidental buffer overruns. This
950 // implementation follows the C++ standard fairly directly as
951 // outlined in 22.2.2.2 [lib.locale.num.put]
952 template<typename _CharT, typename _OutIter>
953 template<typename _ValueT>
955 num_put<_CharT, _OutIter>::
956 _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
959 typedef __numpunct_cache<_CharT> __cache_type;
960 __use_cache<__cache_type> __uc;
961 const locale& __loc = __io._M_getloc();
962 const __cache_type* __lc = __uc(__loc);
964 // Use default precision if out of range.
965 const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
967 const int __max_digits =
968 __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
970 // [22.2.2.2.2] Stage 1, numeric conversion to character.
972 // Long enough for the max format spec.
974 __num_base::_S_format_float(__io, __fbuf, __mod);
976 #ifdef _GLIBCXX_USE_C99
977 // First try a buffer perhaps big enough (most probably sufficient
978 // for non-ios_base::fixed outputs)
979 int __cs_size = __max_digits * 3;
980 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
981 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
982 __fbuf, __prec, __v);
984 // If the buffer was not large enough, try again with the correct size.
985 if (__len >= __cs_size)
987 __cs_size = __len + 1;
988 __cs = static_cast<char*>(__builtin_alloca(__cs_size));
989 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
990 __fbuf, __prec, __v);
993 // Consider the possibility of long ios_base::fixed outputs
994 const bool __fixed = __io.flags() & ios_base::fixed;
995 const int __max_exp =
996 __gnu_cxx::__numeric_traits<_ValueT>::__max_exponent10;
998 // The size of the output string is computed as follows.
999 // ios_base::fixed outputs may need up to __max_exp + 1 chars
1000 // for the integer part + __prec chars for the fractional part
1001 // + 3 chars for sign, decimal point, '\0'. On the other hand,
1002 // for non-fixed outputs __max_digits * 2 + __prec chars are
1003 // largely sufficient.
1004 const int __cs_size = __fixed ? __max_exp + __prec + 4
1005 : __max_digits * 2 + __prec;
1006 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
1007 __len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, __fbuf,
1011 // [22.2.2.2.2] Stage 2, convert to char_type, using correct
1012 // numpunct.decimal_point() values for '.' and adding grouping.
1013 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1015 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1017 __ctype.widen(__cs, __cs + __len, __ws);
1019 // Replace decimal point.
1021 const char* __p = char_traits<char>::find(__cs, __len, '.');
1024 __wp = __ws + (__p - __cs);
1025 *__wp = __lc->_M_decimal_point;
1028 // Add grouping, if necessary.
1029 // N.B. Make sure to not group things like 2e20, i.e., no decimal
1030 // point, scientific notation.
1031 if (__lc->_M_use_grouping
1032 && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
1033 && __cs[1] >= '0' && __cs[2] >= '0')))
1035 // Grouping can add (almost) as many separators as the
1036 // number of digits, but no more.
1037 _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1040 streamsize __off = 0;
1041 if (__cs[0] == '-' || __cs[0] == '+')
1048 _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
1049 __lc->_M_thousands_sep, __wp, __ws2 + __off,
1050 __ws + __off, __len);
1057 const streamsize __w = __io.width();
1058 if (__w > static_cast<streamsize>(__len))
1060 _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1062 _M_pad(__fill, __w, __io, __ws3, __ws, __len);
1067 // [22.2.2.2.2] Stage 4.
1068 // Write resulting, fully-formatted string to output iterator.
1069 return std::__write(__s, __ws, __len);
1072 template<typename _CharT, typename _OutIter>
1074 num_put<_CharT, _OutIter>::
1075 do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
1077 const ios_base::fmtflags __flags = __io.flags();
1078 if ((__flags & ios_base::boolalpha) == 0)
1080 const long __l = __v;
1081 __s = _M_insert_int(__s, __io, __fill, __l);
1085 typedef __numpunct_cache<_CharT> __cache_type;
1086 __use_cache<__cache_type> __uc;
1087 const locale& __loc = __io._M_getloc();
1088 const __cache_type* __lc = __uc(__loc);
1090 const _CharT* __name = __v ? __lc->_M_truename
1091 : __lc->_M_falsename;
1092 int __len = __v ? __lc->_M_truename_size
1093 : __lc->_M_falsename_size;
1095 const streamsize __w = __io.width();
1096 if (__w > static_cast<streamsize>(__len))
1099 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
1101 _M_pad(__fill, __w, __io, __cs, __name, __len);
1105 __s = std::__write(__s, __name, __len);
1110 template<typename _CharT, typename _OutIter>
1112 num_put<_CharT, _OutIter>::
1113 do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
1114 { return _M_insert_int(__s, __io, __fill, __v); }
1116 template<typename _CharT, typename _OutIter>
1118 num_put<_CharT, _OutIter>::
1119 do_put(iter_type __s, ios_base& __io, char_type __fill,
1120 unsigned long __v) const
1121 { return _M_insert_int(__s, __io, __fill, __v); }
1123 #ifdef _GLIBCXX_USE_LONG_LONG
1124 template<typename _CharT, typename _OutIter>
1126 num_put<_CharT, _OutIter>::
1127 do_put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
1128 { return _M_insert_int(__s, __io, __fill, __v); }
1130 template<typename _CharT, typename _OutIter>
1132 num_put<_CharT, _OutIter>::
1133 do_put(iter_type __s, ios_base& __io, char_type __fill,
1134 unsigned long long __v) const
1135 { return _M_insert_int(__s, __io, __fill, __v); }
1138 template<typename _CharT, typename _OutIter>
1140 num_put<_CharT, _OutIter>::
1141 do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
1142 { return _M_insert_float(__s, __io, __fill, char(), __v); }
1144 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
1145 template<typename _CharT, typename _OutIter>
1147 num_put<_CharT, _OutIter>::
1148 __do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
1149 { return _M_insert_float(__s, __io, __fill, char(), __v); }
1152 template<typename _CharT, typename _OutIter>
1154 num_put<_CharT, _OutIter>::
1155 do_put(iter_type __s, ios_base& __io, char_type __fill,
1156 long double __v) const
1157 { return _M_insert_float(__s, __io, __fill, 'L', __v); }
1159 template<typename _CharT, typename _OutIter>
1161 num_put<_CharT, _OutIter>::
1162 do_put(iter_type __s, ios_base& __io, char_type __fill,
1163 const void* __v) const
1165 const ios_base::fmtflags __flags = __io.flags();
1166 const ios_base::fmtflags __fmt = ~(ios_base::basefield
1167 | ios_base::uppercase
1168 | ios_base::internal);
1169 __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
1171 typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
1172 <= sizeof(unsigned long)),
1173 unsigned long, unsigned long long>::__type _UIntPtrType;
1175 __s = _M_insert_int(__s, __io, __fill,
1176 reinterpret_cast<_UIntPtrType>(__v));
1177 __io.flags(__flags);
1181 _GLIBCXX_END_LDBL_NAMESPACE
1183 // Construct correctly padded string, as per 22.2.2.2.2
1185 // __newlen > __oldlen
1186 // __news is allocated for __newlen size
1188 // NB: Of the two parameters, _CharT can be deduced from the
1189 // function arguments. The other (_Traits) has to be explicitly specified.
1190 template<typename _CharT, typename _Traits>
1192 __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
1193 _CharT* __news, const _CharT* __olds,
1194 const streamsize __newlen,
1195 const streamsize __oldlen)
1197 const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
1198 const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
1201 if (__adjust == ios_base::left)
1203 _Traits::copy(__news, __olds, __oldlen);
1204 _Traits::assign(__news + __oldlen, __plen, __fill);
1209 if (__adjust == ios_base::internal)
1211 // Pad after the sign, if there is one.
1212 // Pad after 0[xX], if there is one.
1213 // Who came up with these rules, anyway? Jeeze.
1214 const locale& __loc = __io._M_getloc();
1215 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1217 if (__ctype.widen('-') == __olds[0]
1218 || __ctype.widen('+') == __olds[0])
1220 __news[0] = __olds[0];
1224 else if (__ctype.widen('0') == __olds[0]
1226 && (__ctype.widen('x') == __olds[1]
1227 || __ctype.widen('X') == __olds[1]))
1229 __news[0] = __olds[0];
1230 __news[1] = __olds[1];
1234 // else Padding first.
1236 _Traits::assign(__news, __plen, __fill);
1237 _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
1240 template<typename _CharT>
1242 __add_grouping(_CharT* __s, _CharT __sep,
1243 const char* __gbeg, size_t __gsize,
1244 const _CharT* __first, const _CharT* __last)
1249 while (__last - __first > __gbeg[__idx]
1250 && static_cast<signed char>(__gbeg[__idx]) > 0)
1252 __last -= __gbeg[__idx];
1253 __idx < __gsize - 1 ? ++__idx : ++__ctr;
1256 while (__first != __last)
1257 *__s++ = *__first++;
1262 for (char __i = __gbeg[__idx]; __i > 0; --__i)
1263 *__s++ = *__first++;
1269 for (char __i = __gbeg[__idx]; __i > 0; --__i)
1270 *__s++ = *__first++;
1276 // Inhibit implicit instantiations for required instantiations,
1277 // which are defined via explicit instantiations elsewhere.
1278 // NB: This syntax is a GNU extension.
1279 #if _GLIBCXX_EXTERN_TEMPLATE
1280 extern template class numpunct<char>;
1281 extern template class numpunct_byname<char>;
1282 extern template class _GLIBCXX_LDBL_NAMESPACE num_get<char>;
1283 extern template class _GLIBCXX_LDBL_NAMESPACE num_put<char>;
1284 extern template class ctype_byname<char>;
1288 use_facet<ctype<char> >(const locale&);
1291 const numpunct<char>&
1292 use_facet<numpunct<char> >(const locale&);
1295 const num_put<char>&
1296 use_facet<num_put<char> >(const locale&);
1299 const num_get<char>&
1300 use_facet<num_get<char> >(const locale&);
1304 has_facet<ctype<char> >(const locale&);
1308 has_facet<numpunct<char> >(const locale&);
1312 has_facet<num_put<char> >(const locale&);
1316 has_facet<num_get<char> >(const locale&);
1318 #ifdef _GLIBCXX_USE_WCHAR_T
1319 extern template class numpunct<wchar_t>;
1320 extern template class numpunct_byname<wchar_t>;
1321 extern template class _GLIBCXX_LDBL_NAMESPACE num_get<wchar_t>;
1322 extern template class _GLIBCXX_LDBL_NAMESPACE num_put<wchar_t>;
1323 extern template class ctype_byname<wchar_t>;
1326 const ctype<wchar_t>&
1327 use_facet<ctype<wchar_t> >(const locale&);
1330 const numpunct<wchar_t>&
1331 use_facet<numpunct<wchar_t> >(const locale&);
1334 const num_put<wchar_t>&
1335 use_facet<num_put<wchar_t> >(const locale&);
1338 const num_get<wchar_t>&
1339 use_facet<num_get<wchar_t> >(const locale&);
1343 has_facet<ctype<wchar_t> >(const locale&);
1347 has_facet<numpunct<wchar_t> >(const locale&);
1351 has_facet<num_put<wchar_t> >(const locale&);
1355 has_facet<num_get<wchar_t> >(const locale&);
1359 _GLIBCXX_END_NAMESPACE