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 && (_Traits::eq(__ctype.widen('x'), __olds[1])
02198 || _Traits::eq(__ctype.widen('X'), __olds[1]));
02199 if (__testhex)
02200 {
02201 __news[0] = __olds[0];
02202 __news[1] = __olds[1];
02203 __mod = 2;
02204 __news += 2;
02205 }
02206 else if (__testsign)
02207 {
02208 __news[0] = __olds[0];
02209 __mod = 1;
02210 ++__news;
02211 }
02212
02213 }
02214 _Traits::assign(__news, __plen, __fill);
02215 _Traits::copy(__news + __plen, const_cast<_CharT*>(__olds + __mod),
02216 __oldlen - __mod);
02217 }
02218
02219 template<typename _CharT>
02220 bool
02221 __verify_grouping(const basic_string<_CharT>& __grouping,
02222 basic_string<_CharT>& __grouping_tmp)
02223 {
02224 const size_t __n = __grouping_tmp.size() - 1;
02225 const size_t __min = std::min(__n, __grouping.size() - 1);
02226 size_t __i = __n;
02227 bool __test = true;
02228
02229
02230
02231
02232 for (size_t __j = 0; __j < __min && __test; --__i, ++__j)
02233 __test = __grouping_tmp[__i] == __grouping[__j];
02234 for (; __i && __test; --__i)
02235 __test = __grouping_tmp[__i] == __grouping[__min];
02236
02237
02238 __test &= __grouping_tmp[0] <= __grouping[__min];
02239 return __test;
02240 }
02241
02242 template<typename _CharT>
02243 _CharT*
02244 __add_grouping(_CharT* __s, _CharT __sep,
02245 const char* __gbeg, const char* __gend,
02246 const _CharT* __first, const _CharT* __last)
02247 {
02248 if (__last - __first > *__gbeg)
02249 {
02250 __s = __add_grouping(__s, __sep,
02251 (__gbeg + 1 == __gend ? __gbeg : __gbeg + 1),
02252 __gend, __first, __last - *__gbeg);
02253 __first = __last - *__gbeg;
02254 *__s++ = __sep;
02255 }
02256 do
02257 *__s++ = *__first++;
02258 while (__first != __last);
02259 return __s;
02260 }
02261
02262 #if 1
02263
02264 template<typename _CharT, typename _OutIter>
02265 template<typename _ValueT>
02266 _OutIter
02267 num_put<_CharT, _OutIter>::
02268 _M_convert_int(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
02269 char __modl, _ValueT __v) const
02270 {
02271
02272
02273
02274 char __fbuf[16];
02275 _S_format_int(__io, __fbuf, __mod, __modl);
02276 #ifdef _GLIBCPP_USE_C99
02277
02278 int __cs_size = 64;
02279 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
02280 int __len = __convert_from_v(__cs, __cs_size, __fbuf, __v,
02281 _S_c_locale);
02282
02283 if (__len >= __cs_size)
02284 {
02285 __cs_size = __len + 1;
02286 __cs = static_cast<char*>(__builtin_alloca(__cs_size));
02287 __len = __convert_from_v(__cs, __cs_size, __fbuf, __v,
02288 _S_c_locale);
02289 }
02290 #else
02291
02292
02293 char __cs[128];
02294 int __len = __convert_from_v(__cs, 0, __fbuf, __v, _S_c_locale);
02295 #endif
02296 return _M_widen_int(__s, __io, __fill, __cs, __len);
02297 }
02298
02299 template<typename _CharT, typename _OutIter>
02300 _OutIter
02301 num_put<_CharT, _OutIter>::
02302 _M_widen_float(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs,
02303 int __len) const
02304 {
02305 typedef char_traits<_CharT> __traits_type;
02306
02307
02308 const locale __loc = __io.getloc();
02309 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
02310 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
02311 * __len));
02312
02313
02314 _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
02315 * __len * 2));
02316 __ctype.widen(__cs, __cs + __len, __ws);
02317
02318
02319 const _CharT* __p;
02320 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
02321 if (__p = __traits_type::find(__ws, __len, __ctype.widen('.')))
02322 __ws[__p - __ws] = __np.decimal_point();
02323
02324 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
02325
02326
02327 const string __grouping = __np.grouping();
02328 if (__grouping.size())
02329 {
02330 _CharT* __p2;
02331 int __declen = __p ? __p - __ws : __len;
02332 __p2 = __add_grouping(__ws2, __np.thousands_sep(),
02333 __grouping.c_str(),
02334 __grouping.c_str() + __grouping.size(),
02335 __ws, __ws + __declen);
02336 int __newlen = __p2 - __ws2;
02337
02338
02339 if (__p)
02340 {
02341 __traits_type::copy(__p2, __p, __len - __declen);
02342 __newlen += __len - __declen;
02343 }
02344
02345
02346 __ws = __ws2;
02347 __len = __newlen;
02348 }
02349 #endif
02350 return _M_insert(__s, __io, __fill, __ws, __len);
02351 }
02352
02353 template<typename _CharT, typename _OutIter>
02354 _OutIter
02355 num_put<_CharT, _OutIter>::
02356 _M_widen_int(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs,
02357 int __len) const
02358 {
02359
02360
02361 const locale __loc = __io.getloc();
02362 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
02363 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
02364 * __len));
02365
02366
02367 _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
02368 * __len * 2));
02369 __ctype.widen(__cs, __cs + __len, __ws);
02370
02371
02372 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
02373 const string __grouping = __np.grouping();
02374 if (__grouping.size())
02375 {
02376
02377
02378
02379
02380
02381 streamsize __off = 0;
02382 const ios_base::fmtflags __basefield = __io.flags()
02383 & ios_base::basefield;
02384 if ((__io.flags() & ios_base::showbase) && __len > 1)
02385 if (__basefield == ios_base::oct)
02386 {
02387 __off = 1;
02388 *__ws2 = *__ws;
02389 }
02390 else if (__basefield == ios_base::hex)
02391 {
02392 __off = 2;
02393 *__ws2 = *__ws;
02394 *(__ws2 + 1) = *(__ws + 1);
02395 }
02396 _CharT* __p;
02397 __p = __add_grouping(__ws2 + __off, __np.thousands_sep(),
02398 __grouping.c_str(),
02399 __grouping.c_str() + __grouping.size(),
02400 __ws + __off, __ws + __len);
02401 __len = __p - __ws2;
02402
02403 __ws = __ws2;
02404 }
02405 return _M_insert(__s, __io, __fill, __ws, __len);
02406 }
02407
02408
02409
02410 template<typename _CharT, typename _OutIter>
02411 _OutIter
02412 num_put<_CharT, _OutIter>::
02413 _M_insert(_OutIter __s, ios_base& __io, _CharT __fill, const _CharT* __ws,
02414 int __len) const
02415 {
02416 typedef char_traits<_CharT> __traits_type;
02417
02418
02419 streamsize __w = __io.width();
02420 _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
02421 * __w));
02422 if (__w > static_cast<streamsize>(__len))
02423 {
02424 __pad<_CharT, __traits_type>::_S_pad(__io, __fill, __ws2, __ws,
02425 __w, __len, true);
02426 __len = static_cast<int>(__w);
02427
02428 __ws = __ws2;
02429 }
02430 __io.width(0);
02431
02432
02433
02434 return __write(__s, __ws, __len);
02435 }
02436 #endif
02437
02438 template<typename _CharT>
02439 __locale_cache<numpunct<_CharT> >::__locale_cache(const locale& __loc)
02440 : _M_truename(0), _M_falsename(0), _M_use_grouping(false),
02441 _M_grouping(0)
02442 {
02443 if (has_facet<numpunct<_CharT> >(__loc))
02444 {
02445 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
02446 _M_decimal_point = __np.decimal_point();
02447 _M_thousands_sep = __np.thousands_sep();
02448
02449 string_type __false = __np.falsename();
02450 _CharT* __falsename = new _CharT[__false.length() + 1];
02451 __false.copy(__falsename, __false.length());
02452 __falsename[__false.length()] = _CharT();
02453 _M_falsename = __falsename;
02454
02455 string_type __true = __np.truename();
02456 _CharT* __truename = new _CharT[__true.length() + 1];
02457 __true.copy(__truename, __true.length());
02458 __truename[__true.length()] = _CharT();
02459 _M_truename = __truename;
02460
02461 string __grouping = __np.grouping();
02462 char* __group = new char[__grouping.length() + 1];
02463 __grouping.copy(__group, __grouping.length());
02464 __group[__grouping.length()] = 0;
02465 _M_grouping = __group;
02466
02467 _M_use_grouping = __grouping.length() != 0
02468 && __grouping.data()[0] != 0;
02469 }
02470
02471 if (has_facet<ctype<_CharT> >(__loc))
02472 {
02473 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
02474 __ct.widen(__num_base::_S_atoms_out,
02475 __num_base::_S_atoms_out + __num_base::_S_end,
02476 _M_atoms_out);
02477 }
02478 }
02479
02480
02481
02482 template<typename _CharT>
02483 __locale_cache<numpunct<_CharT> >::
02484 __locale_cache(const locale& __loc, bool)
02485 {
02486
02487 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
02488 _M_thousands_sep = __np._M_thousands_sep;
02489 _M_decimal_point = __np._M_decimal_point;
02490 _M_falsename = __np._M_falsename;
02491 _M_truename = __np._M_truename;
02492 _M_grouping = __np._M_grouping;
02493 _M_use_grouping = false;
02494
02495 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
02496 __ct.widen(__num_base::_S_atoms_out,
02497 __num_base::_S_atoms_out + __num_base::_S_end,
02498 _M_atoms_out);
02499 }
02500
02501
02502
02503
02504 #if _GLIBCPP_EXTERN_TEMPLATE
02505 extern template class moneypunct<char, false>;
02506 extern template class moneypunct<char, true>;
02507 extern template class moneypunct_byname<char, false>;
02508 extern template class moneypunct_byname<char, true>;
02509 extern template class money_get<char>;
02510 extern template class money_put<char>;
02511 extern template class numpunct<char>;
02512 extern template class numpunct_byname<char>;
02513 extern template class num_get<char>;
02514 extern template class num_put<char>;
02515 extern template class __timepunct<char>;
02516 extern template class time_put<char>;
02517 extern template class time_put_byname<char>;
02518 extern template class time_get<char>;
02519 extern template class time_get_byname<char>;
02520 extern template class messages<char>;
02521 extern template class messages_byname<char>;
02522 extern template class ctype_byname<char>;
02523 extern template class codecvt_byname<char, char, mbstate_t>;
02524 extern template class collate<char>;
02525 extern template class collate_byname<char>;
02526
02527 extern template
02528 const codecvt<char, char, mbstate_t>&
02529 use_facet<codecvt<char, char, mbstate_t> >(const locale&);
02530
02531 extern template
02532 const collate<char>&
02533 use_facet<collate<char> >(const locale&);
02534
02535 extern template
02536 const numpunct<char>&
02537 use_facet<numpunct<char> >(const locale&);
02538
02539 extern template
02540 const num_put<char>&
02541 use_facet<num_put<char> >(const locale&);
02542
02543 extern template
02544 const num_get<char>&
02545 use_facet<num_get<char> >(const locale&);
02546
02547 extern template
02548 const moneypunct<char, true>&
02549 use_facet<moneypunct<char, true> >(const locale&);
02550
02551 extern template
02552 const moneypunct<char, false>&
02553 use_facet<moneypunct<char, false> >(const locale&);
02554
02555 extern template
02556 const money_put<char>&
02557 use_facet<money_put<char> >(const locale&);
02558
02559 extern template
02560 const money_get<char>&
02561 use_facet<money_get<char> >(const locale&);
02562
02563 extern template
02564 const __timepunct<char>&
02565 use_facet<__timepunct<char> >(const locale&);
02566
02567 extern template
02568 const time_put<char>&
02569 use_facet<time_put<char> >(const locale&);
02570
02571 extern template
02572 const time_get<char>&
02573 use_facet<time_get<char> >(const locale&);
02574
02575 extern template
02576 const messages<char>&
02577 use_facet<messages<char> >(const locale&);
02578
02579 extern template
02580 bool
02581 has_facet<ctype<char> >(const locale&);
02582
02583 extern template
02584 bool
02585 has_facet<codecvt<char, char, mbstate_t> >(const locale&);
02586
02587 extern template
02588 bool
02589 has_facet<collate<char> >(const locale&);
02590
02591 extern template
02592 bool
02593 has_facet<numpunct<char> >(const locale&);
02594
02595 extern template
02596 bool
02597 has_facet<num_put<char> >(const locale&);
02598
02599 extern template
02600 bool
02601 has_facet<num_get<char> >(const locale&);
02602
02603 extern template
02604 bool
02605 has_facet<moneypunct<char> >(const locale&);
02606
02607 extern template
02608 bool
02609 has_facet<money_put<char> >(const locale&);
02610
02611 extern template
02612 bool
02613 has_facet<money_get<char> >(const locale&);
02614
02615 extern template
02616 bool
02617 has_facet<__timepunct<char> >(const locale&);
02618
02619 extern template
02620 bool
02621 has_facet<time_put<char> >(const locale&);
02622
02623 extern template
02624 bool
02625 has_facet<time_get<char> >(const locale&);
02626
02627 extern template
02628 bool
02629 has_facet<messages<char> >(const locale&);
02630
02631 #ifdef _GLIBCPP_USE_WCHAR_T
02632 extern template class moneypunct<wchar_t, false>;
02633 extern template class moneypunct<wchar_t, true>;
02634 extern template class moneypunct_byname<wchar_t, false>;
02635 extern template class moneypunct_byname<wchar_t, true>;
02636 extern template class money_get<wchar_t>;
02637 extern template class money_put<wchar_t>;
02638 extern template class numpunct<wchar_t>;
02639 extern template class numpunct_byname<wchar_t>;
02640 extern template class num_get<wchar_t>;
02641 extern template class num_put<wchar_t>;
02642 extern template class __timepunct<wchar_t>;
02643 extern template class time_put<wchar_t>;
02644 extern template class time_put_byname<wchar_t>;
02645 extern template class time_get<wchar_t>;
02646 extern template class time_get_byname<wchar_t>;
02647 extern template class messages<wchar_t>;
02648 extern template class messages_byname<wchar_t>;
02649 extern template class ctype_byname<wchar_t>;
02650 extern template class codecvt_byname<wchar_t, char, mbstate_t>;
02651 extern template class collate<wchar_t>;
02652 extern template class collate_byname<wchar_t>;
02653
02654 extern template
02655 const codecvt<wchar_t, char, mbstate_t>&
02656 use_facet<codecvt<wchar_t, char, mbstate_t> >(locale const&);
02657
02658 extern template
02659 const collate<wchar_t>&
02660 use_facet<collate<wchar_t> >(const locale&);
02661
02662 extern template
02663 const numpunct<wchar_t>&
02664 use_facet<numpunct<wchar_t> >(const locale&);
02665
02666 extern template
02667 const num_put<wchar_t>&
02668 use_facet<num_put<wchar_t> >(const locale&);
02669
02670 extern template
02671 const num_get<wchar_t>&
02672 use_facet<num_get<wchar_t> >(const locale&);
02673
02674 extern template
02675 const moneypunct<wchar_t, true>&
02676 use_facet<moneypunct<wchar_t, true> >(const locale&);
02677
02678 extern template
02679 const moneypunct<wchar_t, false>&
02680 use_facet<moneypunct<wchar_t, false> >(const locale&);
02681
02682 extern template
02683 const money_put<wchar_t>&
02684 use_facet<money_put<wchar_t> >(const locale&);
02685
02686 extern template
02687 const money_get<wchar_t>&
02688 use_facet<money_get<wchar_t> >(const locale&);
02689
02690 extern template
02691 const __timepunct<wchar_t>&
02692 use_facet<__timepunct<wchar_t> >(const locale&);
02693
02694 extern template
02695 const time_put<wchar_t>&
02696 use_facet<time_put<wchar_t> >(const locale&);
02697
02698 extern template
02699 const time_get<wchar_t>&
02700 use_facet<time_get<wchar_t> >(const locale&);
02701
02702 extern template
02703 const messages<wchar_t>&
02704 use_facet<messages<wchar_t> >(const locale&);
02705
02706 extern template
02707 bool
02708 has_facet<ctype<wchar_t> >(const locale&);
02709
02710 extern template
02711 bool
02712 has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
02713
02714 extern template
02715 bool
02716 has_facet<collate<wchar_t> >(const locale&);
02717
02718 extern template
02719 bool
02720 has_facet<numpunct<wchar_t> >(const locale&);
02721
02722 extern template
02723 bool
02724 has_facet<num_put<wchar_t> >(const locale&);
02725
02726 extern template
02727 bool
02728 has_facet<num_get<wchar_t> >(const locale&);
02729
02730 extern template
02731 bool
02732 has_facet<moneypunct<wchar_t> >(const locale&);
02733
02734 extern template
02735 bool
02736 has_facet<money_put<wchar_t> >(const locale&);
02737
02738 extern template
02739 bool
02740 has_facet<money_get<wchar_t> >(const locale&);
02741
02742 extern template
02743 bool
02744 has_facet<__timepunct<wchar_t> >(const locale&);
02745
02746 extern template
02747 bool
02748 has_facet<time_put<wchar_t> >(const locale&);
02749
02750 extern template
02751 bool
02752 has_facet<time_get<wchar_t> >(const locale&);
02753
02754 extern template
02755 bool
02756 has_facet<messages<wchar_t> >(const locale&);
02757 #endif
02758 #endif
02759 }
02760
02761 #endif