00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033 #ifndef _CPP_BITS_LOCFACETS_TCC
00034 #define _CPP_BITS_LOCFACETS_TCC 1
00035
00036 #pragma GCC system_header
00037
00038 #include <cerrno>
00039 #include <clocale>
00040 #include <cstdlib>
00041 #include <cmath>
00042 #include <cctype>
00043 #include <limits>
00044 #include <typeinfo>
00045 #include <bits/streambuf_iterator.h>
00046
00047 namespace std
00048 {
00049 template<typename _Facet>
00050 locale
00051 locale::combine(const locale& __other) const
00052 {
00053 _Impl* __tmp = new _Impl(*_M_impl, 1);
00054 try
00055 {
00056 __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
00057 }
00058 catch(...)
00059 {
00060 __tmp->_M_remove_reference();
00061 __throw_exception_again;
00062 }
00063 return locale(__tmp);
00064 }
00065
00066 template<typename _CharT, typename _Traits, typename _Alloc>
00067 bool
00068 locale::operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
00069 const basic_string<_CharT, _Traits, _Alloc>& __s2) const
00070 {
00071 typedef std::collate<_CharT> __collate_type;
00072 const __collate_type& __collate = use_facet<__collate_type>(*this);
00073 return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
00074 __s2.data(), __s2.data() + __s2.length()) < 0);
00075 }
00076
00077 template<typename _Facet>
00078 const _Facet&
00079 use_facet(const locale& __loc)
00080 {
00081 size_t __i = _Facet::id._M_id();
00082 locale::facet** __facets = __loc._M_impl->_M_facets;
00083 if (!(__i < __loc._M_impl->_M_facets_size && __facets[__i]))
00084 __throw_bad_cast();
00085 return static_cast<const _Facet&>(*__facets[__i]);
00086 }
00087
00088 template<typename _Facet>
00089 bool
00090 has_facet(const locale& __loc) throw()
00091 {
00092 size_t __i = _Facet::id._M_id();
00093 locale::facet** __facets = __loc._M_impl->_M_facets;
00094 return (__i < __loc._M_impl->_M_facets_size && __facets[__i]);
00095 }
00096
00097
00098
00099 template<typename _Facet>
00100 inline const __locale_cache<_Facet>&
00101 __use_cache(const locale& __loc)
00102 {
00103 size_t __i = _Facet::id._M_id();
00104 if (__builtin_expect(__i >= __loc._M_impl->_M_facets_size,false))
00105 __throw_bad_cast();
00106 __locale_cache_base* __cache = __loc._M_impl->_M_get_cache(__i);
00107 if (__builtin_expect(!__cache, false))
00108 {
00109 __cache = new __locale_cache<_Facet>(__loc);
00110 __loc._M_impl->_M_install_cache(__cache, __i);
00111 }
00112 return static_cast<const __locale_cache<_Facet>&>(*__cache);
00113 }
00114
00115
00116 template<typename _CharT, typename _InIter>
00117 _InIter
00118 num_get<_CharT, _InIter>::
00119 _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
00120 ios_base::iostate& __err, string& __xtrc) const
00121 {
00122 typedef char_traits<_CharT> __traits_type;
00123 const locale __loc = __io.getloc();
00124 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00125 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
00126
00127
00128 const char_type __plus = __ctype.widen('+');
00129 const char_type __minus = __ctype.widen('-');
00130 int __pos = 0;
00131 char_type __c = *__beg;
00132 if ((__traits_type::eq(__c, __plus) || __traits_type::eq(__c, __minus))
00133 && __beg != __end)
00134 {
00135 __xtrc += __ctype.narrow(__c, char());
00136 ++__pos;
00137 __c = *(++__beg);
00138 }
00139
00140
00141 const char_type __zero = __ctype.widen(_S_atoms_in[_M_zero]);
00142 bool __found_zero = false;
00143 while (__traits_type::eq(__c, __zero) && __beg != __end)
00144 {
00145 __c = *(++__beg);
00146 __found_zero = true;
00147 }
00148 if (__found_zero)
00149 {
00150 __xtrc += _S_atoms_in[_M_zero];
00151 ++__pos;
00152 }
00153
00154
00155 const size_t __len = _M_E - _M_zero + 1;
00156 char_type __watoms[__len];
00157 __ctype.widen(_S_atoms_in, _S_atoms_in + __len, __watoms);
00158 bool __found_dec = false;
00159 bool __found_sci = false;
00160 const char_type __dec = __np.decimal_point();
00161
00162 string __found_grouping;
00163 const string __grouping = __np.grouping();
00164 bool __check_grouping = __grouping.size();
00165 int __sep_pos = 0;
00166 const char_type __sep = __np.thousands_sep();
00167
00168 while (__beg != __end)
00169 {
00170
00171 const char_type* __p = __traits_type::find(__watoms, 10, __c);
00172
00173
00174 if (__p && !__traits_type::eq(__c, char_type()))
00175 {
00176
00177 ++__pos;
00178 __xtrc += _S_atoms_in[__p - __watoms];
00179 ++__sep_pos;
00180 __c = *(++__beg);
00181 }
00182 else if (__traits_type::eq(__c, __sep)
00183 && __check_grouping && !__found_dec)
00184 {
00185
00186
00187 if (__sep_pos)
00188 {
00189 __found_grouping += static_cast<char>(__sep_pos);
00190 __sep_pos = 0;
00191 __c = *(++__beg);
00192 }
00193 else
00194 {
00195 __err |= ios_base::failbit;
00196 break;
00197 }
00198 }
00199 else if (__traits_type::eq(__c, __dec) && !__found_dec)
00200 {
00201
00202
00203
00204 if (__found_grouping.size())
00205 __found_grouping += static_cast<char>(__sep_pos);
00206 ++__pos;
00207 __xtrc += '.';
00208 __c = *(++__beg);
00209 __found_dec = true;
00210 }
00211 else if ((__traits_type::eq(__c, __watoms[_M_e])
00212 || __traits_type::eq(__c, __watoms[_M_E]))
00213 && !__found_sci && __pos)
00214 {
00215
00216 ++__pos;
00217 __xtrc += __ctype.narrow(__c, char());
00218 __c = *(++__beg);
00219
00220
00221 if (__traits_type::eq(__c, __plus)
00222 || __traits_type::eq(__c, __minus))
00223 {
00224 ++__pos;
00225 __xtrc += __ctype.narrow(__c, char());
00226 __c = *(++__beg);
00227 }
00228 __found_sci = true;
00229 }
00230 else
00231
00232 break;
00233 }
00234
00235
00236
00237 if (__check_grouping && __found_grouping.size())
00238 {
00239
00240 if (!__found_dec)
00241 __found_grouping += static_cast<char>(__sep_pos);
00242 if (!__verify_grouping(__grouping, __found_grouping))
00243 __err |= ios_base::failbit;
00244 }
00245
00246
00247 __xtrc += char();
00248 if (__beg == __end)
00249 __err |= ios_base::eofbit;
00250 return __beg;
00251 }
00252
00253
00254 template<typename _CharT, typename _InIter>
00255 _InIter
00256 num_get<_CharT, _InIter>::
00257 _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
00258 ios_base::iostate& __err, string& __xtrc, int& __base) const
00259 {
00260 typedef char_traits<_CharT> __traits_type;
00261 const locale __loc = __io.getloc();
00262 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00263 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
00264
00265
00266 ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield;
00267 if (__basefield == ios_base::oct)
00268 __base = 8;
00269 else if (__basefield == ios_base::hex)
00270 __base = 16;
00271 else
00272 __base = 10;
00273
00274
00275 int __pos = 0;
00276 char_type __c = *__beg;
00277 const char_type __plus = __ctype.widen('+');
00278 const char_type __minus = __ctype.widen('-');
00279
00280 if ((__traits_type::eq(__c, __plus) || __traits_type::eq(__c, __minus))
00281 && __beg != __end)
00282 {
00283 __xtrc += __ctype.narrow(__c, char());
00284 ++__pos;
00285 __c = *(++__beg);
00286 }
00287
00288
00289 const char_type __zero = __ctype.widen(_S_atoms_in[_M_zero]);
00290 const char_type __x = __ctype.widen('x');
00291 const char_type __X = __ctype.widen('X');
00292 if (__base == 10)
00293 {
00294 bool __found_zero = false;
00295 while (__traits_type::eq(__c, __zero) && __beg != __end)
00296 {
00297 __c = *(++__beg);
00298 __found_zero = true;
00299 }
00300 if (__found_zero)
00301 {
00302 __xtrc += _S_atoms_in[_M_zero];
00303 ++__pos;
00304 if (__basefield == 0)
00305 {
00306 if ((__traits_type::eq(__c, __x)
00307 || __traits_type::eq(__c, __X))
00308 && __beg != __end)
00309 {
00310 __xtrc += __ctype.narrow(__c, char());
00311 ++__pos;
00312 __c = *(++__beg);
00313 __base = 16;
00314 }
00315 else
00316 __base = 8;
00317 }
00318 }
00319 }
00320 else if (__base == 16)
00321 {
00322 if (__traits_type::eq(__c, __zero) && __beg != __end)
00323 {
00324 __xtrc += _S_atoms_in[_M_zero];
00325 ++__pos;
00326 __c = *(++__beg);
00327 if ((__traits_type::eq(__c, __x) || __traits_type::eq(__c, __X))
00328 && __beg != __end)
00329 {
00330 __xtrc += __ctype.narrow(__c, char());
00331 ++__pos;
00332 __c = *(++__beg);
00333 }
00334 }
00335 }
00336
00337
00338
00339 size_t __len;
00340 if (__base == 16)
00341 __len = _M_size;
00342 else
00343 __len = __base;
00344
00345
00346 char_type __watoms[_M_size];
00347 __ctype.widen(_S_atoms_in, _S_atoms_in + __len, __watoms);
00348 string __found_grouping;
00349 const string __grouping = __np.grouping();
00350 bool __check_grouping = __grouping.size();
00351 int __sep_pos = 0;
00352 const char_type __sep = __np.thousands_sep();
00353 while (__beg != __end)
00354 {
00355 const char_type* __p = __traits_type::find(__watoms, __len, __c);
00356
00357
00358 if (__p && !__traits_type::eq(__c, char_type()))
00359 {
00360
00361 __xtrc += _S_atoms_in[__p - __watoms];
00362 ++__pos;
00363 ++__sep_pos;
00364 __c = *(++__beg);
00365 }
00366 else if (__traits_type::eq(__c, __sep) && __check_grouping)
00367 {
00368
00369
00370 if (__sep_pos)
00371 {
00372 __found_grouping += static_cast<char>(__sep_pos);
00373 __sep_pos = 0;
00374 __c = *(++__beg);
00375 }
00376 else
00377 {
00378 __err |= ios_base::failbit;
00379 break;
00380 }
00381 }
00382 else
00383
00384 break;
00385 }
00386
00387
00388
00389 if (__check_grouping && __found_grouping.size())
00390 {
00391
00392 __found_grouping += static_cast<char>(__sep_pos);
00393 if (!__verify_grouping(__grouping, __found_grouping))
00394 __err |= ios_base::failbit;
00395 }
00396
00397
00398 __xtrc += char();
00399 if (__beg == __end)
00400 __err |= ios_base::eofbit;
00401 return __beg;
00402 }
00403
00404 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00405
00406 template<typename _CharT, typename _InIter>
00407 _InIter
00408 num_get<_CharT, _InIter>::
00409 do_get(iter_type __beg, iter_type __end, ios_base& __io,
00410 ios_base::iostate& __err, bool& __v) const
00411 {
00412
00413 if (!(__io.flags() & ios_base::boolalpha))
00414 {
00415
00416
00417 string __xtrc;
00418 int __base;
00419 __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00420
00421 unsigned long __ul;
00422 __convert_to_v(__xtrc.c_str(), __ul, __err, _S_c_locale, __base);
00423 if (!(__err & ios_base::failbit) && __ul <= 1)
00424 __v = __ul;
00425 else
00426 __err |= ios_base::failbit;
00427 }
00428
00429
00430 else
00431 {
00432 typedef char_traits<_CharT> __traits_type;
00433 typedef basic_string<_CharT> __string_type;
00434
00435 locale __loc = __io.getloc();
00436 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
00437 const __string_type __true = __np.truename();
00438 const __string_type __false = __np.falsename();
00439 const char_type* __trues = __true.c_str();
00440 const char_type* __falses = __false.c_str();
00441 const size_t __truen = __true.size() - 1;
00442 const size_t __falsen = __false.size() - 1;
00443
00444 for (size_t __n = 0; __beg != __end; ++__n)
00445 {
00446 char_type __c = *__beg++;
00447 bool __testf = __n <= __falsen
00448 ? __traits_type::eq(__c, __falses[__n]) : false;
00449 bool __testt = __n <= __truen
00450 ? __traits_type::eq(__c, __trues[__n]) : false;
00451 if (!(__testf || __testt))
00452 {
00453 __err |= ios_base::failbit;
00454 break;
00455 }
00456 else if (__testf && __n == __falsen)
00457 {
00458 __v = 0;
00459 break;
00460 }
00461 else if (__testt && __n == __truen)
00462 {
00463 __v = 1;
00464 break;
00465 }
00466 }
00467 if (__beg == __end)
00468 __err |= ios_base::eofbit;
00469 }
00470 return __beg;
00471 }
00472 #endif
00473
00474 template<typename _CharT, typename _InIter>
00475 _InIter
00476 num_get<_CharT, _InIter>::
00477 do_get(iter_type __beg, iter_type __end, ios_base& __io,
00478 ios_base::iostate& __err, long& __v) const
00479 {
00480 string __xtrc;
00481 int __base;
00482 __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00483 __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale, __base);
00484 return __beg;
00485 }
00486
00487 template<typename _CharT, typename _InIter>
00488 _InIter
00489 num_get<_CharT, _InIter>::
00490 do_get(iter_type __beg, iter_type __end, ios_base& __io,
00491 ios_base::iostate& __err, unsigned short& __v) const
00492 {
00493 string __xtrc;
00494 int __base;
00495 __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00496 unsigned long __ul;
00497 __convert_to_v(__xtrc.c_str(), __ul, __err, _S_c_locale, __base);
00498 if (!(__err & ios_base::failbit)
00499 && __ul <= numeric_limits<unsigned short>::max())
00500 __v = static_cast<unsigned short>(__ul);
00501 else
00502 __err |= ios_base::failbit;
00503 return __beg;
00504 }
00505
00506 template<typename _CharT, typename _InIter>
00507 _InIter
00508 num_get<_CharT, _InIter>::
00509 do_get(iter_type __beg, iter_type __end, ios_base& __io,
00510 ios_base::iostate& __err, unsigned int& __v) const
00511 {
00512 string __xtrc;
00513 int __base;
00514 __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00515 unsigned long __ul;
00516 __convert_to_v(__xtrc.c_str(), __ul, __err, _S_c_locale, __base);
00517 if (!(__err & ios_base::failbit)
00518 && __ul <= numeric_limits<unsigned int>::max())
00519 __v = static_cast<unsigned int>(__ul);
00520 else
00521 __err |= ios_base::failbit;
00522 return __beg;
00523 }
00524
00525 template<typename _CharT, typename _InIter>
00526 _InIter
00527 num_get<_CharT, _InIter>::
00528 do_get(iter_type __beg, iter_type __end, ios_base& __io,
00529 ios_base::iostate& __err, unsigned long& __v) const
00530 {
00531 string __xtrc;
00532 int __base;
00533 __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00534 __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale, __base);
00535 return __beg;
00536 }
00537
00538 #ifdef _GLIBCPP_USE_LONG_LONG
00539 template<typename _CharT, typename _InIter>
00540 _InIter
00541 num_get<_CharT, _InIter>::
00542 do_get(iter_type __beg, iter_type __end, ios_base& __io,
00543 ios_base::iostate& __err, long long& __v) const
00544 {
00545 string __xtrc;
00546 int __base;
00547 __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00548 __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale, __base);
00549 return __beg;
00550 }
00551
00552 template<typename _CharT, typename _InIter>
00553 _InIter
00554 num_get<_CharT, _InIter>::
00555 do_get(iter_type __beg, iter_type __end, ios_base& __io,
00556 ios_base::iostate& __err, unsigned long long& __v) const
00557 {
00558 string __xtrc;
00559 int __base;
00560 __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00561 __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale, __base);
00562 return __beg;
00563 }
00564 #endif
00565
00566 template<typename _CharT, typename _InIter>
00567 _InIter
00568 num_get<_CharT, _InIter>::
00569 do_get(iter_type __beg, iter_type __end, ios_base& __io,
00570 ios_base::iostate& __err, float& __v) const
00571 {
00572 string __xtrc;
00573 __xtrc.reserve(32);
00574 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
00575 __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale);
00576 return __beg;
00577 }
00578
00579 template<typename _CharT, typename _InIter>
00580 _InIter
00581 num_get<_CharT, _InIter>::
00582 do_get(iter_type __beg, iter_type __end, ios_base& __io,
00583 ios_base::iostate& __err, double& __v) const
00584 {
00585 string __xtrc;
00586 __xtrc.reserve(32);
00587 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
00588 __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale);
00589 return __beg;
00590 }
00591
00592 template<typename _CharT, typename _InIter>
00593 _InIter
00594 num_get<_CharT, _InIter>::
00595 do_get(iter_type __beg, iter_type __end, ios_base& __io,
00596 ios_base::iostate& __err, long double& __v) const
00597 {
00598 string __xtrc;
00599 __xtrc.reserve(32);
00600 __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
00601 __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale);
00602 return __beg;
00603 }
00604
00605 template<typename _CharT, typename _InIter>
00606 _InIter
00607 num_get<_CharT, _InIter>::
00608 do_get(iter_type __beg, iter_type __end, ios_base& __io,
00609 ios_base::iostate& __err, void*& __v) const
00610 {
00611
00612 typedef ios_base::fmtflags fmtflags;
00613 fmtflags __fmt = __io.flags();
00614 fmtflags __fmtmask = ~(ios_base::showpos | ios_base::basefield
00615 | ios_base::uppercase | ios_base::internal);
00616 __io.flags(__fmt & __fmtmask | (ios_base::hex | ios_base::showbase));
00617
00618 string __xtrc;
00619 int __base;
00620 __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00621
00622
00623 __io.flags(__fmt);
00624
00625 unsigned long __ul;
00626 __convert_to_v(__xtrc.c_str(), __ul, __err, _S_c_locale, __base);
00627 if (!(__err & ios_base::failbit))
00628 __v = reinterpret_cast<void*>(__ul);
00629 else
00630 __err |= ios_base::failbit;
00631 return __beg;
00632 }
00633
00634
00635
00636 template<typename _CharT, typename _OutIter>
00637 void
00638 num_put<_CharT, _OutIter>::
00639 _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
00640 _CharT* __new, const _CharT* __cs, int& __len) const
00641 {
00642
00643
00644 __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, __cs,
00645 __w, __len, true);
00646 __len = static_cast<int>(__w);
00647 }
00648
00649
00650 template<typename _CharT>
00651 inline int
00652 __int_to_char(_CharT* __out, const int __size, long __v,
00653 const _CharT* __lit, ios_base::fmtflags __flags)
00654 {
00655 unsigned long __ul = static_cast<unsigned long>(__v);
00656 bool __neg = false;
00657 if (__v < 0)
00658 {
00659 __ul = -__ul;
00660 __neg = true;
00661 }
00662 return __int_to_char(__out, __size, __ul, __lit, __flags, __neg);
00663 }
00664
00665 template<typename _CharT>
00666 inline int
00667 __int_to_char(_CharT* __out, const int __size, unsigned long __v,
00668 const _CharT* __lit, ios_base::fmtflags __flags)
00669 { return __int_to_char(__out, __size, __v, __lit, __flags, false); }
00670
00671 #ifdef _GLIBCPP_USE_LONG_LONG
00672 template<typename _CharT>
00673 inline int
00674 __int_to_char(_CharT* __out, const int __size, long long __v,
00675 const _CharT* __lit, ios_base::fmtflags __flags)
00676 {
00677 unsigned long long __ull = static_cast<unsigned long long>(__v);
00678 bool __neg = false;
00679 if (__v < 0)
00680 {
00681 __ull = -__ull;
00682 __neg = true;
00683 }
00684 return __int_to_char(__out, __size, __ull, __lit, __flags, __neg);
00685 }
00686
00687 template<typename _CharT>
00688 inline int
00689 __int_to_char(_CharT* __out, const int __size, unsigned long long __v,
00690 const _CharT* __lit, ios_base::fmtflags __flags)
00691 { return __int_to_char(__out, __size, __v, __lit, __flags, false); }
00692 #endif
00693
00694 template<typename _CharT, typename _ValueT>
00695 int
00696 __int_to_char(_CharT* __out, const int __size, _ValueT __v,
00697 const _CharT* __lit, ios_base::fmtflags __flags, bool __neg)
00698 {
00699
00700 const bool __showbase = (__flags & ios_base::showbase) && __v;
00701 const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
00702 _CharT* __buf = __out + __size - 1;
00703 _CharT* __bufend = __out + __size;
00704
00705 if (__builtin_expect(__basefield != ios_base::oct &&
00706 __basefield != ios_base::hex, true))
00707 {
00708
00709 do
00710 {
00711 *__buf-- = __lit[(__v % 10) + __num_base::_S_digits];
00712 __v /= 10;
00713 }
00714 while (__v != 0);
00715 if (__neg)
00716 *__buf-- = __lit[__num_base::_S_minus];
00717 else if (__flags & ios_base::showpos)
00718 *__buf-- = __lit[__num_base::_S_plus];
00719 }
00720 else if (__basefield == ios_base::oct)
00721 {
00722
00723 do
00724 {
00725 *__buf-- = __lit[(__v & 0x7) + __num_base::_S_digits];
00726 __v >>= 3;
00727 }
00728 while (__v != 0);
00729 if (__showbase)
00730 *__buf-- = __lit[__num_base::_S_digits];
00731 }
00732 else
00733 {
00734
00735 const bool __uppercase = __flags & ios_base::uppercase;
00736 int __case_offset = __uppercase
00737 ? __num_base::_S_udigits : __num_base::_S_digits;
00738 do
00739 {
00740 *__buf-- = __lit[(__v & 0xf) + __case_offset];
00741 __v >>= 4;
00742 }
00743 while (__v != 0);
00744 if (__showbase)
00745 {
00746
00747 *__buf-- = __lit[__num_base::_S_x + __uppercase];
00748
00749 *__buf-- = __lit[__num_base::_S_digits];
00750 }
00751 }
00752 int __ret = __bufend - __buf - 1;
00753 return __ret;
00754 }
00755
00756 template<typename _CharT, typename _OutIter>
00757 void
00758 num_put<_CharT, _OutIter>::
00759 _M_group_int(const string& __grouping, _CharT __sep, ios_base& __io,
00760 _CharT* __new, _CharT* __cs, int& __len) const
00761 {
00762
00763
00764
00765
00766
00767 streamsize __off = 0;
00768 const ios_base::fmtflags __basefield = __io.flags()
00769 & ios_base::basefield;
00770 if ((__io.flags() & ios_base::showbase) && __len > 1)
00771 if (__basefield == ios_base::oct)
00772 {
00773 __off = 1;
00774 *__new = *__cs;
00775 }
00776 else if (__basefield == ios_base::hex)
00777 {
00778 __off = 2;
00779 *__new = *__cs;
00780 *(__new + 1) = *(__cs + 1);
00781 }
00782 _CharT* __p;
00783 __p = __add_grouping(__new + __off, __sep,
00784 __grouping.c_str(),
00785 __grouping.c_str() + __grouping.size(),
00786 __cs + __off, __cs + __len);
00787 __len = __p - __new;
00788 }
00789
00790 template<typename _CharT, typename _OutIter>
00791 template<typename _ValueT>
00792 _OutIter
00793 num_put<_CharT, _OutIter>::
00794 _M_convert_int(_OutIter __s, ios_base& __io, _CharT __fill,
00795 _ValueT __v) const
00796 {
00797 typedef numpunct<_CharT> __facet_type;
00798 typedef __locale_cache<numpunct<_CharT> > __cache_type;
00799 const locale& __loc = __io._M_getloc();
00800 const __cache_type& __lc = __use_cache<__facet_type>(__loc);
00801 const _CharT* __lit = __lc._M_atoms_out;
00802
00803
00804 int __ilen = 4 * sizeof(_ValueT);
00805 _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
00806 * __ilen));
00807
00808
00809 int __len;
00810 __len = __int_to_char(&__cs[0], __ilen, __v, __lit, __io.flags());
00811 __cs = __cs + __ilen - __len;
00812
00813
00814 _CharT* __cs2;
00815 if (__lc._M_use_grouping)
00816 {
00817
00818
00819 __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
00820 * __len * 2));
00821 _M_group_int(__lc._M_grouping, __lc._M_thousands_sep, __io,
00822 __cs2, __cs, __len);
00823 __cs = __cs2;
00824 }
00825
00826
00827 _CharT* __cs3;
00828 streamsize __w = __io.width();
00829 if (__w > static_cast<streamsize>(__len))
00830 {
00831 __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
00832 * __w));
00833 _M_pad(__fill, __w, __io, __cs3, __cs, __len);
00834 __cs = __cs3;
00835 }
00836 __io.width(0);
00837
00838
00839
00840 return __write(__s, __cs, __len);
00841 }
00842
00843 template<typename _CharT, typename _OutIter>
00844 void
00845 num_put<_CharT, _OutIter>::
00846 _M_group_float(const string& __grouping, _CharT __sep, const _CharT* __p,
00847 _CharT* __new, _CharT* __cs, int& __len) const
00848 {
00849 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00850
00851
00852 _CharT* __p2;
00853 int __declen = __p ? __p - __cs : __len;
00854 __p2 = __add_grouping(__new, __sep,
00855 __grouping.c_str(),
00856 __grouping.c_str() + __grouping.size(),
00857 __cs, __cs + __declen);
00858
00859
00860 int __newlen = __p2 - __new;
00861 if (__p)
00862 {
00863 char_traits<_CharT>::copy(__p2, __p, __len - __declen);
00864 __newlen += __len - __declen;
00865 }
00866 __len = __newlen;
00867 #endif
00868 }
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880 template<typename _CharT, typename _OutIter>
00881 template<typename _ValueT>
00882 _OutIter
00883 num_put<_CharT, _OutIter>::
00884 _M_convert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
00885 _ValueT __v) const
00886 {
00887
00888 streamsize __prec = __io.precision();
00889 if (__prec < static_cast<streamsize>(0))
00890 __prec = static_cast<streamsize>(6);
00891
00892 const int __max_digits = numeric_limits<_ValueT>::digits10;
00893
00894 typedef numpunct<_CharT> __facet_type;
00895 typedef __locale_cache<numpunct<_CharT> > __cache_type;
00896 const locale __loc = __io._M_getloc();
00897 const __cache_type& __lc = __use_cache<__facet_type>(__loc);
00898
00899
00900 int __len;
00901
00902 char __fbuf[16];
00903
00904 #ifdef _GLIBCPP_USE_C99
00905
00906
00907 int __cs_size = __max_digits * 3;
00908 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
00909
00910 _S_format_float(__io, __fbuf, __mod, __prec);
00911 __len = __convert_from_v(__cs, __cs_size, __fbuf, __v,
00912 _S_c_locale, __prec);
00913
00914
00915 if (__len >= __cs_size)
00916 {
00917 __cs_size = __len + 1;
00918 __cs = static_cast<char*>(__builtin_alloca(__cs_size));
00919 __len = __convert_from_v(__cs, __cs_size, __fbuf, __v,
00920 _S_c_locale, __prec);
00921 }
00922 #else
00923
00924 const bool __fixed = __io.flags() & ios_base::fixed;
00925 const int __max_exp = numeric_limits<_ValueT>::max_exponent10;
00926
00927
00928
00929
00930
00931
00932 const int __cs_size = __fixed ? __max_exp + __prec + 4
00933 : __max_digits * 2 + __prec;
00934 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
00935
00936 _S_format_float(__io, __fbuf, __mod, __prec);
00937 __len = __convert_from_v(__cs, 0, __fbuf, __v, _S_c_locale, __prec);
00938 #endif
00939
00940
00941
00942 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00943
00944 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
00945 * __len));
00946 __ctype.widen(__cs, __cs + __len, __ws);
00947
00948
00949 const _CharT __cdec = __ctype.widen('.');
00950 const _CharT __dec = __lc._M_decimal_point;
00951 const _CharT* __p;
00952 if (__p = char_traits<_CharT>::find(__ws, __len, __cdec))
00953 __ws[__p - __ws] = __dec;
00954
00955
00956 _CharT* __ws2;
00957 if (__lc._M_use_grouping)
00958 {
00959
00960
00961 __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
00962 * __len * 2));
00963 _M_group_float(__lc._M_grouping, __lc._M_thousands_sep, __p,
00964 __ws2, __ws, __len);
00965 __ws = __ws2;
00966 }
00967
00968
00969 _CharT* __ws3;
00970 streamsize __w = __io.width();
00971 if (__w > static_cast<streamsize>(__len))
00972 {
00973 __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
00974 _M_pad(__fill, __w, __io, __ws3, __ws, __len);
00975 __ws = __ws3;
00976 }
00977 __io.width(0);
00978
00979
00980
00981 return __write(__s, __ws, __len);
00982 }
00983
00984 template<typename _CharT, typename _OutIter>
00985 _OutIter
00986 num_put<_CharT, _OutIter>::
00987 do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
00988 {
00989 ios_base::fmtflags __flags = __io.flags();
00990 if ((__flags & ios_base::boolalpha) == 0)
00991 {
00992 unsigned long __uv = __v;
00993 __s = _M_convert_int(__s, __io, __fill, __uv);
00994 }
00995 else
00996 {
00997 typedef numpunct<_CharT> __facet_type;
00998 typedef __locale_cache<numpunct<_CharT> > __cache_type;
00999 const locale __loc = __io._M_getloc();
01000 const __cache_type& __lc = __use_cache<__facet_type>(__loc);
01001
01002 typedef basic_string<_CharT> __string_type;
01003 __string_type __name;
01004 if (__v)
01005 __name = __lc._M_truename;
01006 else
01007 __name = __lc._M_falsename;
01008
01009 const _CharT* __cs = __name.c_str();
01010 int __len = __name.size();
01011 _CharT* __cs3;
01012 streamsize __w = __io.width();
01013 if (__w > static_cast<streamsize>(__len))
01014 {
01015 __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
01016 * __w));
01017 _M_pad(__fill, __w, __io, __cs3, __cs, __len);
01018 __cs = __cs3;
01019 }
01020 __io.width(0);
01021 __s = __write(__s, __cs, __len);
01022 }
01023 return __s;
01024 }
01025
01026 template<typename _CharT, typename _OutIter>
01027 _OutIter
01028 num_put<_CharT, _OutIter>::
01029 do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
01030 { return _M_convert_int(__s, __io, __fill, __v); }
01031
01032 template<typename _CharT, typename _OutIter>
01033 _OutIter
01034 num_put<_CharT, _OutIter>::
01035 do_put(iter_type __s, ios_base& __io, char_type __fill,
01036 unsigned long __v) const
01037 { return _M_convert_int(__s, __io, __fill, __v); }
01038
01039 #ifdef _GLIBCPP_USE_LONG_LONG
01040 template<typename _CharT, typename _OutIter>
01041 _OutIter
01042 num_put<_CharT, _OutIter>::
01043 do_put(iter_type __s, ios_base& __b, char_type __fill, long long __v) const
01044 { return _M_convert_int(__s, __b, __fill, __v); }
01045
01046 template<typename _CharT, typename _OutIter>
01047 _OutIter
01048 num_put<_CharT, _OutIter>::
01049 do_put(iter_type __s, ios_base& __io, char_type __fill,
01050 unsigned long long __v) const
01051 { return _M_convert_int(__s, __io, __fill, __v); }
01052 #endif
01053
01054 template<typename _CharT, typename _OutIter>
01055 _OutIter
01056 num_put<_CharT, _OutIter>::
01057 do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
01058 { return _M_convert_float(__s, __io, __fill, char(), __v); }
01059
01060 template<typename _CharT, typename _OutIter>
01061 _OutIter
01062 num_put<_CharT, _OutIter>::
01063 do_put(iter_type __s, ios_base& __io, char_type __fill,
01064 long double __v) const
01065 { return _M_convert_float(__s, __io, __fill, 'L', __v); }
01066
01067 template<typename _CharT, typename _OutIter>
01068 _OutIter
01069 num_put<_CharT, _OutIter>::
01070 do_put(iter_type __s, ios_base& __io, char_type __fill,
01071 const void* __v) const
01072 {
01073 ios_base::fmtflags __flags = __io.flags();
01074 ios_base::fmtflags __fmt = ~(ios_base::showpos | ios_base::basefield
01075 | ios_base::uppercase | ios_base::internal);
01076 __io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase));
01077 try
01078 {
01079 __s = _M_convert_int(__s, __io, __fill,
01080 reinterpret_cast<unsigned long>(__v));
01081 __io.flags(__flags);
01082 }
01083 catch (...)
01084 {
01085 __io.flags(__flags);
01086 __throw_exception_again;
01087 }
01088 return __s;
01089 }
01090
01091
01092 template<typename _CharT, typename _InIter>
01093 _InIter
01094 money_get<_CharT, _InIter>::
01095 do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
01096 ios_base::iostate& __err, long double& __units) const
01097 {
01098 string_type __str;
01099 __beg = this->do_get(__beg, __end, __intl, __io, __err, __str);
01100
01101 const int __cs_size = __str.size() + 1;
01102 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
01103 const locale __loc = __io.getloc();
01104 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
01105 const _CharT* __wcs = __str.c_str();
01106 __ctype.narrow(__wcs, __wcs + __cs_size, char(), __cs);
01107 __convert_to_v(__cs, __units, __err, _S_c_locale);
01108 return __beg;
01109 }
01110
01111 template<typename _CharT, typename _InIter>
01112 _InIter
01113 money_get<_CharT, _InIter>::
01114 do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
01115 ios_base::iostate& __err, string_type& __units) const
01116 {
01117
01118 typedef moneypunct<_CharT, true> __money_true;
01119 typedef moneypunct<_CharT, false> __money_false;
01120 typedef money_base::part part;
01121 typedef typename string_type::size_type size_type;
01122
01123 const locale __loc = __io.getloc();
01124 const __money_true& __mpt = use_facet<__money_true>(__loc);
01125 const __money_false& __mpf = use_facet<__money_false>(__loc);
01126 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
01127
01128 const money_base::pattern __p = __intl ? __mpt.neg_format()
01129 : __mpf.neg_format();
01130
01131 const string_type __pos_sign =__intl ? __mpt.positive_sign()
01132 : __mpf.positive_sign();
01133 const string_type __neg_sign =__intl ? __mpt.negative_sign()
01134 : __mpf.negative_sign();
01135 const char_type __d = __intl ? __mpt.decimal_point()
01136 : __mpf.decimal_point();
01137 const char_type __sep = __intl ? __mpt.thousands_sep()
01138 : __mpf.thousands_sep();
01139
01140 const string __grouping = __intl ? __mpt.grouping() : __mpf.grouping();
01141
01142
01143 string_type __sign;
01144
01145 string __grouping_tmp;
01146
01147 int __sep_pos = 0;
01148
01149 bool __testvalid = true;
01150
01151 bool __testdecfound = false;
01152
01153
01154 string_type __temp_units;
01155
01156 char_type __c = *__beg;
01157 char_type __eof = static_cast<char_type>(char_traits<char_type>::eof());
01158 for (int __i = 0; __beg != __end && __i < 4 && __testvalid; ++__i)
01159 {
01160 part __which = static_cast<part>(__p.field[__i]);
01161 switch (__which)
01162 {
01163 case money_base::symbol:
01164 if (__io.flags() & ios_base::showbase
01165 || __i < 2 || __sign.size() > 1
01166 || ((static_cast<part>(__p.field[3]) != money_base::none)
01167 && __i == 2))
01168 {
01169
01170
01171
01172
01173
01174 const string_type __symbol = __intl ? __mpt.curr_symbol()
01175 : __mpf.curr_symbol();
01176 size_type __len = __symbol.size();
01177 size_type __j = 0;
01178 while (__beg != __end
01179 && __j < __len && __symbol[__j] == __c)
01180 {
01181 __c = *(++__beg);
01182 ++__j;
01183 }
01184
01185
01186 if (__j != __len && (__io.flags() & ios_base::showbase))
01187 __testvalid = false;
01188 }
01189 break;
01190 case money_base::sign:
01191
01192 if (__pos_sign.size() && __neg_sign.size())
01193 {
01194
01195 if (__c == __pos_sign[0])
01196 {
01197 __sign = __pos_sign;
01198 __c = *(++__beg);
01199 }
01200 else if (__c == __neg_sign[0])
01201 {
01202 __sign = __neg_sign;
01203 __c = *(++__beg);
01204 }
01205 else
01206 __testvalid = false;
01207 }
01208 else if (__pos_sign.size() && __c == __pos_sign[0])
01209 {
01210 __sign = __pos_sign;
01211 __c = *(++__beg);
01212 }
01213 else if (__neg_sign.size() && __c == __neg_sign[0])
01214 {
01215 __sign = __neg_sign;
01216 __c = *(++__beg);
01217 }
01218 break;
01219 case money_base::value:
01220
01221
01222 while (__beg != __end
01223 && (__ctype.is(ctype_base::digit, __c)
01224 || (__c == __d && !__testdecfound)
01225 || __c == __sep))
01226 {
01227 if (__c == __d)
01228 {
01229 __grouping_tmp += static_cast<char>(__sep_pos);
01230 __sep_pos = 0;
01231 __testdecfound = true;
01232 }
01233 else if (__c == __sep)
01234 {
01235 if (__grouping.size())
01236 {
01237
01238 __grouping_tmp += static_cast<char>(__sep_pos);
01239 __sep_pos = 0;
01240 }
01241 else
01242 {
01243 __testvalid = false;
01244 break;
01245 }
01246 }
01247 else
01248 {
01249 __temp_units += __c;
01250 ++__sep_pos;
01251 }
01252 __c = *(++__beg);
01253 }
01254 break;
01255 case money_base::space:
01256 case money_base::none:
01257
01258 if (__i != 3)
01259 while (__beg != __end
01260 && __ctype.is(ctype_base::space, __c))
01261 __c = *(++__beg);
01262 break;
01263 }
01264 }
01265
01266
01267 if (__sign.size() > 1)
01268 {
01269 size_type __len = __sign.size();
01270 size_type __i = 1;
01271 for (; __c != __eof && __i < __len; ++__i)
01272 while (__beg != __end && __c != __sign[__i])
01273 __c = *(++__beg);
01274
01275 if (__i != __len)
01276 __testvalid = false;
01277 }
01278
01279
01280 while (__temp_units.size() > 1 && __temp_units[0] == __ctype.widen('0'))
01281 __temp_units.erase(__temp_units.begin());
01282
01283 if (__sign.size() && __sign == __neg_sign)
01284 __temp_units.insert(__temp_units.begin(), __ctype.widen('-'));
01285
01286
01287 if (__grouping.size() && __grouping_tmp.size())
01288 {
01289 if (!__verify_grouping(__grouping, __grouping_tmp))
01290 __testvalid = false;
01291 }
01292
01293
01294 if (__c == __eof)
01295 __err |= ios_base::eofbit;
01296
01297
01298 if (!__testvalid || !__temp_units.size())
01299 __err |= ios_base::failbit;
01300 else
01301
01302 __temp_units.swap(__units);
01303
01304 return __beg;
01305 }
01306
01307 template<typename _CharT, typename _OutIter>
01308 _OutIter
01309 money_put<_CharT, _OutIter>::
01310 do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
01311 long double __units) const
01312 {
01313 const locale __loc = __io.getloc();
01314 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
01315 #ifdef _GLIBCPP_USE_C99
01316
01317 int __cs_size = 64;
01318 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
01319
01320
01321 int __len = __convert_from_v(__cs, __cs_size, "%.0Lf", __units,
01322 _S_c_locale);
01323
01324 if (__len >= __cs_size)
01325 {
01326 __cs_size = __len + 1;
01327 __cs = static_cast<char*>(__builtin_alloca(__cs_size));
01328 __len = __convert_from_v(__cs, __cs_size, "%.0Lf", __units,
01329 _S_c_locale);
01330 }
01331 #else
01332
01333 const int __cs_size = numeric_limits<long double>::max_exponent10 + 3;
01334 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
01335 int __len = __convert_from_v(__cs, 0, "%.0Lf", __units, _S_c_locale);
01336 #endif
01337 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
01338 * __cs_size));
01339 __ctype.widen(__cs, __cs + __len, __ws);
01340 const string_type __digits(__ws, __len);
01341 return this->do_put(__s, __intl, __io, __fill, __digits);
01342 }
01343
01344 template<typename _CharT, typename _OutIter>
01345 _OutIter
01346 money_put<_CharT, _OutIter>::
01347 do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
01348 const string_type& __digits) const
01349 {
01350 typedef typename string_type::size_type size_type;
01351 typedef money_base::part part;
01352
01353 const locale __loc = __io.getloc();
01354 const size_type __width = static_cast<size_type>(__io.width());
01355
01356
01357 typedef moneypunct<_CharT, true> __money_true;
01358 typedef moneypunct<_CharT, false> __money_false;
01359 const __money_true& __mpt = use_facet<__money_true>(__loc);
01360 const __money_false& __mpf = use_facet<__money_false>(__loc);
01361 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
01362
01363
01364
01365 const char_type* __beg = __digits.data();
01366 const char_type* __end = __beg + __digits.size();
01367 money_base::pattern __p;
01368 string_type __sign;
01369 if (*__beg != __ctype.widen('-'))
01370 {
01371 __p = __intl ? __mpt.pos_format() : __mpf.pos_format();
01372 __sign =__intl ? __mpt.positive_sign() : __mpf.positive_sign();
01373 }
01374 else
01375 {
01376 __p = __intl ? __mpt.neg_format() : __mpf.neg_format();
01377 __sign =__intl ? __mpt.negative_sign() : __mpf.negative_sign();
01378 ++__beg;
01379 }
01380
01381
01382 __end = __ctype.scan_not(ctype_base::digit, __beg, __end);
01383 if (__beg != __end)
01384 {
01385
01386
01387
01388 string_type __res;
01389 string_type __value;
01390 const string_type __symbol = __intl ? __mpt.curr_symbol()
01391 : __mpf.curr_symbol();
01392
01393
01394 const int __frac = __intl ? __mpt.frac_digits()
01395 : __mpf.frac_digits();
01396 if (__frac > 0)
01397 {
01398 const char_type __d = __intl ? __mpt.decimal_point()
01399 : __mpf.decimal_point();
01400 if (__end - __beg >= __frac)
01401 {
01402 __value = string_type(__end - __frac, __end);
01403 __value.insert(__value.begin(), __d);
01404 __end -= __frac;
01405 }
01406 else
01407 {
01408
01409 __value = string_type(__beg, __end);
01410 int __paddec = __frac - (__end - __beg);
01411 char_type __zero = __ctype.widen('0');
01412 __value.insert(__value.begin(), __paddec, __zero);
01413 __value.insert(__value.begin(), __d);
01414 __beg = __end;
01415 }
01416 }
01417
01418
01419
01420 if (__beg != __end)
01421 {
01422 const string __grouping = __intl ? __mpt.grouping()
01423 : __mpf.grouping();
01424 if (__grouping.size())
01425 {
01426 const char_type __sep = __intl ? __mpt.thousands_sep()
01427 : __mpf.thousands_sep();
01428 const char* __gbeg = __grouping.c_str();
01429 const char* __gend = __gbeg + __grouping.size();
01430 const int __n = (__end - __beg) * 2;
01431 _CharT* __ws2 =
01432 static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __n));
01433 _CharT* __ws_end = __add_grouping(__ws2, __sep, __gbeg,
01434 __gend, __beg, __end);
01435 __value.insert(0, __ws2, __ws_end - __ws2);
01436 }
01437 else
01438 __value.insert(0, string_type(__beg, __end));
01439 }
01440
01441
01442 ios_base::fmtflags __f = __io.flags() & ios_base::adjustfield;
01443 size_type __len = __value.size() + __sign.size();
01444 __len += (__io.flags() & ios_base::showbase) ? __symbol.size() : 0;
01445 bool __testipad = __f == ios_base::internal && __len < __width;
01446
01447
01448 for (int __i = 0; __i < 4; ++__i)
01449 {
01450 part __which = static_cast<part>(__p.field[__i]);
01451 switch (__which)
01452 {
01453 case money_base::symbol:
01454 if (__io.flags() & ios_base::showbase)
01455 __res += __symbol;
01456 break;
01457 case money_base::sign:
01458
01459
01460
01461 if (__sign.size())
01462 __res += __sign[0];
01463 break;
01464 case money_base::value:
01465 __res += __value;
01466 break;
01467 case money_base::space:
01468
01469
01470
01471 if (__testipad)
01472 __res += string_type(__width - __len, __fill);
01473 else
01474 __res += __ctype.widen(__fill);
01475 break;
01476 case money_base::none:
01477 if (__testipad)
01478 __res += string_type(__width - __len, __fill);
01479 break;
01480 }
01481 }
01482
01483
01484 if (__sign.size() > 1)
01485 __res += string_type(__sign.begin() + 1, __sign.end());
01486
01487
01488 __len = __res.size();
01489 if (__width > __len)
01490 {
01491 if (__f == ios_base::left)
01492
01493 __res.append(__width - __len, __fill);
01494 else
01495
01496 __res.insert(0, string_type(__width - __len, __fill));
01497 __len = __width;
01498 }
01499
01500
01501 __s = __write(__s, __res.c_str(), __len);
01502 }
01503 __io.width(0);
01504 return __s;
01505 }
01506
01507
01508
01509
01510
01511 template<typename _CharT, typename _InIter>
01512 time_base::dateorder
01513 time_get<_CharT, _InIter>::do_date_order() const
01514 { return time_base::no_order; }
01515
01516 template<typename _CharT, typename _InIter>
01517 void
01518 time_get<_CharT, _InIter>::
01519 _M_extract_via_format(iter_type& __beg, iter_type& __end, ios_base& __io,
01520 ios_base::iostate& __err, tm* __tm,
01521 const _CharT* __format) const
01522 {
01523 locale __loc = __io.getloc();
01524 __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
01525 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
01526 size_t __len = char_traits<_CharT>::length(__format);
01527
01528 for (size_t __i = 0; __beg != __end && __i < __len && !__err; ++__i)
01529 {
01530 char __c = __format[__i];
01531 if (__c == '%')
01532 {
01533
01534 __c = __format[++__i];
01535 char __mod = 0;
01536 int __mem = 0;
01537 if (__c == 'E' || __c == 'O')
01538 {
01539 __mod = __c;
01540 __c = __format[++__i];
01541 }
01542 switch (__c)
01543 {
01544 const char* __cs;
01545 _CharT __wcs[10];
01546 case 'a':
01547
01548 const char_type* __days1[7];
01549 __tp._M_days_abbreviated(__days1);
01550 _M_extract_name(__beg, __end, __tm->tm_wday, __days1, 7,
01551 __err);
01552 break;
01553 case 'A':
01554
01555 const char_type* __days2[7];
01556 __tp._M_days(__days2);
01557 _M_extract_name(__beg, __end, __tm->tm_wday, __days2, 7,
01558 __err);
01559 break;
01560 case 'h':
01561 case 'b':
01562
01563 const char_type* __months1[12];
01564 __tp._M_months_abbreviated(__months1);
01565 _M_extract_name(__beg, __end, __tm->tm_mon, __months1, 12,
01566 __err);
01567 break;
01568 case 'B':
01569
01570 const char_type* __months2[12];
01571 __tp._M_months(__months2);
01572 _M_extract_name(__beg, __end, __tm->tm_mon, __months2, 12,
01573 __err);
01574 break;
01575 case 'c':
01576
01577 const char_type* __dt[2];
01578 __tp._M_date_time_formats(__dt);
01579 _M_extract_via_format(__beg, __end, __io, __err, __tm,
01580 __dt[0]);
01581 break;
01582 case 'd':
01583
01584 _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
01585 __ctype, __err);
01586 break;
01587 case 'D':
01588
01589 __cs = "%m/%d/%y";
01590 __ctype.widen(__cs, __cs + 9, __wcs);
01591 _M_extract_via_format(__beg, __end, __io, __err, __tm,
01592 __wcs);
01593 break;
01594 case 'H':
01595
01596 _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
01597 __ctype, __err);
01598 break;
01599 case 'I':
01600
01601 _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
01602 __ctype, __err);
01603 break;
01604 case 'm':
01605
01606 _M_extract_num(__beg, __end, __mem, 1, 12, 2, __ctype,
01607 __err);
01608 if (!__err)
01609 __tm->tm_mon = __mem - 1;
01610 break;
01611 case 'M':
01612
01613 _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
01614 __ctype, __err);
01615 break;
01616 case 'n':
01617 if (__ctype.narrow(*__beg, 0) == '\n')
01618 ++__beg;
01619 else
01620 __err |= ios_base::failbit;
01621 break;
01622 case 'R':
01623
01624 __cs = "%H:%M";
01625 __ctype.widen(__cs, __cs + 6, __wcs);
01626 _M_extract_via_format(__beg, __end, __io, __err, __tm,
01627 __wcs);
01628 break;
01629 case 'S':
01630
01631 _M_extract_num(__beg, __end, __tm->tm_sec, 0, 59, 2,
01632 __ctype, __err);
01633 break;
01634 case 't':
01635 if (__ctype.narrow(*__beg, 0) == '\t')
01636 ++__beg;
01637 else
01638 __err |= ios_base::failbit;
01639 break;
01640 case 'T':
01641
01642 __cs = "%H:%M:%S";
01643 __ctype.widen(__cs, __cs + 9, __wcs);
01644 _M_extract_via_format(__beg, __end, __io, __err, __tm,
01645 __wcs);
01646 break;
01647 case 'x':
01648
01649 const char_type* __dates[2];
01650 __tp._M_date_formats(__dates);
01651 _M_extract_via_format(__beg, __end, __io, __err, __tm,
01652 __dates[0]);
01653 break;
01654 case 'X':
01655
01656 const char_type* __times[2];
01657 __tp._M_time_formats(__times);
01658 _M_extract_via_format(__beg, __end, __io, __err, __tm,
01659 __times[0]);
01660 break;
01661 case 'y':
01662
01663 _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2,
01664 __ctype, __err);
01665 break;
01666 case 'Y':
01667
01668 _M_extract_num(__beg, __end, __mem, 0,
01669 numeric_limits<int>::max(), 4,
01670 __ctype, __err);
01671 if (!__err)
01672 __tm->tm_year = __mem - 1900;
01673 break;
01674 case 'Z':
01675
01676 if (__ctype.is(ctype_base::upper, *__beg))
01677 {
01678 int __tmp;
01679 _M_extract_name(__beg, __end, __tmp,
01680 __timepunct<_CharT>::_S_timezones,
01681 14, __err);
01682
01683
01684 char_type __c = *__beg;
01685 if (!__err && __tmp == 0
01686 && (__c == __ctype.widen('-')
01687 || __c == __ctype.widen('+')))
01688 {
01689 _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
01690 __ctype, __err);
01691 _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
01692 __ctype, __err);
01693 }
01694 }
01695 else
01696 __err |= ios_base::failbit;
01697 break;
01698 default:
01699
01700 __err |= ios_base::failbit;
01701 }
01702 }
01703 else
01704 {
01705
01706 if (__c == __ctype.narrow(*__beg, 0))
01707 ++__beg;
01708 else
01709 __err |= ios_base::failbit;
01710 }
01711 }
01712 }
01713
01714 template<typename _CharT, typename _InIter>
01715 void
01716 time_get<_CharT, _InIter>::
01717 _M_extract_num(iter_type& __beg, iter_type& __end, int& __member,
01718 int __min, int __max, size_t __len,
01719 const ctype<_CharT>& __ctype,
01720 ios_base::iostate& __err) const
01721 {
01722 size_t __i = 0;
01723 string __digits;
01724 bool __testvalid = true;
01725 char_type __c = *__beg;
01726 while (__beg != __end && __i < __len
01727 && __ctype.is(ctype_base::digit, __c))
01728 {
01729 __digits += __ctype.narrow(__c, 0);
01730 __c = *(++__beg);
01731 ++__i;
01732 }
01733 if (__i == __len)
01734 {
01735 int __value = atoi(__digits.c_str());
01736 if (__min <= __value && __value <= __max)
01737 __member = __value;
01738 else
01739 __testvalid = false;
01740 }
01741 else
01742 __testvalid = false;
01743 if (!__testvalid)
01744 __err |= ios_base::failbit;
01745 }
01746
01747
01748
01749 template<typename _CharT, typename _InIter>
01750 void
01751 time_get<_CharT, _InIter>::
01752 _M_extract_name(iter_type& __beg, iter_type& __end, int& __member,
01753 const _CharT** __names, size_t __indexlen,
01754 ios_base::iostate& __err) const
01755 {
01756 typedef char_traits<_CharT> __traits_type;
01757 int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
01758 * __indexlen));
01759 size_t __nmatches = 0;
01760 size_t __pos = 0;
01761 bool __testvalid = true;
01762 const char_type* __name;
01763
01764 char_type __c = *__beg;
01765
01766 for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
01767 if (__c == __names[__i1][0])
01768 __matches[__nmatches++] = __i1;
01769
01770 while (__nmatches > 1)
01771 {
01772
01773 size_t __minlen = 10;
01774 for (size_t __i2 = 0; __i2 < __nmatches; ++__i2)
01775 __minlen = min(__minlen,
01776 __traits_type::length(__names[__matches[__i2]]));
01777
01778 if (__pos < __minlen && __beg != __end)
01779 {
01780 ++__pos;
01781 __c = *(++__beg);
01782 for (size_t __i3 = 0; __i3 < __nmatches; ++__i3)
01783 {
01784 __name = __names[__matches[__i3]];
01785 if (__name[__pos] != __c)
01786 __matches[__i3] = __matches[--__nmatches];
01787 }
01788 }
01789 else
01790 break;
01791 }
01792
01793 if (__nmatches == 1)
01794 {
01795
01796 __name = __names[__matches[0]];
01797 const size_t __len = __traits_type::length(__name);
01798 while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
01799 ++__beg, ++__pos;
01800
01801 if (__len == __pos)
01802 __member = __matches[0];
01803 else
01804 __testvalid = false;
01805 }
01806 else
01807 __testvalid = false;
01808 if (!__testvalid)
01809 __err |= ios_base::failbit;
01810 }
01811
01812 template<typename _CharT, typename _InIter>
01813 _InIter
01814 time_get<_CharT, _InIter>::
01815 do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
01816 ios_base::iostate& __err, tm* __tm) const
01817 {
01818 _CharT __wcs[3];
01819 const char* __cs = "%X";
01820 locale __loc = __io.getloc();
01821 ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
01822 __ctype.widen(__cs, __cs + 3, __wcs);
01823 _M_extract_via_format(__beg, __end, __io, __err, __tm, __wcs);
01824 if (__beg == __end)
01825 __err |= ios_base::eofbit;
01826 return __beg;
01827 }
01828
01829 template<typename _CharT, typename _InIter>
01830 _InIter
01831 time_get<_CharT, _InIter>::
01832 do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
01833 ios_base::iostate& __err, tm* __tm) const
01834 {
01835 _CharT __wcs[3];
01836 const char* __cs = "%x";
01837 locale __loc = __io.getloc();
01838 ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
01839 __ctype.widen(__cs, __cs + 3, __wcs);
01840 _M_extract_via_format(__beg, __end, __io, __err, __tm, __wcs);
01841 if (__beg == __end)
01842 __err |= ios_base::eofbit;
01843 return __beg;
01844 }
01845
01846 template<typename _CharT, typename _InIter>
01847 _InIter
01848 time_get<_CharT, _InIter>::
01849 do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
01850 ios_base::iostate& __err, tm* __tm) const
01851 {
01852 typedef char_traits<_CharT> __traits_type;
01853 locale __loc = __io.getloc();
01854 __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
01855 const char_type* __days[7];
01856 __tp._M_days_abbreviated(__days);
01857 int __tmpwday;
01858 _M_extract_name(__beg, __end, __tmpwday, __days, 7, __err);
01859
01860
01861
01862
01863
01864
01865
01866 if (!__err)
01867 {
01868 size_t __pos = __traits_type::length(__days[__tmpwday]);
01869 __tp._M_days(__days);
01870 const char_type* __name = __days[__tmpwday];
01871 if (__name[__pos] == *__beg)
01872 {
01873
01874 const size_t __len = __traits_type::length(__name);
01875 while (__pos < __len && __beg != __end
01876 && __name[__pos] == *__beg)
01877 ++__beg, ++__pos;
01878 if (__len != __pos)
01879 __err |= ios_base::failbit;
01880 }
01881 if (!__err)
01882 __tm->tm_wday = __tmpwday;
01883 }
01884 if (__beg == __end)
01885 __err |= ios_base::eofbit;
01886 return __beg;
01887 }
01888
01889 template<typename _CharT, typename _InIter>
01890 _InIter
01891 time_get<_CharT, _InIter>::
01892 do_get_monthname(iter_type __beg, iter_type __end,
01893 ios_base& __io, ios_base::iostate& __err, tm* __tm) const
01894 {
01895 typedef char_traits<_CharT> __traits_type;
01896 locale __loc = __io.getloc();
01897 __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
01898 const char_type* __months[12];
01899 __tp._M_months_abbreviated(__months);
01900 int __tmpmon;
01901 _M_extract_name(__beg, __end, __tmpmon, __months, 12, __err);
01902
01903
01904
01905
01906
01907
01908
01909 if (!__err)
01910 {
01911 size_t __pos = __traits_type::length(__months[__tmpmon]);
01912 __tp._M_months(__months);
01913 const char_type* __name = __months[__tmpmon];
01914 if (__name[__pos] == *__beg)
01915 {
01916
01917 const size_t __len = __traits_type::length(__name);
01918 while (__pos < __len && __beg != __end
01919 && __name[__pos] == *__beg)
01920 ++__beg, ++__pos;
01921 if (__len != __pos)
01922 __err |= ios_base::failbit;
01923 }
01924 if (!__err)
01925 __tm->tm_mon = __tmpmon;
01926 }
01927
01928 if (__beg == __end)
01929 __err |= ios_base::eofbit;
01930 return __beg;
01931 }
01932
01933 template<typename _CharT, typename _InIter>
01934 _InIter
01935 time_get<_CharT, _InIter>::
01936 do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
01937 ios_base::iostate& __err, tm* __tm) const
01938 {
01939 locale __loc = __io.getloc();
01940 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
01941
01942 char_type __c = *__beg;
01943 size_t __i = 0;
01944 string __digits;
01945 while (__i < 4 && __beg != __end && __ctype.is(ctype_base::digit, __c))
01946 {
01947 __digits += __ctype.narrow(__c, 0);
01948 __c = *(++__beg);
01949 ++__i;
01950 }
01951 if (__i == 2 || __i == 4)
01952 {
01953 long __l;
01954 __convert_to_v(__digits.c_str(), __l, __err, _S_c_locale);
01955 if (!(__err & ios_base::failbit) && __l <= INT_MAX)
01956 {
01957 __l = __i == 2 ? __l : __l - 1900;
01958 __tm->tm_year = static_cast<int>(__l);
01959 }
01960 }
01961 else
01962 __err |= ios_base::failbit;
01963 if (__beg == __end)
01964 __err |= ios_base::eofbit;
01965 return __beg;
01966 }
01967
01968 template<typename _CharT, typename _OutIter>
01969 _OutIter
01970 time_put<_CharT, _OutIter>::
01971 put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
01972 const _CharT* __beg, const _CharT* __end) const
01973 {
01974 locale __loc = __io.getloc();
01975 ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
01976 while (__beg != __end)
01977 {
01978 char __c = __ctype.narrow(*__beg, 0);
01979 ++__beg;
01980 if (__c == '%')
01981 {
01982 char __format;
01983 char __mod = 0;
01984 size_t __len = 1;
01985 __c = __ctype.narrow(*__beg, 0);
01986 ++__beg;
01987 if (__c == 'E' || __c == 'O')
01988 {
01989 __mod = __c;
01990 __format = __ctype.narrow(*__beg, 0);
01991 ++__beg;
01992 }
01993 else
01994 __format = __c;
01995 __s = this->do_put(__s, __io, _CharT(), __tm, __format, __mod);
01996 }
01997 else
01998 {
01999 *__s = __c;
02000 ++__s;
02001 }
02002 }
02003 return __s;
02004 }
02005
02006 template<typename _CharT, typename _OutIter>
02007 _OutIter
02008 time_put<_CharT, _OutIter>::
02009 do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
02010 char __format, char __mod) const
02011 {
02012 locale __loc = __io.getloc();
02013 ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
02014 __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
02015
02016
02017
02018 const size_t __maxlen = 64;
02019 char_type* __res = static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __maxlen));
02020
02021
02022
02023
02024
02025
02026 char_type __fmt[4];
02027 __fmt[0] = __ctype.widen('%');
02028 if (!__mod)
02029 {
02030 __fmt[1] = __format;
02031 __fmt[2] = char_type();
02032 }
02033 else
02034 {
02035 __fmt[1] = __mod;
02036 __fmt[2] = __format;
02037 __fmt[3] = char_type();
02038 }
02039
02040 __tp._M_put(__res, __maxlen, __fmt, __tm);
02041
02042
02043 return __write(__s, __res, char_traits<char_type>::length(__res));
02044 }
02045
02046
02047
02048 template<typename _CharT>
02049 int
02050 collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const
02051 { return 0; }
02052
02053
02054 template<typename _CharT>
02055 size_t
02056 collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const
02057 { return 0; }
02058
02059 template<typename _CharT>
02060 int
02061 collate<_CharT>::
02062 do_compare(const _CharT* __lo1, const _CharT* __hi1,
02063 const _CharT* __lo2, const _CharT* __hi2) const
02064 {
02065
02066
02067 const string_type __one(__lo1, __hi1);
02068 const string_type __two(__lo2, __hi2);
02069
02070 const _CharT* __p = __one.c_str();
02071 const _CharT* __pend = __one.c_str() + __one.length();
02072 const _CharT* __q = __two.c_str();
02073 const _CharT* __qend = __two.c_str() + __two.length();
02074
02075
02076
02077
02078 for (;;)
02079 {
02080 int __res = _M_compare(__p, __q);
02081 if (__res)
02082 return __res;
02083
02084 __p += char_traits<_CharT>::length(__p);
02085 __q += char_traits<_CharT>::length(__q);
02086 if (__p == __pend && __q == __qend)
02087 return 0;
02088 else if (__p == __pend)
02089 return -1;
02090 else if (__q == __qend)
02091 return 1;
02092
02093 __p++;
02094 __q++;
02095 }
02096 }
02097
02098 template<typename _CharT>
02099 typename collate<_CharT>::string_type
02100 collate<_CharT>::
02101 do_transform(const _CharT* __lo, const _CharT* __hi) const
02102 {
02103
02104 string_type __str(__lo, __hi);
02105
02106 const _CharT* __p = __str.c_str();
02107 const _CharT* __pend = __str.c_str() + __str.length();
02108
02109 size_t __len = (__hi - __lo) * 2;
02110
02111 string_type __ret;
02112
02113
02114
02115
02116 for (;;)
02117 {
02118
02119 _CharT* __c =
02120 static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len));
02121 size_t __res = _M_transform(__c, __p, __len);
02122
02123
02124 if (__res >= __len)
02125 {
02126 __len = __res + 1;
02127 __c = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
02128 * __len));
02129 __res = _M_transform(__c, __p, __res + 1);
02130 }
02131
02132 __ret.append(__c, __res);
02133 __p += char_traits<_CharT>::length(__p);
02134 if (__p == __pend)
02135 return __ret;
02136
02137 __p++;
02138 __ret.push_back(_CharT());
02139 }
02140 }
02141
02142 template<typename _CharT>
02143 long
02144 collate<_CharT>::
02145 do_hash(const _CharT* __lo, const _CharT* __hi) const
02146 {
02147 unsigned long __val = 0;
02148 for (; __lo < __hi; ++__lo)
02149 __val = *__lo + ((__val << 7) |
02150 (__val >> (numeric_limits<unsigned long>::digits - 7)));
02151 return static_cast<long>(__val);
02152 }
02153
02154
02155
02156
02157
02158
02159
02160
02161
02162
02163
02164
02165 template<typename _CharT, typename _Traits>
02166 void
02167 __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
02168 _CharT* __news, const _CharT* __olds,
02169 const streamsize __newlen,
02170 const streamsize __oldlen, const bool __num)
02171 {
02172 const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
02173 const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
02174
02175
02176 if (__adjust == ios_base::left)
02177 {
02178 _Traits::copy(__news, const_cast<_CharT*>(__olds), __oldlen);
02179 _Traits::assign(__news + __oldlen, __plen, __fill);
02180 return;
02181 }
02182
02183 size_t __mod = 0;
02184 if (__adjust == ios_base::internal && __num)
02185 {
02186
02187
02188
02189 const locale& __loc = __io.getloc();
02190 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
02191 const _CharT __minus = __ctype.widen('-');
02192 const _CharT __plus = __ctype.widen('+');
02193 const bool __testsign = _Traits::eq(__olds[0], __minus)
02194 || _Traits::eq(__olds[0], __plus);
02195
02196 const bool __testhex = (_Traits::eq(__ctype.widen('0'), __olds[0])
02197 && __oldlen > 1
02198 && (_Traits::eq(__ctype.widen('x'), __olds[1])
02199 || _Traits::eq(__ctype.widen('X'),
02200 __olds[1])));
02201 if (__testhex)
02202 {
02203 __news[0] = __olds[0];
02204 __news[1] = __olds[1];
02205 __mod = 2;
02206 __news += 2;
02207 }
02208 else if (__testsign)
02209 {
02210 __news[0] = __olds[0];
02211 __mod = 1;
02212 ++__news;
02213 }
02214
02215 }
02216 _Traits::assign(__news, __plen, __fill);
02217 _Traits::copy(__news + __plen, const_cast<_CharT*>(__olds + __mod),
02218 __oldlen - __mod);
02219 }
02220
02221 template<typename _CharT>
02222 bool
02223 __verify_grouping(const basic_string<_CharT>& __grouping,
02224 basic_string<_CharT>& __grouping_tmp)
02225 {
02226 const size_t __n = __grouping_tmp.size() - 1;
02227 const size_t __min = std::min(__n, __grouping.size() - 1);
02228 size_t __i = __n;
02229 bool __test = true;
02230
02231
02232
02233
02234 for (size_t __j = 0; __j < __min && __test; --__i, ++__j)
02235 __test = __grouping_tmp[__i] == __grouping[__j];
02236 for (; __i && __test; --__i)
02237 __test = __grouping_tmp[__i] == __grouping[__min];
02238
02239
02240 __test &= __grouping_tmp[0] <= __grouping[__min];
02241 return __test;
02242 }
02243
02244 template<typename _CharT>
02245 _CharT*
02246 __add_grouping(_CharT* __s, _CharT __sep,
02247 const char* __gbeg, const char* __gend,
02248 const _CharT* __first, const _CharT* __last)
02249 {
02250 if (__last - __first > *__gbeg)
02251 {
02252 __s = __add_grouping(__s, __sep,
02253 (__gbeg + 1 == __gend ? __gbeg : __gbeg + 1),
02254 __gend, __first, __last - *__gbeg);
02255 __first = __last - *__gbeg;
02256 *__s++ = __sep;
02257 }
02258 do
02259 *__s++ = *__first++;
02260 while (__first != __last);
02261 return __s;
02262 }
02263
02264 #if 1
02265
02266 template<typename _CharT, typename _OutIter>
02267 template<typename _ValueT>
02268 _OutIter
02269 num_put<_CharT, _OutIter>::
02270 _M_convert_int(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
02271 char __modl, _ValueT __v) const
02272 {
02273
02274
02275
02276 char __fbuf[16];
02277 _S_format_int(__io, __fbuf, __mod, __modl);
02278 #ifdef _GLIBCPP_USE_C99
02279
02280 int __cs_size = 64;
02281 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
02282 int __len = __convert_from_v(__cs, __cs_size, __fbuf, __v,
02283 _S_c_locale);
02284
02285 if (__len >= __cs_size)
02286 {
02287 __cs_size = __len + 1;
02288 __cs = static_cast<char*>(__builtin_alloca(__cs_size));
02289 __len = __convert_from_v(__cs, __cs_size, __fbuf, __v,
02290 _S_c_locale);
02291 }
02292 #else
02293
02294
02295 char __cs[128];
02296 int __len = __convert_from_v(__cs, 0, __fbuf, __v, _S_c_locale);
02297 #endif
02298 return _M_widen_int(__s, __io, __fill, __cs, __len);
02299 }
02300
02301 template<typename _CharT, typename _OutIter>
02302 _OutIter
02303 num_put<_CharT, _OutIter>::
02304 _M_widen_float(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs,
02305 int __len) const
02306 {
02307 typedef char_traits<_CharT> __traits_type;
02308
02309
02310 const locale __loc = __io.getloc();
02311 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
02312 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
02313 * __len));
02314
02315
02316 _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
02317 * __len * 2));
02318 __ctype.widen(__cs, __cs + __len, __ws);
02319
02320
02321 const _CharT* __p;
02322 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
02323 if (__p = __traits_type::find(__ws, __len, __ctype.widen('.')))
02324 __ws[__p - __ws] = __np.decimal_point();
02325
02326 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
02327
02328
02329 const string __grouping = __np.grouping();
02330 if (__grouping.size())
02331 {
02332 _CharT* __p2;
02333 int __declen = __p ? __p - __ws : __len;
02334 __p2 = __add_grouping(__ws2, __np.thousands_sep(),
02335 __grouping.c_str(),
02336 __grouping.c_str() + __grouping.size(),
02337 __ws, __ws + __declen);
02338 int __newlen = __p2 - __ws2;
02339
02340
02341 if (__p)
02342 {
02343 __traits_type::copy(__p2, __p, __len - __declen);
02344 __newlen += __len - __declen;
02345 }
02346
02347
02348 __ws = __ws2;
02349 __len = __newlen;
02350 }
02351 #endif
02352 return _M_insert(__s, __io, __fill, __ws, __len);
02353 }
02354
02355 template<typename _CharT, typename _OutIter>
02356 _OutIter
02357 num_put<_CharT, _OutIter>::
02358 _M_widen_int(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs,
02359 int __len) const
02360 {
02361
02362
02363 const locale __loc = __io.getloc();
02364 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
02365 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
02366 * __len));
02367
02368
02369 _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
02370 * __len * 2));
02371 __ctype.widen(__cs, __cs + __len, __ws);
02372
02373
02374 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
02375 const string __grouping = __np.grouping();
02376 if (__grouping.size())
02377 {
02378
02379
02380
02381
02382
02383 streamsize __off = 0;
02384 const ios_base::fmtflags __basefield = __io.flags()
02385 & ios_base::basefield;
02386 if ((__io.flags() & ios_base::showbase) && __len > 1)
02387 if (__basefield == ios_base::oct)
02388 {
02389 __off = 1;
02390 *__ws2 = *__ws;
02391 }
02392 else if (__basefield == ios_base::hex)
02393 {
02394 __off = 2;
02395 *__ws2 = *__ws;
02396 *(__ws2 + 1) = *(__ws + 1);
02397 }
02398 _CharT* __p;
02399 __p = __add_grouping(__ws2 + __off, __np.thousands_sep(),
02400 __grouping.c_str(),
02401 __grouping.c_str() + __grouping.size(),
02402 __ws + __off, __ws + __len);
02403 __len = __p - __ws2;
02404
02405 __ws = __ws2;
02406 }
02407 return _M_insert(__s, __io, __fill, __ws, __len);
02408 }
02409
02410
02411
02412 template<typename _CharT, typename _OutIter>
02413 _OutIter
02414 num_put<_CharT, _OutIter>::
02415 _M_insert(_OutIter __s, ios_base& __io, _CharT __fill, const _CharT* __ws,
02416 int __len) const
02417 {
02418 typedef char_traits<_CharT> __traits_type;
02419
02420
02421 streamsize __w = __io.width();
02422 _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
02423 * __w));
02424 if (__w > static_cast<streamsize>(__len))
02425 {
02426 __pad<_CharT, __traits_type>::_S_pad(__io, __fill, __ws2, __ws,
02427 __w, __len, true);
02428 __len = static_cast<int>(__w);
02429
02430 __ws = __ws2;
02431 }
02432 __io.width(0);
02433
02434
02435
02436 return __write(__s, __ws, __len);
02437 }
02438 #endif
02439
02440 template<typename _CharT>
02441 __locale_cache<numpunct<_CharT> >::__locale_cache(const locale& __loc)
02442 : _M_truename(0), _M_falsename(0), _M_use_grouping(false),
02443 _M_grouping(0)
02444 {
02445 if (has_facet<numpunct<_CharT> >(__loc))
02446 {
02447 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
02448 _M_decimal_point = __np.decimal_point();
02449 _M_thousands_sep = __np.thousands_sep();
02450
02451 string_type __false = __np.falsename();
02452 _CharT* __falsename = new _CharT[__false.length() + 1];
02453 __false.copy(__falsename, __false.length());
02454 __falsename[__false.length()] = _CharT();
02455 _M_falsename = __falsename;
02456
02457 string_type __true = __np.truename();
02458 _CharT* __truename = new _CharT[__true.length() + 1];
02459 __true.copy(__truename, __true.length());
02460 __truename[__true.length()] = _CharT();
02461 _M_truename = __truename;
02462
02463 string __grouping = __np.grouping();
02464 char* __group = new char[__grouping.length() + 1];
02465 __grouping.copy(__group, __grouping.length());
02466 __group[__grouping.length()] = 0;
02467 _M_grouping = __group;
02468
02469 _M_use_grouping = __grouping.length() != 0
02470 && __grouping.data()[0] != 0;
02471 }
02472
02473 if (has_facet<ctype<_CharT> >(__loc))
02474 {
02475 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
02476 __ct.widen(__num_base::_S_atoms_out,
02477 __num_base::_S_atoms_out + __num_base::_S_end,
02478 _M_atoms_out);
02479 }
02480 }
02481
02482
02483
02484 template<typename _CharT>
02485 __locale_cache<numpunct<_CharT> >::
02486 __locale_cache(const locale& __loc, bool)
02487 {
02488
02489 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
02490 _M_thousands_sep = __np._M_thousands_sep;
02491 _M_decimal_point = __np._M_decimal_point;
02492 _M_falsename = __np._M_falsename;
02493 _M_truename = __np._M_truename;
02494 _M_grouping = __np._M_grouping;
02495 _M_use_grouping = false;
02496
02497 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
02498 __ct.widen(__num_base::_S_atoms_out,
02499 __num_base::_S_atoms_out + __num_base::_S_end,
02500 _M_atoms_out);
02501 }
02502
02503
02504
02505
02506 #if _GLIBCPP_EXTERN_TEMPLATE
02507 extern template class moneypunct<char, false>;
02508 extern template class moneypunct<char, true>;
02509 extern template class moneypunct_byname<char, false>;
02510 extern template class moneypunct_byname<char, true>;
02511 extern template class money_get<char>;
02512 extern template class money_put<char>;
02513 extern template class numpunct<char>;
02514 extern template class numpunct_byname<char>;
02515 extern template class num_get<char>;
02516 extern template class num_put<char>;
02517 extern template class __timepunct<char>;
02518 extern template class time_put<char>;
02519 extern template class time_put_byname<char>;
02520 extern template class time_get<char>;
02521 extern template class time_get_byname<char>;
02522 extern template class messages<char>;
02523 extern template class messages_byname<char>;
02524 extern template class ctype_byname<char>;
02525 extern template class codecvt_byname<char, char, mbstate_t>;
02526 extern template class collate<char>;
02527 extern template class collate_byname<char>;
02528
02529 extern template
02530 const codecvt<char, char, mbstate_t>&
02531 use_facet<codecvt<char, char, mbstate_t> >(const locale&);
02532
02533 extern template
02534 const collate<char>&
02535 use_facet<collate<char> >(const locale&);
02536
02537 extern template
02538 const numpunct<char>&
02539 use_facet<numpunct<char> >(const locale&);
02540
02541 extern template
02542 const num_put<char>&
02543 use_facet<num_put<char> >(const locale&);
02544
02545 extern template
02546 const num_get<char>&
02547 use_facet<num_get<char> >(const locale&);
02548
02549 extern template
02550 const moneypunct<char, true>&
02551 use_facet<moneypunct<char, true> >(const locale&);
02552
02553 extern template
02554 const moneypunct<char, false>&
02555 use_facet<moneypunct<char, false> >(const locale&);
02556
02557 extern template
02558 const money_put<char>&
02559 use_facet<money_put<char> >(const locale&);
02560
02561 extern template
02562 const money_get<char>&
02563 use_facet<money_get<char> >(const locale&);
02564
02565 extern template
02566 const __timepunct<char>&
02567 use_facet<__timepunct<char> >(const locale&);
02568
02569 extern template
02570 const time_put<char>&
02571 use_facet<time_put<char> >(const locale&);
02572
02573 extern template
02574 const time_get<char>&
02575 use_facet<time_get<char> >(const locale&);
02576
02577 extern template
02578 const messages<char>&
02579 use_facet<messages<char> >(const locale&);
02580
02581 extern template
02582 bool
02583 has_facet<ctype<char> >(const locale&);
02584
02585 extern template
02586 bool
02587 has_facet<codecvt<char, char, mbstate_t> >(const locale&);
02588
02589 extern template
02590 bool
02591 has_facet<collate<char> >(const locale&);
02592
02593 extern template
02594 bool
02595 has_facet<numpunct<char> >(const locale&);
02596
02597 extern template
02598 bool
02599 has_facet<num_put<char> >(const locale&);
02600
02601 extern template
02602 bool
02603 has_facet<num_get<char> >(const locale&);
02604
02605 extern template
02606 bool
02607 has_facet<moneypunct<char> >(const locale&);
02608
02609 extern template
02610 bool
02611 has_facet<money_put<char> >(const locale&);
02612
02613 extern template
02614 bool
02615 has_facet<money_get<char> >(const locale&);
02616
02617 extern template
02618 bool
02619 has_facet<__timepunct<char> >(const locale&);
02620
02621 extern template
02622 bool
02623 has_facet<time_put<char> >(const locale&);
02624
02625 extern template
02626 bool
02627 has_facet<time_get<char> >(const locale&);
02628
02629 extern template
02630 bool
02631 has_facet<messages<char> >(const locale&);
02632
02633 #ifdef _GLIBCPP_USE_WCHAR_T
02634 extern template class moneypunct<wchar_t, false>;
02635 extern template class moneypunct<wchar_t, true>;
02636 extern template class moneypunct_byname<wchar_t, false>;
02637 extern template class moneypunct_byname<wchar_t, true>;
02638 extern template class money_get<wchar_t>;
02639 extern template class money_put<wchar_t>;
02640 extern template class numpunct<wchar_t>;
02641 extern template class numpunct_byname<wchar_t>;
02642 extern template class num_get<wchar_t>;
02643 extern template class num_put<wchar_t>;
02644 extern template class __timepunct<wchar_t>;
02645 extern template class time_put<wchar_t>;
02646 extern template class time_put_byname<wchar_t>;
02647 extern template class time_get<wchar_t>;
02648 extern template class time_get_byname<wchar_t>;
02649 extern template class messages<wchar_t>;
02650 extern template class messages_byname<wchar_t>;
02651 extern template class ctype_byname<wchar_t>;
02652 extern template class codecvt_byname<wchar_t, char, mbstate_t>;
02653 extern template class collate<wchar_t>;
02654 extern template class collate_byname<wchar_t>;
02655
02656 extern template
02657 const codecvt<wchar_t, char, mbstate_t>&
02658 use_facet<codecvt<wchar_t, char, mbstate_t> >(locale const&);
02659
02660 extern template
02661 const collate<wchar_t>&
02662 use_facet<collate<wchar_t> >(const locale&);
02663
02664 extern template
02665 const numpunct<wchar_t>&
02666 use_facet<numpunct<wchar_t> >(const locale&);
02667
02668 extern template
02669 const num_put<wchar_t>&
02670 use_facet<num_put<wchar_t> >(const locale&);
02671
02672 extern template
02673 const num_get<wchar_t>&
02674 use_facet<num_get<wchar_t> >(const locale&);
02675
02676 extern template
02677 const moneypunct<wchar_t, true>&
02678 use_facet<moneypunct<wchar_t, true> >(const locale&);
02679
02680 extern template
02681 const moneypunct<wchar_t, false>&
02682 use_facet<moneypunct<wchar_t, false> >(const locale&);
02683
02684 extern template
02685 const money_put<wchar_t>&
02686 use_facet<money_put<wchar_t> >(const locale&);
02687
02688 extern template
02689 const money_get<wchar_t>&
02690 use_facet<money_get<wchar_t> >(const locale&);
02691
02692 extern template
02693 const __timepunct<wchar_t>&
02694 use_facet<__timepunct<wchar_t> >(const locale&);
02695
02696 extern template
02697 const time_put<wchar_t>&
02698 use_facet<time_put<wchar_t> >(const locale&);
02699
02700 extern template
02701 const time_get<wchar_t>&
02702 use_facet<time_get<wchar_t> >(const locale&);
02703
02704 extern template
02705 const messages<wchar_t>&
02706 use_facet<messages<wchar_t> >(const locale&);
02707
02708 extern template
02709 bool
02710 has_facet<ctype<wchar_t> >(const locale&);
02711
02712 extern template
02713 bool
02714 has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
02715
02716 extern template
02717 bool
02718 has_facet<collate<wchar_t> >(const locale&);
02719
02720 extern template
02721 bool
02722 has_facet<numpunct<wchar_t> >(const locale&);
02723
02724 extern template
02725 bool
02726 has_facet<num_put<wchar_t> >(const locale&);
02727
02728 extern template
02729 bool
02730 has_facet<num_get<wchar_t> >(const locale&);
02731
02732 extern template
02733 bool
02734 has_facet<moneypunct<wchar_t> >(const locale&);
02735
02736 extern template
02737 bool
02738 has_facet<money_put<wchar_t> >(const locale&);
02739
02740 extern template
02741 bool
02742 has_facet<money_get<wchar_t> >(const locale&);
02743
02744 extern template
02745 bool
02746 has_facet<__timepunct<wchar_t> >(const locale&);
02747
02748 extern template
02749 bool
02750 has_facet<time_put<wchar_t> >(const locale&);
02751
02752 extern template
02753 bool
02754 has_facet<time_get<wchar_t> >(const locale&);
02755
02756 extern template
02757 bool
02758 has_facet<messages<wchar_t> >(const locale&);
02759 #endif
02760 #endif
02761 }
02762
02763 #endif