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