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 #ifndef _LOCALE_FACETS_NONIO_TCC
00031 #define _LOCALE_FACETS_NONIO_TCC 1
00032
00033 #pragma GCC system_header
00034
00035 _GLIBCXX_BEGIN_NAMESPACE(std)
00036
00037 template<typename _CharT, bool _Intl>
00038 struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
00039 {
00040 const __moneypunct_cache<_CharT, _Intl>*
00041 operator() (const locale& __loc) const
00042 {
00043 const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
00044 const locale::facet** __caches = __loc._M_impl->_M_caches;
00045 if (!__caches[__i])
00046 {
00047 __moneypunct_cache<_CharT, _Intl>* __tmp = NULL;
00048 __try
00049 {
00050 __tmp = new __moneypunct_cache<_CharT, _Intl>;
00051 __tmp->_M_cache(__loc);
00052 }
00053 __catch(...)
00054 {
00055 delete __tmp;
00056 __throw_exception_again;
00057 }
00058 __loc._M_impl->_M_install_cache(__tmp, __i);
00059 }
00060 return static_cast<
00061 const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
00062 }
00063 };
00064
00065 template<typename _CharT, bool _Intl>
00066 void
00067 __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
00068 {
00069 _M_allocated = true;
00070
00071 const moneypunct<_CharT, _Intl>& __mp =
00072 use_facet<moneypunct<_CharT, _Intl> >(__loc);
00073
00074 _M_grouping_size = __mp.grouping().size();
00075 char* __grouping = new char[_M_grouping_size];
00076 __mp.grouping().copy(__grouping, _M_grouping_size);
00077 _M_grouping = __grouping;
00078 _M_use_grouping = (_M_grouping_size
00079 && static_cast<signed char>(_M_grouping[0]) > 0
00080 && (_M_grouping[0]
00081 != __gnu_cxx::__numeric_traits<char>::__max));
00082
00083 _M_decimal_point = __mp.decimal_point();
00084 _M_thousands_sep = __mp.thousands_sep();
00085 _M_frac_digits = __mp.frac_digits();
00086
00087 _M_curr_symbol_size = __mp.curr_symbol().size();
00088 _CharT* __curr_symbol = new _CharT[_M_curr_symbol_size];
00089 __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
00090 _M_curr_symbol = __curr_symbol;
00091
00092 _M_positive_sign_size = __mp.positive_sign().size();
00093 _CharT* __positive_sign = new _CharT[_M_positive_sign_size];
00094 __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
00095 _M_positive_sign = __positive_sign;
00096
00097 _M_negative_sign_size = __mp.negative_sign().size();
00098 _CharT* __negative_sign = new _CharT[_M_negative_sign_size];
00099 __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
00100 _M_negative_sign = __negative_sign;
00101
00102 _M_pos_format = __mp.pos_format();
00103 _M_neg_format = __mp.neg_format();
00104
00105 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
00106 __ct.widen(money_base::_S_atoms,
00107 money_base::_S_atoms + money_base::_S_end, _M_atoms);
00108 }
00109
00110 _GLIBCXX_BEGIN_LDBL_NAMESPACE
00111
00112 template<typename _CharT, typename _InIter>
00113 template<bool _Intl>
00114 _InIter
00115 money_get<_CharT, _InIter>::
00116 _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
00117 ios_base::iostate& __err, string& __units) const
00118 {
00119 typedef char_traits<_CharT> __traits_type;
00120 typedef typename string_type::size_type size_type;
00121 typedef money_base::part part;
00122 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
00123
00124 const locale& __loc = __io._M_getloc();
00125 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00126
00127 __use_cache<__cache_type> __uc;
00128 const __cache_type* __lc = __uc(__loc);
00129 const char_type* __lit = __lc->_M_atoms;
00130
00131
00132 bool __negative = false;
00133
00134 size_type __sign_size = 0;
00135
00136 const bool __mandatory_sign = (__lc->_M_positive_sign_size
00137 && __lc->_M_negative_sign_size);
00138
00139 string __grouping_tmp;
00140 if (__lc->_M_use_grouping)
00141 __grouping_tmp.reserve(32);
00142
00143 int __last_pos = 0;
00144
00145 int __n = 0;
00146
00147 bool __testvalid = true;
00148
00149 bool __testdecfound = false;
00150
00151
00152 string __res;
00153 __res.reserve(32);
00154
00155 const char_type* __lit_zero = __lit + money_base::_S_zero;
00156 const money_base::pattern __p = __lc->_M_neg_format;
00157 for (int __i = 0; __i < 4 && __testvalid; ++__i)
00158 {
00159 const part __which = static_cast<part>(__p.field[__i]);
00160 switch (__which)
00161 {
00162 case money_base::symbol:
00163
00164
00165
00166
00167 if (__io.flags() & ios_base::showbase || __sign_size > 1
00168 || __i == 0
00169 || (__i == 1 && (__mandatory_sign
00170 || (static_cast<part>(__p.field[0])
00171 == money_base::sign)
00172 || (static_cast<part>(__p.field[2])
00173 == money_base::space)))
00174 || (__i == 2 && ((static_cast<part>(__p.field[3])
00175 == money_base::value)
00176 || (__mandatory_sign
00177 && (static_cast<part>(__p.field[3])
00178 == money_base::sign)))))
00179 {
00180 const size_type __len = __lc->_M_curr_symbol_size;
00181 size_type __j = 0;
00182 for (; __beg != __end && __j < __len
00183 && *__beg == __lc->_M_curr_symbol[__j];
00184 ++__beg, ++__j);
00185 if (__j != __len
00186 && (__j || __io.flags() & ios_base::showbase))
00187 __testvalid = false;
00188 }
00189 break;
00190 case money_base::sign:
00191
00192 if (__lc->_M_positive_sign_size && __beg != __end
00193 && *__beg == __lc->_M_positive_sign[0])
00194 {
00195 __sign_size = __lc->_M_positive_sign_size;
00196 ++__beg;
00197 }
00198 else if (__lc->_M_negative_sign_size && __beg != __end
00199 && *__beg == __lc->_M_negative_sign[0])
00200 {
00201 __negative = true;
00202 __sign_size = __lc->_M_negative_sign_size;
00203 ++__beg;
00204 }
00205 else if (__lc->_M_positive_sign_size
00206 && !__lc->_M_negative_sign_size)
00207
00208
00209 __negative = true;
00210 else if (__mandatory_sign)
00211 __testvalid = false;
00212 break;
00213 case money_base::value:
00214
00215
00216 for (; __beg != __end; ++__beg)
00217 {
00218 const char_type __c = *__beg;
00219 const char_type* __q = __traits_type::find(__lit_zero,
00220 10, __c);
00221 if (__q != 0)
00222 {
00223 __res += money_base::_S_atoms[__q - __lit];
00224 ++__n;
00225 }
00226 else if (__c == __lc->_M_decimal_point
00227 && !__testdecfound)
00228 {
00229 if (__lc->_M_frac_digits <= 0)
00230 break;
00231
00232 __last_pos = __n;
00233 __n = 0;
00234 __testdecfound = true;
00235 }
00236 else if (__lc->_M_use_grouping
00237 && __c == __lc->_M_thousands_sep
00238 && !__testdecfound)
00239 {
00240 if (__n)
00241 {
00242
00243 __grouping_tmp += static_cast<char>(__n);
00244 __n = 0;
00245 }
00246 else
00247 {
00248 __testvalid = false;
00249 break;
00250 }
00251 }
00252 else
00253 break;
00254 }
00255 if (__res.empty())
00256 __testvalid = false;
00257 break;
00258 case money_base::space:
00259
00260 if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
00261 ++__beg;
00262 else
00263 __testvalid = false;
00264 case money_base::none:
00265
00266 if (__i != 3)
00267 for (; __beg != __end
00268 && __ctype.is(ctype_base::space, *__beg); ++__beg);
00269 break;
00270 }
00271 }
00272
00273
00274 if (__sign_size > 1 && __testvalid)
00275 {
00276 const char_type* __sign = __negative ? __lc->_M_negative_sign
00277 : __lc->_M_positive_sign;
00278 size_type __i = 1;
00279 for (; __beg != __end && __i < __sign_size
00280 && *__beg == __sign[__i]; ++__beg, ++__i);
00281
00282 if (__i != __sign_size)
00283 __testvalid = false;
00284 }
00285
00286 if (__testvalid)
00287 {
00288
00289 if (__res.size() > 1)
00290 {
00291 const size_type __first = __res.find_first_not_of('0');
00292 const bool __only_zeros = __first == string::npos;
00293 if (__first)
00294 __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
00295 }
00296
00297
00298 if (__negative && __res[0] != '0')
00299 __res.insert(__res.begin(), '-');
00300
00301
00302 if (__grouping_tmp.size())
00303 {
00304
00305 __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
00306 : __n);
00307 if (!std::__verify_grouping(__lc->_M_grouping,
00308 __lc->_M_grouping_size,
00309 __grouping_tmp))
00310 __err |= ios_base::failbit;
00311 }
00312
00313
00314 if (__testdecfound && __n != __lc->_M_frac_digits)
00315 __testvalid = false;
00316 }
00317
00318
00319 if (!__testvalid)
00320 __err |= ios_base::failbit;
00321 else
00322 __units.swap(__res);
00323
00324
00325 if (__beg == __end)
00326 __err |= ios_base::eofbit;
00327 return __beg;
00328 }
00329
00330 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
00331 template<typename _CharT, typename _InIter>
00332 _InIter
00333 money_get<_CharT, _InIter>::
00334 __do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
00335 ios_base::iostate& __err, double& __units) const
00336 {
00337 string __str;
00338 __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
00339 : _M_extract<false>(__beg, __end, __io, __err, __str);
00340 std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
00341 return __beg;
00342 }
00343 #endif
00344
00345 template<typename _CharT, typename _InIter>
00346 _InIter
00347 money_get<_CharT, _InIter>::
00348 do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
00349 ios_base::iostate& __err, long double& __units) const
00350 {
00351 string __str;
00352 __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
00353 : _M_extract<false>(__beg, __end, __io, __err, __str);
00354 std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
00355 return __beg;
00356 }
00357
00358 template<typename _CharT, typename _InIter>
00359 _InIter
00360 money_get<_CharT, _InIter>::
00361 do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
00362 ios_base::iostate& __err, string_type& __digits) const
00363 {
00364 typedef typename string::size_type size_type;
00365
00366 const locale& __loc = __io._M_getloc();
00367 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00368
00369 string __str;
00370 __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
00371 : _M_extract<false>(__beg, __end, __io, __err, __str);
00372 const size_type __len = __str.size();
00373 if (__len)
00374 {
00375 __digits.resize(__len);
00376 __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
00377 }
00378 return __beg;
00379 }
00380
00381 template<typename _CharT, typename _OutIter>
00382 template<bool _Intl>
00383 _OutIter
00384 money_put<_CharT, _OutIter>::
00385 _M_insert(iter_type __s, ios_base& __io, char_type __fill,
00386 const string_type& __digits) const
00387 {
00388 typedef typename string_type::size_type size_type;
00389 typedef money_base::part part;
00390 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
00391
00392 const locale& __loc = __io._M_getloc();
00393 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00394
00395 __use_cache<__cache_type> __uc;
00396 const __cache_type* __lc = __uc(__loc);
00397 const char_type* __lit = __lc->_M_atoms;
00398
00399
00400
00401 const char_type* __beg = __digits.data();
00402
00403 money_base::pattern __p;
00404 const char_type* __sign;
00405 size_type __sign_size;
00406 if (!(*__beg == __lit[money_base::_S_minus]))
00407 {
00408 __p = __lc->_M_pos_format;
00409 __sign = __lc->_M_positive_sign;
00410 __sign_size = __lc->_M_positive_sign_size;
00411 }
00412 else
00413 {
00414 __p = __lc->_M_neg_format;
00415 __sign = __lc->_M_negative_sign;
00416 __sign_size = __lc->_M_negative_sign_size;
00417 if (__digits.size())
00418 ++__beg;
00419 }
00420
00421
00422 size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
00423 __beg + __digits.size()) - __beg;
00424 if (__len)
00425 {
00426
00427
00428
00429 string_type __value;
00430 __value.reserve(2 * __len);
00431
00432
00433
00434 long __paddec = __len - __lc->_M_frac_digits;
00435 if (__paddec > 0)
00436 {
00437 if (__lc->_M_frac_digits < 0)
00438 __paddec = __len;
00439 if (__lc->_M_grouping_size)
00440 {
00441 __value.assign(2 * __paddec, char_type());
00442 _CharT* __vend =
00443 std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
00444 __lc->_M_grouping,
00445 __lc->_M_grouping_size,
00446 __beg, __beg + __paddec);
00447 __value.erase(__vend - &__value[0]);
00448 }
00449 else
00450 __value.assign(__beg, __paddec);
00451 }
00452
00453
00454 if (__lc->_M_frac_digits > 0)
00455 {
00456 __value += __lc->_M_decimal_point;
00457 if (__paddec >= 0)
00458 __value.append(__beg + __paddec, __lc->_M_frac_digits);
00459 else
00460 {
00461
00462 __value.append(-__paddec, __lit[money_base::_S_zero]);
00463 __value.append(__beg, __len);
00464 }
00465 }
00466
00467
00468 const ios_base::fmtflags __f = __io.flags()
00469 & ios_base::adjustfield;
00470 __len = __value.size() + __sign_size;
00471 __len += ((__io.flags() & ios_base::showbase)
00472 ? __lc->_M_curr_symbol_size : 0);
00473
00474 string_type __res;
00475 __res.reserve(2 * __len);
00476
00477 const size_type __width = static_cast<size_type>(__io.width());
00478 const bool __testipad = (__f == ios_base::internal
00479 && __len < __width);
00480
00481 for (int __i = 0; __i < 4; ++__i)
00482 {
00483 const part __which = static_cast<part>(__p.field[__i]);
00484 switch (__which)
00485 {
00486 case money_base::symbol:
00487 if (__io.flags() & ios_base::showbase)
00488 __res.append(__lc->_M_curr_symbol,
00489 __lc->_M_curr_symbol_size);
00490 break;
00491 case money_base::sign:
00492
00493
00494
00495 if (__sign_size)
00496 __res += __sign[0];
00497 break;
00498 case money_base::value:
00499 __res += __value;
00500 break;
00501 case money_base::space:
00502
00503
00504
00505 if (__testipad)
00506 __res.append(__width - __len, __fill);
00507 else
00508 __res += __fill;
00509 break;
00510 case money_base::none:
00511 if (__testipad)
00512 __res.append(__width - __len, __fill);
00513 break;
00514 }
00515 }
00516
00517
00518 if (__sign_size > 1)
00519 __res.append(__sign + 1, __sign_size - 1);
00520
00521
00522 __len = __res.size();
00523 if (__width > __len)
00524 {
00525 if (__f == ios_base::left)
00526
00527 __res.append(__width - __len, __fill);
00528 else
00529
00530 __res.insert(0, __width - __len, __fill);
00531 __len = __width;
00532 }
00533
00534
00535 __s = std::__write(__s, __res.data(), __len);
00536 }
00537 __io.width(0);
00538 return __s;
00539 }
00540
00541 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
00542 template<typename _CharT, typename _OutIter>
00543 _OutIter
00544 money_put<_CharT, _OutIter>::
00545 __do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
00546 double __units) const
00547 { return this->do_put(__s, __intl, __io, __fill, (long double) __units); }
00548 #endif
00549
00550 template<typename _CharT, typename _OutIter>
00551 _OutIter
00552 money_put<_CharT, _OutIter>::
00553 do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
00554 long double __units) const
00555 {
00556 const locale __loc = __io.getloc();
00557 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00558 #ifdef _GLIBCXX_USE_C99
00559
00560 int __cs_size = 64;
00561 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
00562
00563
00564 int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
00565 "%.*Lf", 0, __units);
00566
00567 if (__len >= __cs_size)
00568 {
00569 __cs_size = __len + 1;
00570 __cs = static_cast<char*>(__builtin_alloca(__cs_size));
00571 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
00572 "%.*Lf", 0, __units);
00573 }
00574 #else
00575
00576 const int __cs_size =
00577 __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 3;
00578 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
00579 int __len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, "%.*Lf",
00580 0, __units);
00581 #endif
00582 string_type __digits(__len, char_type());
00583 __ctype.widen(__cs, __cs + __len, &__digits[0]);
00584 return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
00585 : _M_insert<false>(__s, __io, __fill, __digits);
00586 }
00587
00588 template<typename _CharT, typename _OutIter>
00589 _OutIter
00590 money_put<_CharT, _OutIter>::
00591 do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
00592 const string_type& __digits) const
00593 { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
00594 : _M_insert<false>(__s, __io, __fill, __digits); }
00595
00596 _GLIBCXX_END_LDBL_NAMESPACE
00597
00598
00599
00600
00601 template<typename _CharT, typename _InIter>
00602 time_base::dateorder
00603 time_get<_CharT, _InIter>::do_date_order() const
00604 { return time_base::no_order; }
00605
00606
00607
00608 template<typename _CharT, typename _InIter>
00609 _InIter
00610 time_get<_CharT, _InIter>::
00611 _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
00612 ios_base::iostate& __err, tm* __tm,
00613 const _CharT* __format) const
00614 {
00615 const locale& __loc = __io._M_getloc();
00616 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
00617 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00618 const size_t __len = char_traits<_CharT>::length(__format);
00619
00620 ios_base::iostate __tmperr = ios_base::goodbit;
00621 for (size_t __i = 0; __beg != __end && __i < __len && !__tmperr; ++__i)
00622 {
00623 if (__ctype.narrow(__format[__i], 0) == '%')
00624 {
00625
00626 char __c = __ctype.narrow(__format[++__i], 0);
00627 int __mem = 0;
00628 if (__c == 'E' || __c == 'O')
00629 __c = __ctype.narrow(__format[++__i], 0);
00630 switch (__c)
00631 {
00632 const char* __cs;
00633 _CharT __wcs[10];
00634 case 'a':
00635
00636 const char_type* __days1[7];
00637 __tp._M_days_abbreviated(__days1);
00638 __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
00639 7, __io, __tmperr);
00640 break;
00641 case 'A':
00642
00643 const char_type* __days2[7];
00644 __tp._M_days(__days2);
00645 __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
00646 7, __io, __tmperr);
00647 break;
00648 case 'h':
00649 case 'b':
00650
00651 const char_type* __months1[12];
00652 __tp._M_months_abbreviated(__months1);
00653 __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
00654 __months1, 12, __io, __tmperr);
00655 break;
00656 case 'B':
00657
00658 const char_type* __months2[12];
00659 __tp._M_months(__months2);
00660 __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
00661 __months2, 12, __io, __tmperr);
00662 break;
00663 case 'c':
00664
00665 const char_type* __dt[2];
00666 __tp._M_date_time_formats(__dt);
00667 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
00668 __tm, __dt[0]);
00669 break;
00670 case 'd':
00671
00672 __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
00673 __io, __tmperr);
00674 break;
00675 case 'e':
00676
00677
00678 if (__ctype.is(ctype_base::space, *__beg))
00679 __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
00680 1, __io, __tmperr);
00681 else
00682 __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
00683 2, __io, __tmperr);
00684 break;
00685 case 'D':
00686
00687 __cs = "%m/%d/%y";
00688 __ctype.widen(__cs, __cs + 9, __wcs);
00689 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
00690 __tm, __wcs);
00691 break;
00692 case 'H':
00693
00694 __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
00695 __io, __tmperr);
00696 break;
00697 case 'I':
00698
00699 __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
00700 __io, __tmperr);
00701 break;
00702 case 'm':
00703
00704 __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
00705 __io, __tmperr);
00706 if (!__tmperr)
00707 __tm->tm_mon = __mem - 1;
00708 break;
00709 case 'M':
00710
00711 __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
00712 __io, __tmperr);
00713 break;
00714 case 'n':
00715 if (__ctype.narrow(*__beg, 0) == '\n')
00716 ++__beg;
00717 else
00718 __tmperr |= ios_base::failbit;
00719 break;
00720 case 'R':
00721
00722 __cs = "%H:%M";
00723 __ctype.widen(__cs, __cs + 6, __wcs);
00724 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
00725 __tm, __wcs);
00726 break;
00727 case 'S':
00728
00729
00730 #ifdef _GLIBCXX_USE_C99
00731 __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
00732 #else
00733 __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 61, 2,
00734 #endif
00735 __io, __tmperr);
00736 break;
00737 case 't':
00738 if (__ctype.narrow(*__beg, 0) == '\t')
00739 ++__beg;
00740 else
00741 __tmperr |= ios_base::failbit;
00742 break;
00743 case 'T':
00744
00745 __cs = "%H:%M:%S";
00746 __ctype.widen(__cs, __cs + 9, __wcs);
00747 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
00748 __tm, __wcs);
00749 break;
00750 case 'x':
00751
00752 const char_type* __dates[2];
00753 __tp._M_date_formats(__dates);
00754 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
00755 __tm, __dates[0]);
00756 break;
00757 case 'X':
00758
00759 const char_type* __times[2];
00760 __tp._M_time_formats(__times);
00761 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
00762 __tm, __times[0]);
00763 break;
00764 case 'y':
00765 case 'C':
00766
00767 __beg = _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2,
00768 __io, __tmperr);
00769 break;
00770 case 'Y':
00771
00772 __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
00773 __io, __tmperr);
00774 if (!__tmperr)
00775 __tm->tm_year = __mem - 1900;
00776 break;
00777 case 'Z':
00778
00779 if (__ctype.is(ctype_base::upper, *__beg))
00780 {
00781 int __tmp;
00782 __beg = _M_extract_name(__beg, __end, __tmp,
00783 __timepunct_cache<_CharT>::_S_timezones,
00784 14, __io, __tmperr);
00785
00786
00787 if (__beg != __end && !__tmperr && __tmp == 0
00788 && (*__beg == __ctype.widen('-')
00789 || *__beg == __ctype.widen('+')))
00790 {
00791 __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
00792 __io, __tmperr);
00793 __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
00794 __io, __tmperr);
00795 }
00796 }
00797 else
00798 __tmperr |= ios_base::failbit;
00799 break;
00800 default:
00801
00802 __tmperr |= ios_base::failbit;
00803 }
00804 }
00805 else
00806 {
00807
00808 if (__format[__i] == *__beg)
00809 ++__beg;
00810 else
00811 __tmperr |= ios_base::failbit;
00812 }
00813 }
00814
00815 if (__tmperr)
00816 __err |= ios_base::failbit;
00817
00818 return __beg;
00819 }
00820
00821 template<typename _CharT, typename _InIter>
00822 _InIter
00823 time_get<_CharT, _InIter>::
00824 _M_extract_num(iter_type __beg, iter_type __end, int& __member,
00825 int __min, int __max, size_t __len,
00826 ios_base& __io, ios_base::iostate& __err) const
00827 {
00828 const locale& __loc = __io._M_getloc();
00829 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00830
00831
00832 int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
00833
00834 ++__min;
00835 size_t __i = 0;
00836 int __value = 0;
00837 for (; __beg != __end && __i < __len; ++__beg, ++__i)
00838 {
00839 const char __c = __ctype.narrow(*__beg, '*');
00840 if (__c >= '0' && __c <= '9')
00841 {
00842 __value = __value * 10 + (__c - '0');
00843 const int __valuec = __value * __mult;
00844 if (__valuec > __max || __valuec + __mult < __min)
00845 break;
00846 __mult /= 10;
00847 }
00848 else
00849 break;
00850 }
00851 if (__i == __len)
00852 __member = __value;
00853 else
00854 __err |= ios_base::failbit;
00855
00856 return __beg;
00857 }
00858
00859
00860
00861 template<typename _CharT, typename _InIter>
00862 _InIter
00863 time_get<_CharT, _InIter>::
00864 _M_extract_name(iter_type __beg, iter_type __end, int& __member,
00865 const _CharT** __names, size_t __indexlen,
00866 ios_base& __io, ios_base::iostate& __err) const
00867 {
00868 typedef char_traits<_CharT> __traits_type;
00869 const locale& __loc = __io._M_getloc();
00870 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00871
00872 int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
00873 * __indexlen));
00874 size_t __nmatches = 0;
00875 size_t __pos = 0;
00876 bool __testvalid = true;
00877 const char_type* __name;
00878
00879
00880
00881
00882
00883 if (__beg != __end)
00884 {
00885 const char_type __c = *__beg;
00886 for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
00887 if (__c == __names[__i1][0]
00888 || __c == __ctype.toupper(__names[__i1][0]))
00889 __matches[__nmatches++] = __i1;
00890 }
00891
00892 while (__nmatches > 1)
00893 {
00894
00895 size_t __minlen = __traits_type::length(__names[__matches[0]]);
00896 for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
00897 __minlen = std::min(__minlen,
00898 __traits_type::length(__names[__matches[__i2]]));
00899 ++__beg, ++__pos;
00900 if (__pos < __minlen && __beg != __end)
00901 for (size_t __i3 = 0; __i3 < __nmatches;)
00902 {
00903 __name = __names[__matches[__i3]];
00904 if (!(__name[__pos] == *__beg))
00905 __matches[__i3] = __matches[--__nmatches];
00906 else
00907 ++__i3;
00908 }
00909 else
00910 break;
00911 }
00912
00913 if (__nmatches == 1)
00914 {
00915
00916 ++__beg, ++__pos;
00917 __name = __names[__matches[0]];
00918 const size_t __len = __traits_type::length(__name);
00919 while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
00920 ++__beg, ++__pos;
00921
00922 if (__len == __pos)
00923 __member = __matches[0];
00924 else
00925 __testvalid = false;
00926 }
00927 else
00928 __testvalid = false;
00929 if (!__testvalid)
00930 __err |= ios_base::failbit;
00931
00932 return __beg;
00933 }
00934
00935 template<typename _CharT, typename _InIter>
00936 _InIter
00937 time_get<_CharT, _InIter>::
00938 do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
00939 ios_base::iostate& __err, tm* __tm) const
00940 {
00941 const locale& __loc = __io._M_getloc();
00942 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
00943 const char_type* __times[2];
00944 __tp._M_time_formats(__times);
00945 __beg = _M_extract_via_format(__beg, __end, __io, __err,
00946 __tm, __times[0]);
00947 if (__beg == __end)
00948 __err |= ios_base::eofbit;
00949 return __beg;
00950 }
00951
00952 template<typename _CharT, typename _InIter>
00953 _InIter
00954 time_get<_CharT, _InIter>::
00955 do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
00956 ios_base::iostate& __err, tm* __tm) const
00957 {
00958 const locale& __loc = __io._M_getloc();
00959 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
00960 const char_type* __dates[2];
00961 __tp._M_date_formats(__dates);
00962 __beg = _M_extract_via_format(__beg, __end, __io, __err,
00963 __tm, __dates[0]);
00964 if (__beg == __end)
00965 __err |= ios_base::eofbit;
00966 return __beg;
00967 }
00968
00969 template<typename _CharT, typename _InIter>
00970 _InIter
00971 time_get<_CharT, _InIter>::
00972 do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
00973 ios_base::iostate& __err, tm* __tm) const
00974 {
00975 typedef char_traits<_CharT> __traits_type;
00976 const locale& __loc = __io._M_getloc();
00977 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
00978 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00979 const char_type* __days[7];
00980 __tp._M_days_abbreviated(__days);
00981 int __tmpwday;
00982 ios_base::iostate __tmperr = ios_base::goodbit;
00983 __beg = _M_extract_name(__beg, __end, __tmpwday, __days, 7,
00984 __io, __tmperr);
00985
00986
00987
00988
00989
00990
00991
00992 if (!__tmperr && __beg != __end)
00993 {
00994 size_t __pos = __traits_type::length(__days[__tmpwday]);
00995 __tp._M_days(__days);
00996 const char_type* __name = __days[__tmpwday];
00997 if (__name[__pos] == *__beg)
00998 {
00999
01000 const size_t __len = __traits_type::length(__name);
01001 while (__pos < __len && __beg != __end
01002 && __name[__pos] == *__beg)
01003 ++__beg, ++__pos;
01004 if (__len != __pos)
01005 __tmperr |= ios_base::failbit;
01006 }
01007 }
01008 if (!__tmperr)
01009 __tm->tm_wday = __tmpwday;
01010 else
01011 __err |= ios_base::failbit;
01012
01013 if (__beg == __end)
01014 __err |= ios_base::eofbit;
01015 return __beg;
01016 }
01017
01018 template<typename _CharT, typename _InIter>
01019 _InIter
01020 time_get<_CharT, _InIter>::
01021 do_get_monthname(iter_type __beg, iter_type __end,
01022 ios_base& __io, ios_base::iostate& __err, tm* __tm) const
01023 {
01024 typedef char_traits<_CharT> __traits_type;
01025 const locale& __loc = __io._M_getloc();
01026 const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
01027 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
01028 const char_type* __months[12];
01029 __tp._M_months_abbreviated(__months);
01030 int __tmpmon;
01031 ios_base::iostate __tmperr = ios_base::goodbit;
01032 __beg = _M_extract_name(__beg, __end, __tmpmon, __months, 12,
01033 __io, __tmperr);
01034
01035
01036
01037
01038
01039
01040
01041 if (!__tmperr && __beg != __end)
01042 {
01043 size_t __pos = __traits_type::length(__months[__tmpmon]);
01044 __tp._M_months(__months);
01045 const char_type* __name = __months[__tmpmon];
01046 if (__name[__pos] == *__beg)
01047 {
01048
01049 const size_t __len = __traits_type::length(__name);
01050 while (__pos < __len && __beg != __end
01051 && __name[__pos] == *__beg)
01052 ++__beg, ++__pos;
01053 if (__len != __pos)
01054 __tmperr |= ios_base::failbit;
01055 }
01056 }
01057 if (!__tmperr)
01058 __tm->tm_mon = __tmpmon;
01059 else
01060 __err |= ios_base::failbit;
01061
01062 if (__beg == __end)
01063 __err |= ios_base::eofbit;
01064 return __beg;
01065 }
01066
01067 template<typename _CharT, typename _InIter>
01068 _InIter
01069 time_get<_CharT, _InIter>::
01070 do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
01071 ios_base::iostate& __err, tm* __tm) const
01072 {
01073 const locale& __loc = __io._M_getloc();
01074 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
01075
01076 size_t __i = 0;
01077 int __value = 0;
01078 for (; __beg != __end && __i < 4; ++__beg, ++__i)
01079 {
01080 const char __c = __ctype.narrow(*__beg, '*');
01081 if (__c >= '0' && __c <= '9')
01082 __value = __value * 10 + (__c - '0');
01083 else
01084 break;
01085 }
01086 if (__i == 2 || __i == 4)
01087 __tm->tm_year = __i == 2 ? __value : __value - 1900;
01088 else
01089 __err |= ios_base::failbit;
01090
01091 if (__beg == __end)
01092 __err |= ios_base::eofbit;
01093 return __beg;
01094 }
01095
01096 template<typename _CharT, typename _OutIter>
01097 _OutIter
01098 time_put<_CharT, _OutIter>::
01099 put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
01100 const _CharT* __beg, const _CharT* __end) const
01101 {
01102 const locale& __loc = __io._M_getloc();
01103 ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
01104 for (; __beg != __end; ++__beg)
01105 if (__ctype.narrow(*__beg, 0) != '%')
01106 {
01107 *__s = *__beg;
01108 ++__s;
01109 }
01110 else if (++__beg != __end)
01111 {
01112 char __format;
01113 char __mod = 0;
01114 const char __c = __ctype.narrow(*__beg, 0);
01115 if (__c != 'E' && __c != 'O')
01116 __format = __c;
01117 else if (++__beg != __end)
01118 {
01119 __mod = __c;
01120 __format = __ctype.narrow(*__beg, 0);
01121 }
01122 else
01123 break;
01124 __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
01125 }
01126 else
01127 break;
01128 return __s;
01129 }
01130
01131 template<typename _CharT, typename _OutIter>
01132 _OutIter
01133 time_put<_CharT, _OutIter>::
01134 do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
01135 char __format, char __mod) const
01136 {
01137 const locale& __loc = __io._M_getloc();
01138 ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
01139 __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
01140
01141
01142
01143 const size_t __maxlen = 128;
01144 char_type* __res =
01145 static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __maxlen));
01146
01147
01148
01149
01150
01151
01152 char_type __fmt[4];
01153 __fmt[0] = __ctype.widen('%');
01154 if (!__mod)
01155 {
01156 __fmt[1] = __format;
01157 __fmt[2] = char_type();
01158 }
01159 else
01160 {
01161 __fmt[1] = __mod;
01162 __fmt[2] = __format;
01163 __fmt[3] = char_type();
01164 }
01165
01166 __tp._M_put(__res, __maxlen, __fmt, __tm);
01167
01168
01169 return std::__write(__s, __res, char_traits<char_type>::length(__res));
01170 }
01171
01172
01173
01174
01175
01176 #if _GLIBCXX_EXTERN_TEMPLATE
01177 extern template class moneypunct<char, false>;
01178 extern template class moneypunct<char, true>;
01179 extern template class moneypunct_byname<char, false>;
01180 extern template class moneypunct_byname<char, true>;
01181 extern template class _GLIBCXX_LDBL_NAMESPACE money_get<char>;
01182 extern template class _GLIBCXX_LDBL_NAMESPACE money_put<char>;
01183 extern template class __timepunct<char>;
01184 extern template class time_put<char>;
01185 extern template class time_put_byname<char>;
01186 extern template class time_get<char>;
01187 extern template class time_get_byname<char>;
01188 extern template class messages<char>;
01189 extern template class messages_byname<char>;
01190
01191 extern template
01192 const moneypunct<char, true>&
01193 use_facet<moneypunct<char, true> >(const locale&);
01194
01195 extern template
01196 const moneypunct<char, false>&
01197 use_facet<moneypunct<char, false> >(const locale&);
01198
01199 extern template
01200 const money_put<char>&
01201 use_facet<money_put<char> >(const locale&);
01202
01203 extern template
01204 const money_get<char>&
01205 use_facet<money_get<char> >(const locale&);
01206
01207 extern template
01208 const __timepunct<char>&
01209 use_facet<__timepunct<char> >(const locale&);
01210
01211 extern template
01212 const time_put<char>&
01213 use_facet<time_put<char> >(const locale&);
01214
01215 extern template
01216 const time_get<char>&
01217 use_facet<time_get<char> >(const locale&);
01218
01219 extern template
01220 const messages<char>&
01221 use_facet<messages<char> >(const locale&);
01222
01223 extern template
01224 bool
01225 has_facet<moneypunct<char> >(const locale&);
01226
01227 extern template
01228 bool
01229 has_facet<money_put<char> >(const locale&);
01230
01231 extern template
01232 bool
01233 has_facet<money_get<char> >(const locale&);
01234
01235 extern template
01236 bool
01237 has_facet<__timepunct<char> >(const locale&);
01238
01239 extern template
01240 bool
01241 has_facet<time_put<char> >(const locale&);
01242
01243 extern template
01244 bool
01245 has_facet<time_get<char> >(const locale&);
01246
01247 extern template
01248 bool
01249 has_facet<messages<char> >(const locale&);
01250
01251 #ifdef _GLIBCXX_USE_WCHAR_T
01252 extern template class moneypunct<wchar_t, false>;
01253 extern template class moneypunct<wchar_t, true>;
01254 extern template class moneypunct_byname<wchar_t, false>;
01255 extern template class moneypunct_byname<wchar_t, true>;
01256 extern template class _GLIBCXX_LDBL_NAMESPACE money_get<wchar_t>;
01257 extern template class _GLIBCXX_LDBL_NAMESPACE money_put<wchar_t>;
01258 extern template class __timepunct<wchar_t>;
01259 extern template class time_put<wchar_t>;
01260 extern template class time_put_byname<wchar_t>;
01261 extern template class time_get<wchar_t>;
01262 extern template class time_get_byname<wchar_t>;
01263 extern template class messages<wchar_t>;
01264 extern template class messages_byname<wchar_t>;
01265
01266 extern template
01267 const moneypunct<wchar_t, true>&
01268 use_facet<moneypunct<wchar_t, true> >(const locale&);
01269
01270 extern template
01271 const moneypunct<wchar_t, false>&
01272 use_facet<moneypunct<wchar_t, false> >(const locale&);
01273
01274 extern template
01275 const money_put<wchar_t>&
01276 use_facet<money_put<wchar_t> >(const locale&);
01277
01278 extern template
01279 const money_get<wchar_t>&
01280 use_facet<money_get<wchar_t> >(const locale&);
01281
01282 extern template
01283 const __timepunct<wchar_t>&
01284 use_facet<__timepunct<wchar_t> >(const locale&);
01285
01286 extern template
01287 const time_put<wchar_t>&
01288 use_facet<time_put<wchar_t> >(const locale&);
01289
01290 extern template
01291 const time_get<wchar_t>&
01292 use_facet<time_get<wchar_t> >(const locale&);
01293
01294 extern template
01295 const messages<wchar_t>&
01296 use_facet<messages<wchar_t> >(const locale&);
01297
01298 extern template
01299 bool
01300 has_facet<moneypunct<wchar_t> >(const locale&);
01301
01302 extern template
01303 bool
01304 has_facet<money_put<wchar_t> >(const locale&);
01305
01306 extern template
01307 bool
01308 has_facet<money_get<wchar_t> >(const locale&);
01309
01310 extern template
01311 bool
01312 has_facet<__timepunct<wchar_t> >(const locale&);
01313
01314 extern template
01315 bool
01316 has_facet<time_put<wchar_t> >(const locale&);
01317
01318 extern template
01319 bool
01320 has_facet<time_get<wchar_t> >(const locale&);
01321
01322 extern template
01323 bool
01324 has_facet<messages<wchar_t> >(const locale&);
01325 #endif
01326 #endif
01327
01328 _GLIBCXX_END_NAMESPACE
01329
01330 #endif