locale revision 318031
1// -*- C++ -*- 2//===-------------------------- locale ------------------------------------===// 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is dual licensed under the MIT and the University of Illinois Open 7// Source Licenses. See LICENSE.TXT for details. 8// 9//===----------------------------------------------------------------------===// 10 11#ifndef _LIBCPP_LOCALE 12#define _LIBCPP_LOCALE 13 14/* 15 locale synopsis 16 17namespace std 18{ 19 20class locale 21{ 22public: 23 // types: 24 class facet; 25 class id; 26 27 typedef int category; 28 static const category // values assigned here are for exposition only 29 none = 0x000, 30 collate = 0x010, 31 ctype = 0x020, 32 monetary = 0x040, 33 numeric = 0x080, 34 time = 0x100, 35 messages = 0x200, 36 all = collate | ctype | monetary | numeric | time | messages; 37 38 // construct/copy/destroy: 39 locale() noexcept; 40 locale(const locale& other) noexcept; 41 explicit locale(const char* std_name); 42 explicit locale(const string& std_name); 43 locale(const locale& other, const char* std_name, category); 44 locale(const locale& other, const string& std_name, category); 45 template <class Facet> locale(const locale& other, Facet* f); 46 locale(const locale& other, const locale& one, category); 47 48 ~locale(); // not virtual 49 50 const locale& operator=(const locale& other) noexcept; 51 52 template <class Facet> locale combine(const locale& other) const; 53 54 // locale operations: 55 basic_string<char> name() const; 56 bool operator==(const locale& other) const; 57 bool operator!=(const locale& other) const; 58 template <class charT, class Traits, class Allocator> 59 bool operator()(const basic_string<charT,Traits,Allocator>& s1, 60 const basic_string<charT,Traits,Allocator>& s2) const; 61 62 // global locale objects: 63 static locale global(const locale&); 64 static const locale& classic(); 65}; 66 67template <class Facet> const Facet& use_facet(const locale&); 68template <class Facet> bool has_facet(const locale&) noexcept; 69 70// 22.3.3, convenience interfaces: 71template <class charT> bool isspace (charT c, const locale& loc); 72template <class charT> bool isprint (charT c, const locale& loc); 73template <class charT> bool iscntrl (charT c, const locale& loc); 74template <class charT> bool isupper (charT c, const locale& loc); 75template <class charT> bool islower (charT c, const locale& loc); 76template <class charT> bool isalpha (charT c, const locale& loc); 77template <class charT> bool isdigit (charT c, const locale& loc); 78template <class charT> bool ispunct (charT c, const locale& loc); 79template <class charT> bool isxdigit(charT c, const locale& loc); 80template <class charT> bool isalnum (charT c, const locale& loc); 81template <class charT> bool isgraph (charT c, const locale& loc); 82template <class charT> charT toupper(charT c, const locale& loc); 83template <class charT> charT tolower(charT c, const locale& loc); 84 85template<class Codecvt, class Elem = wchar_t, 86 class Wide_alloc = allocator<Elem>, 87 class Byte_alloc = allocator<char>> 88class wstring_convert 89{ 90public: 91 typedef basic_string<char, char_traits<char>, Byte_alloc> byte_string; 92 typedef basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string; 93 typedef typename Codecvt::state_type state_type; 94 typedef typename wide_string::traits_type::int_type int_type; 95 96 explicit wstring_convert(Codecvt* pcvt = new Codecvt); // explicit in C++14 97 wstring_convert(Codecvt* pcvt, state_type state); 98 explicit wstring_convert(const byte_string& byte_err, // explicit in C++14 99 const wide_string& wide_err = wide_string()); 100 wstring_convert(const wstring_convert&) = delete; // C++14 101 wstring_convert & operator=(const wstring_convert &) = delete; // C++14 102 ~wstring_convert(); 103 104 wide_string from_bytes(char byte); 105 wide_string from_bytes(const char* ptr); 106 wide_string from_bytes(const byte_string& str); 107 wide_string from_bytes(const char* first, const char* last); 108 109 byte_string to_bytes(Elem wchar); 110 byte_string to_bytes(const Elem* wptr); 111 byte_string to_bytes(const wide_string& wstr); 112 byte_string to_bytes(const Elem* first, const Elem* last); 113 114 size_t converted() const; // noexcept in C++14 115 state_type state() const; 116}; 117 118template <class Codecvt, class Elem = wchar_t, class Tr = char_traits<Elem>> 119class wbuffer_convert 120 : public basic_streambuf<Elem, Tr> 121{ 122public: 123 typedef typename Tr::state_type state_type; 124 125 explicit wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt, 126 state_type state = state_type()); // explicit in C++14 127 wbuffer_convert(const wbuffer_convert&) = delete; // C++14 128 wbuffer_convert & operator=(const wbuffer_convert &) = delete; // C++14 129 ~wbuffer_convert(); // C++14 130 131 streambuf* rdbuf() const; 132 streambuf* rdbuf(streambuf* bytebuf); 133 134 state_type state() const; 135}; 136 137// 22.4.1 and 22.4.1.3, ctype: 138class ctype_base; 139template <class charT> class ctype; 140template <> class ctype<char>; // specialization 141template <class charT> class ctype_byname; 142template <> class ctype_byname<char>; // specialization 143 144class codecvt_base; 145template <class internT, class externT, class stateT> class codecvt; 146template <class internT, class externT, class stateT> class codecvt_byname; 147 148// 22.4.2 and 22.4.3, numeric: 149template <class charT, class InputIterator> class num_get; 150template <class charT, class OutputIterator> class num_put; 151template <class charT> class numpunct; 152template <class charT> class numpunct_byname; 153 154// 22.4.4, col lation: 155template <class charT> class collate; 156template <class charT> class collate_byname; 157 158// 22.4.5, date and time: 159class time_base; 160template <class charT, class InputIterator> class time_get; 161template <class charT, class InputIterator> class time_get_byname; 162template <class charT, class OutputIterator> class time_put; 163template <class charT, class OutputIterator> class time_put_byname; 164 165// 22.4.6, money: 166class money_base; 167template <class charT, class InputIterator> class money_get; 168template <class charT, class OutputIterator> class money_put; 169template <class charT, bool Intl> class moneypunct; 170template <class charT, bool Intl> class moneypunct_byname; 171 172// 22.4.7, message retrieval: 173class messages_base; 174template <class charT> class messages; 175template <class charT> class messages_byname; 176 177} // std 178 179*/ 180 181#include <__config> 182#include <__locale> 183#include <algorithm> 184#include <memory> 185#include <ios> 186#include <streambuf> 187#include <iterator> 188#include <limits> 189#ifndef __APPLE__ 190#include <cstdarg> 191#endif 192#include <cstdlib> 193#include <ctime> 194#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__) 195#include <support/win32/locale_win32.h> 196#elif defined(_NEWLIB_VERSION) 197// FIXME: replace all the uses of _NEWLIB_VERSION with __NEWLIB__ preceded by an 198// include of <sys/cdefs.h> once https://sourceware.org/ml/newlib-cvs/2014-q3/msg00038.html 199// has had a chance to bake for a bit 200#include <support/newlib/xlocale.h> 201#elif !defined(__ANDROID__) 202#include <nl_types.h> 203#endif 204 205#ifdef __APPLE__ 206#include <Availability.h> 207#endif 208 209#include <__undef_min_max> 210 211#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 212#pragma GCC system_header 213#endif 214 215_LIBCPP_BEGIN_NAMESPACE_STD 216 217#if defined(__APPLE__) || defined(__FreeBSD__) 218# define _LIBCPP_GET_C_LOCALE 0 219#elif defined(__NetBSD__) 220# define _LIBCPP_GET_C_LOCALE LC_C_LOCALE 221#else 222# define _LIBCPP_GET_C_LOCALE __cloc() 223 // Get the C locale object 224 _LIBCPP_FUNC_VIS locale_t __cloc(); 225#define __cloc_defined 226#endif 227 228typedef _VSTD::remove_pointer<locale_t>::type __locale_struct; 229typedef _VSTD::unique_ptr<__locale_struct, decltype(&freelocale)> __locale_unique_ptr; 230#ifndef _LIBCPP_LOCALE__L_EXTENSIONS 231typedef _VSTD::unique_ptr<__locale_struct, decltype(&uselocale)> __locale_raii; 232#endif 233 234// OSX has nice foo_l() functions that let you turn off use of the global 235// locale. Linux, not so much. The following functions avoid the locale when 236// that's possible and otherwise do the wrong thing. FIXME. 237#if defined(__linux__) || defined(__EMSCRIPTEN__) || defined(_AIX) || \ 238 defined(_NEWLIB_VERSION) 239 240#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 241decltype(MB_CUR_MAX_L(_VSTD::declval<locale_t>())) 242inline _LIBCPP_INLINE_VISIBILITY 243__mb_cur_max_l(locale_t __l) 244{ 245 return MB_CUR_MAX_L(__l); 246} 247#else // _LIBCPP_LOCALE__L_EXTENSIONS 248inline _LIBCPP_ALWAYS_INLINE 249decltype(MB_CUR_MAX) __mb_cur_max_l(locale_t __l) 250{ 251 __locale_raii __current(uselocale(__l), uselocale); 252 return MB_CUR_MAX; 253} 254#endif // _LIBCPP_LOCALE__L_EXTENSIONS 255 256inline _LIBCPP_ALWAYS_INLINE 257wint_t __btowc_l(int __c, locale_t __l) 258{ 259#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 260 return btowc_l(__c, __l); 261#else 262 __locale_raii __current(uselocale(__l), uselocale); 263 return btowc(__c); 264#endif 265} 266 267inline _LIBCPP_ALWAYS_INLINE 268int __wctob_l(wint_t __c, locale_t __l) 269{ 270#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 271 return wctob_l(__c, __l); 272#else 273 __locale_raii __current(uselocale(__l), uselocale); 274 return wctob(__c); 275#endif 276} 277 278inline _LIBCPP_ALWAYS_INLINE 279size_t __wcsnrtombs_l(char *__dest, const wchar_t **__src, size_t __nwc, 280 size_t __len, mbstate_t *__ps, locale_t __l) 281{ 282#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 283 return wcsnrtombs_l(__dest, __src, __nwc, __len, __ps, __l); 284#else 285 __locale_raii __current(uselocale(__l), uselocale); 286 return wcsnrtombs(__dest, __src, __nwc, __len, __ps); 287#endif 288} 289 290inline _LIBCPP_ALWAYS_INLINE 291size_t __wcrtomb_l(char *__s, wchar_t __wc, mbstate_t *__ps, locale_t __l) 292{ 293#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 294 return wcrtomb_l(__s, __wc, __ps, __l); 295#else 296 __locale_raii __current(uselocale(__l), uselocale); 297 return wcrtomb(__s, __wc, __ps); 298#endif 299} 300 301inline _LIBCPP_ALWAYS_INLINE 302size_t __mbsnrtowcs_l(wchar_t * __dest, const char **__src, size_t __nms, 303 size_t __len, mbstate_t *__ps, locale_t __l) 304{ 305#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 306 return mbsnrtowcs_l(__dest, __src, __nms, __len, __ps, __l); 307#else 308 __locale_raii __current(uselocale(__l), uselocale); 309 return mbsnrtowcs(__dest, __src, __nms, __len, __ps); 310#endif 311} 312 313inline _LIBCPP_ALWAYS_INLINE 314size_t __mbrtowc_l(wchar_t *__pwc, const char *__s, size_t __n, 315 mbstate_t *__ps, locale_t __l) 316{ 317#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 318 return mbrtowc_l(__pwc, __s, __n, __ps, __l); 319#else 320 __locale_raii __current(uselocale(__l), uselocale); 321 return mbrtowc(__pwc, __s, __n, __ps); 322#endif 323} 324 325inline _LIBCPP_ALWAYS_INLINE 326int __mbtowc_l(wchar_t *__pwc, const char *__pmb, size_t __max, locale_t __l) 327{ 328#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 329 return mbtowc_l(__pwc, __pmb, __max, __l); 330#else 331 __locale_raii __current(uselocale(__l), uselocale); 332 return mbtowc(__pwc, __pmb, __max); 333#endif 334} 335 336inline _LIBCPP_ALWAYS_INLINE 337size_t __mbrlen_l(const char *__s, size_t __n, mbstate_t *__ps, locale_t __l) 338{ 339#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 340 return mbrlen_l(__s, __n, __ps, __l); 341#else 342 __locale_raii __current(uselocale(__l), uselocale); 343 return mbrlen(__s, __n, __ps); 344#endif 345} 346 347inline _LIBCPP_ALWAYS_INLINE 348lconv *__localeconv_l(locale_t __l) 349{ 350#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 351 return localeconv_l(__l); 352#else 353 __locale_raii __current(uselocale(__l), uselocale); 354 return localeconv(); 355#endif 356} 357 358inline _LIBCPP_ALWAYS_INLINE 359size_t __mbsrtowcs_l(wchar_t *__dest, const char **__src, size_t __len, 360 mbstate_t *__ps, locale_t __l) 361{ 362#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 363 return mbsrtowcs_l(__dest, __src, __len, __ps, __l); 364#else 365 __locale_raii __current(uselocale(__l), uselocale); 366 return mbsrtowcs(__dest, __src, __len, __ps); 367#endif 368} 369 370inline 371int __snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...) { 372 va_list __va; 373 va_start(__va, __format); 374#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 375 int __res = vsnprintf_l(__s, __n, __l, __format, __va); 376#else 377 __locale_raii __current(uselocale(__l), uselocale); 378 int __res = vsnprintf(__s, __n, __format, __va); 379#endif 380 va_end(__va); 381 return __res; 382} 383 384inline 385int __asprintf_l(char **__s, locale_t __l, const char *__format, ...) { 386 va_list __va; 387 va_start(__va, __format); 388#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 389 int __res = vasprintf_l(__s, __l, __format, __va); 390#else 391 __locale_raii __current(uselocale(__l), uselocale); 392 int __res = vasprintf(__s, __format, __va); 393#endif 394 va_end(__va); 395 return __res; 396} 397 398inline 399int __sscanf_l(const char *__s, locale_t __l, const char *__format, ...) { 400 va_list __va; 401 va_start(__va, __format); 402#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 403 int __res = vsscanf_l(__s, __l, __format, __va); 404#else 405 __locale_raii __current(uselocale(__l), uselocale); 406 int __res = vsscanf(__s, __format, __va); 407#endif 408 va_end(__va); 409 return __res; 410} 411 412#endif // __linux__ 413 414// __scan_keyword 415// Scans [__b, __e) until a match is found in the basic_strings range 416// [__kb, __ke) or until it can be shown that there is no match in [__kb, __ke). 417// __b will be incremented (visibly), consuming CharT until a match is found 418// or proved to not exist. A keyword may be "", in which will match anything. 419// If one keyword is a prefix of another, and the next CharT in the input 420// might match another keyword, the algorithm will attempt to find the longest 421// matching keyword. If the longer matching keyword ends up not matching, then 422// no keyword match is found. If no keyword match is found, __ke is returned 423// and failbit is set in __err. 424// Else an iterator pointing to the matching keyword is found. If more than 425// one keyword matches, an iterator to the first matching keyword is returned. 426// If on exit __b == __e, eofbit is set in __err. If __case_sensitive is false, 427// __ct is used to force to lower case before comparing characters. 428// Examples: 429// Keywords: "a", "abb" 430// If the input is "a", the first keyword matches and eofbit is set. 431// If the input is "abc", no match is found and "ab" are consumed. 432template <class _InputIterator, class _ForwardIterator, class _Ctype> 433_LIBCPP_HIDDEN 434_ForwardIterator 435__scan_keyword(_InputIterator& __b, _InputIterator __e, 436 _ForwardIterator __kb, _ForwardIterator __ke, 437 const _Ctype& __ct, ios_base::iostate& __err, 438 bool __case_sensitive = true) 439{ 440 typedef typename iterator_traits<_InputIterator>::value_type _CharT; 441 size_t __nkw = static_cast<size_t>(_VSTD::distance(__kb, __ke)); 442 const unsigned char __doesnt_match = '\0'; 443 const unsigned char __might_match = '\1'; 444 const unsigned char __does_match = '\2'; 445 unsigned char __statbuf[100]; 446 unsigned char* __status = __statbuf; 447 unique_ptr<unsigned char, void(*)(void*)> __stat_hold(0, free); 448 if (__nkw > sizeof(__statbuf)) 449 { 450 __status = (unsigned char*)malloc(__nkw); 451 if (__status == 0) 452 __throw_bad_alloc(); 453 __stat_hold.reset(__status); 454 } 455 size_t __n_might_match = __nkw; // At this point, any keyword might match 456 size_t __n_does_match = 0; // but none of them definitely do 457 // Initialize all statuses to __might_match, except for "" keywords are __does_match 458 unsigned char* __st = __status; 459 for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st) 460 { 461 if (!__ky->empty()) 462 *__st = __might_match; 463 else 464 { 465 *__st = __does_match; 466 --__n_might_match; 467 ++__n_does_match; 468 } 469 } 470 // While there might be a match, test keywords against the next CharT 471 for (size_t __indx = 0; __b != __e && __n_might_match > 0; ++__indx) 472 { 473 // Peek at the next CharT but don't consume it 474 _CharT __c = *__b; 475 if (!__case_sensitive) 476 __c = __ct.toupper(__c); 477 bool __consume = false; 478 // For each keyword which might match, see if the __indx character is __c 479 // If a match if found, consume __c 480 // If a match is found, and that is the last character in the keyword, 481 // then that keyword matches. 482 // If the keyword doesn't match this character, then change the keyword 483 // to doesn't match 484 __st = __status; 485 for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st) 486 { 487 if (*__st == __might_match) 488 { 489 _CharT __kc = (*__ky)[__indx]; 490 if (!__case_sensitive) 491 __kc = __ct.toupper(__kc); 492 if (__c == __kc) 493 { 494 __consume = true; 495 if (__ky->size() == __indx+1) 496 { 497 *__st = __does_match; 498 --__n_might_match; 499 ++__n_does_match; 500 } 501 } 502 else 503 { 504 *__st = __doesnt_match; 505 --__n_might_match; 506 } 507 } 508 } 509 // consume if we matched a character 510 if (__consume) 511 { 512 ++__b; 513 // If we consumed a character and there might be a matched keyword that 514 // was marked matched on a previous iteration, then such keywords 515 // which are now marked as not matching. 516 if (__n_might_match + __n_does_match > 1) 517 { 518 __st = __status; 519 for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st) 520 { 521 if (*__st == __does_match && __ky->size() != __indx+1) 522 { 523 *__st = __doesnt_match; 524 --__n_does_match; 525 } 526 } 527 } 528 } 529 } 530 // We've exited the loop because we hit eof and/or we have no more "might matches". 531 if (__b == __e) 532 __err |= ios_base::eofbit; 533 // Return the first matching result 534 for (__st = __status; __kb != __ke; ++__kb, (void) ++__st) 535 if (*__st == __does_match) 536 break; 537 if (__kb == __ke) 538 __err |= ios_base::failbit; 539 return __kb; 540} 541 542struct _LIBCPP_TYPE_VIS __num_get_base 543{ 544 static const int __num_get_buf_sz = 40; 545 546 static int __get_base(ios_base&); 547 static const char __src[33]; 548}; 549 550_LIBCPP_FUNC_VIS 551void __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end, 552 ios_base::iostate& __err); 553 554template <class _CharT> 555struct __num_get 556 : protected __num_get_base 557{ 558 static string __stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep); 559 static string __stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point, 560 _CharT& __thousands_sep); 561 static int __stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end, 562 unsigned& __dc, _CharT __thousands_sep, const string& __grouping, 563 unsigned* __g, unsigned*& __g_end, _CharT* __atoms); 564 static int __stage2_float_loop(_CharT __ct, bool& __in_units, char& __exp, 565 char* __a, char*& __a_end, 566 _CharT __decimal_point, _CharT __thousands_sep, 567 const string& __grouping, unsigned* __g, 568 unsigned*& __g_end, unsigned& __dc, _CharT* __atoms); 569}; 570 571template <class _CharT> 572string 573__num_get<_CharT>::__stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep) 574{ 575 locale __loc = __iob.getloc(); 576 use_facet<ctype<_CharT> >(__loc).widen(__src, __src + 26, __atoms); 577 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); 578 __thousands_sep = __np.thousands_sep(); 579 return __np.grouping(); 580} 581 582template <class _CharT> 583string 584__num_get<_CharT>::__stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point, 585 _CharT& __thousands_sep) 586{ 587 locale __loc = __iob.getloc(); 588 use_facet<ctype<_CharT> >(__loc).widen(__src, __src + 32, __atoms); 589 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); 590 __decimal_point = __np.decimal_point(); 591 __thousands_sep = __np.thousands_sep(); 592 return __np.grouping(); 593} 594 595template <class _CharT> 596int 597__num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end, 598 unsigned& __dc, _CharT __thousands_sep, const string& __grouping, 599 unsigned* __g, unsigned*& __g_end, _CharT* __atoms) 600{ 601 if (__a_end == __a && (__ct == __atoms[24] || __ct == __atoms[25])) 602 { 603 *__a_end++ = __ct == __atoms[24] ? '+' : '-'; 604 __dc = 0; 605 return 0; 606 } 607 if (__grouping.size() != 0 && __ct == __thousands_sep) 608 { 609 if (__g_end-__g < __num_get_buf_sz) 610 { 611 *__g_end++ = __dc; 612 __dc = 0; 613 } 614 return 0; 615 } 616 ptrdiff_t __f = find(__atoms, __atoms + 26, __ct) - __atoms; 617 if (__f >= 24) 618 return -1; 619 switch (__base) 620 { 621 case 8: 622 case 10: 623 if (__f >= __base) 624 return -1; 625 break; 626 case 16: 627 if (__f < 22) 628 break; 629 if (__a_end != __a && __a_end - __a <= 2 && __a_end[-1] == '0') 630 { 631 __dc = 0; 632 *__a_end++ = __src[__f]; 633 return 0; 634 } 635 return -1; 636 } 637 *__a_end++ = __src[__f]; 638 ++__dc; 639 return 0; 640} 641 642template <class _CharT> 643int 644__num_get<_CharT>::__stage2_float_loop(_CharT __ct, bool& __in_units, char& __exp, char* __a, char*& __a_end, 645 _CharT __decimal_point, _CharT __thousands_sep, const string& __grouping, 646 unsigned* __g, unsigned*& __g_end, unsigned& __dc, _CharT* __atoms) 647{ 648 if (__ct == __decimal_point) 649 { 650 if (!__in_units) 651 return -1; 652 __in_units = false; 653 *__a_end++ = '.'; 654 if (__grouping.size() != 0 && __g_end-__g < __num_get_buf_sz) 655 *__g_end++ = __dc; 656 return 0; 657 } 658 if (__ct == __thousands_sep && __grouping.size() != 0) 659 { 660 if (!__in_units) 661 return -1; 662 if (__g_end-__g < __num_get_buf_sz) 663 { 664 *__g_end++ = __dc; 665 __dc = 0; 666 } 667 return 0; 668 } 669 ptrdiff_t __f = find(__atoms, __atoms + 32, __ct) - __atoms; 670 if (__f >= 32) 671 return -1; 672 char __x = __src[__f]; 673 if (__x == '-' || __x == '+') 674 { 675 if (__a_end == __a || (__a_end[-1] & 0x5F) == (__exp & 0x7F)) 676 { 677 *__a_end++ = __x; 678 return 0; 679 } 680 return -1; 681 } 682 if (__x == 'x' || __x == 'X') 683 __exp = 'P'; 684 else if ((__x & 0x5F) == __exp) 685 { 686 __exp |= 0x80; 687 if (__in_units) 688 { 689 __in_units = false; 690 if (__grouping.size() != 0 && __g_end-__g < __num_get_buf_sz) 691 *__g_end++ = __dc; 692 } 693 } 694 *__a_end++ = __x; 695 if (__f >= 22) 696 return 0; 697 ++__dc; 698 return 0; 699} 700 701_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_TYPE_VIS __num_get<char>) 702_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_TYPE_VIS __num_get<wchar_t>) 703 704template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > 705class _LIBCPP_TYPE_VIS_ONLY num_get 706 : public locale::facet, 707 private __num_get<_CharT> 708{ 709public: 710 typedef _CharT char_type; 711 typedef _InputIterator iter_type; 712 713 _LIBCPP_ALWAYS_INLINE 714 explicit num_get(size_t __refs = 0) 715 : locale::facet(__refs) {} 716 717 _LIBCPP_ALWAYS_INLINE 718 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 719 ios_base::iostate& __err, bool& __v) const 720 { 721 return do_get(__b, __e, __iob, __err, __v); 722 } 723 724 _LIBCPP_ALWAYS_INLINE 725 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 726 ios_base::iostate& __err, long& __v) const 727 { 728 return do_get(__b, __e, __iob, __err, __v); 729 } 730 731 _LIBCPP_ALWAYS_INLINE 732 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 733 ios_base::iostate& __err, long long& __v) const 734 { 735 return do_get(__b, __e, __iob, __err, __v); 736 } 737 738 _LIBCPP_ALWAYS_INLINE 739 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 740 ios_base::iostate& __err, unsigned short& __v) const 741 { 742 return do_get(__b, __e, __iob, __err, __v); 743 } 744 745 _LIBCPP_ALWAYS_INLINE 746 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 747 ios_base::iostate& __err, unsigned int& __v) const 748 { 749 return do_get(__b, __e, __iob, __err, __v); 750 } 751 752 _LIBCPP_ALWAYS_INLINE 753 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 754 ios_base::iostate& __err, unsigned long& __v) const 755 { 756 return do_get(__b, __e, __iob, __err, __v); 757 } 758 759 _LIBCPP_ALWAYS_INLINE 760 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 761 ios_base::iostate& __err, unsigned long long& __v) const 762 { 763 return do_get(__b, __e, __iob, __err, __v); 764 } 765 766 _LIBCPP_ALWAYS_INLINE 767 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 768 ios_base::iostate& __err, float& __v) const 769 { 770 return do_get(__b, __e, __iob, __err, __v); 771 } 772 773 _LIBCPP_ALWAYS_INLINE 774 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 775 ios_base::iostate& __err, double& __v) const 776 { 777 return do_get(__b, __e, __iob, __err, __v); 778 } 779 780 _LIBCPP_ALWAYS_INLINE 781 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 782 ios_base::iostate& __err, long double& __v) const 783 { 784 return do_get(__b, __e, __iob, __err, __v); 785 } 786 787 _LIBCPP_ALWAYS_INLINE 788 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 789 ios_base::iostate& __err, void*& __v) const 790 { 791 return do_get(__b, __e, __iob, __err, __v); 792 } 793 794 static locale::id id; 795 796protected: 797 _LIBCPP_ALWAYS_INLINE 798 ~num_get() {} 799 800 template <class _Fp> 801 iter_type __do_get_floating_point 802 (iter_type __b, iter_type __e, ios_base& __iob, 803 ios_base::iostate& __err, _Fp& __v) const; 804 805 template <class _Signed> 806 iter_type __do_get_signed 807 (iter_type __b, iter_type __e, ios_base& __iob, 808 ios_base::iostate& __err, _Signed& __v) const; 809 810 template <class _Unsigned> 811 iter_type __do_get_unsigned 812 (iter_type __b, iter_type __e, ios_base& __iob, 813 ios_base::iostate& __err, _Unsigned& __v) const; 814 815 816 virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, 817 ios_base::iostate& __err, bool& __v) const; 818 819 virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, 820 ios_base::iostate& __err, long& __v) const 821 { return this->__do_get_signed ( __b, __e, __iob, __err, __v ); } 822 823 virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, 824 ios_base::iostate& __err, long long& __v) const 825 { return this->__do_get_signed ( __b, __e, __iob, __err, __v ); } 826 827 virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, 828 ios_base::iostate& __err, unsigned short& __v) const 829 { return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); } 830 831 virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, 832 ios_base::iostate& __err, unsigned int& __v) const 833 { return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); } 834 835 virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, 836 ios_base::iostate& __err, unsigned long& __v) const 837 { return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); } 838 839 virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, 840 ios_base::iostate& __err, unsigned long long& __v) const 841 { return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); } 842 843 virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, 844 ios_base::iostate& __err, float& __v) const 845 { return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); } 846 847 virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, 848 ios_base::iostate& __err, double& __v) const 849 { return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); } 850 851 virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, 852 ios_base::iostate& __err, long double& __v) const 853 { return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); } 854 855 virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, 856 ios_base::iostate& __err, void*& __v) const; 857}; 858 859template <class _CharT, class _InputIterator> 860locale::id 861num_get<_CharT, _InputIterator>::id; 862 863template <class _Tp> 864_Tp 865__num_get_signed_integral(const char* __a, const char* __a_end, 866 ios_base::iostate& __err, int __base) 867{ 868 if (__a != __a_end) 869 { 870 typename remove_reference<decltype(errno)>::type __save_errno = errno; 871 errno = 0; 872 char *__p2; 873 long long __ll = strtoll_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE); 874 typename remove_reference<decltype(errno)>::type __current_errno = errno; 875 if (__current_errno == 0) 876 errno = __save_errno; 877 if (__p2 != __a_end) 878 { 879 __err = ios_base::failbit; 880 return 0; 881 } 882 else if (__current_errno == ERANGE || 883 __ll < numeric_limits<_Tp>::min() || 884 numeric_limits<_Tp>::max() < __ll) 885 { 886 __err = ios_base::failbit; 887 if (__ll > 0) 888 return numeric_limits<_Tp>::max(); 889 else 890 return numeric_limits<_Tp>::min(); 891 } 892 return static_cast<_Tp>(__ll); 893 } 894 __err = ios_base::failbit; 895 return 0; 896} 897 898template <class _Tp> 899_Tp 900__num_get_unsigned_integral(const char* __a, const char* __a_end, 901 ios_base::iostate& __err, int __base) 902{ 903 if (__a != __a_end) 904 { 905 if (*__a == '-') 906 { 907 __err = ios_base::failbit; 908 return 0; 909 } 910 typename remove_reference<decltype(errno)>::type __save_errno = errno; 911 errno = 0; 912 char *__p2; 913 unsigned long long __ll = strtoull_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE); 914 typename remove_reference<decltype(errno)>::type __current_errno = errno; 915 if (__current_errno == 0) 916 errno = __save_errno; 917 if (__p2 != __a_end) 918 { 919 __err = ios_base::failbit; 920 return 0; 921 } 922 else if (__current_errno == ERANGE || 923 numeric_limits<_Tp>::max() < __ll) 924 { 925 __err = ios_base::failbit; 926 return numeric_limits<_Tp>::max(); 927 } 928 return static_cast<_Tp>(__ll); 929 } 930 __err = ios_base::failbit; 931 return 0; 932} 933 934template <class _Tp> 935_Tp 936__num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err) 937{ 938 if (__a != __a_end) 939 { 940 typename remove_reference<decltype(errno)>::type __save_errno = errno; 941 errno = 0; 942 char *__p2; 943 long double __ld = strtold_l(__a, &__p2, _LIBCPP_GET_C_LOCALE); 944 typename remove_reference<decltype(errno)>::type __current_errno = errno; 945 if (__current_errno == 0) 946 errno = __save_errno; 947 if (__p2 != __a_end) 948 { 949 __err = ios_base::failbit; 950 return 0; 951 } 952 else if (__current_errno == ERANGE) 953 __err = ios_base::failbit; 954 return static_cast<_Tp>(__ld); 955 } 956 __err = ios_base::failbit; 957 return 0; 958} 959 960template <class _CharT, class _InputIterator> 961_InputIterator 962num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, 963 ios_base& __iob, 964 ios_base::iostate& __err, 965 bool& __v) const 966{ 967 if ((__iob.flags() & ios_base::boolalpha) == 0) 968 { 969 long __lv = -1; 970 __b = do_get(__b, __e, __iob, __err, __lv); 971 switch (__lv) 972 { 973 case 0: 974 __v = false; 975 break; 976 case 1: 977 __v = true; 978 break; 979 default: 980 __v = true; 981 __err = ios_base::failbit; 982 break; 983 } 984 return __b; 985 } 986 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__iob.getloc()); 987 const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__iob.getloc()); 988 typedef typename numpunct<_CharT>::string_type string_type; 989 const string_type __names[2] = {__np.truename(), __np.falsename()}; 990 const string_type* __i = __scan_keyword(__b, __e, __names, __names+2, 991 __ct, __err); 992 __v = __i == __names; 993 return __b; 994} 995 996// signed 997 998template <class _CharT, class _InputIterator> 999template <class _Signed> 1000_InputIterator 1001num_get<_CharT, _InputIterator>::__do_get_signed(iter_type __b, iter_type __e, 1002 ios_base& __iob, 1003 ios_base::iostate& __err, 1004 _Signed& __v) const 1005{ 1006 // Stage 1 1007 int __base = this->__get_base(__iob); 1008 // Stage 2 1009 char_type __atoms[26]; 1010 char_type __thousands_sep; 1011 string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); 1012 string __buf; 1013 __buf.resize(__buf.capacity()); 1014 char* __a = &__buf[0]; 1015 char* __a_end = __a; 1016 unsigned __g[__num_get_base::__num_get_buf_sz]; 1017 unsigned* __g_end = __g; 1018 unsigned __dc = 0; 1019 for (; __b != __e; ++__b) 1020 { 1021 if (__a_end == __a + __buf.size()) 1022 { 1023 size_t __tmp = __buf.size(); 1024 __buf.resize(2*__buf.size()); 1025 __buf.resize(__buf.capacity()); 1026 __a = &__buf[0]; 1027 __a_end = __a + __tmp; 1028 } 1029 if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, 1030 __thousands_sep, __grouping, __g, __g_end, 1031 __atoms)) 1032 break; 1033 } 1034 if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) 1035 *__g_end++ = __dc; 1036 // Stage 3 1037 __v = __num_get_signed_integral<_Signed>(__a, __a_end, __err, __base); 1038 // Digit grouping checked 1039 __check_grouping(__grouping, __g, __g_end, __err); 1040 // EOF checked 1041 if (__b == __e) 1042 __err |= ios_base::eofbit; 1043 return __b; 1044} 1045 1046// unsigned 1047 1048template <class _CharT, class _InputIterator> 1049template <class _Unsigned> 1050_InputIterator 1051num_get<_CharT, _InputIterator>::__do_get_unsigned(iter_type __b, iter_type __e, 1052 ios_base& __iob, 1053 ios_base::iostate& __err, 1054 _Unsigned& __v) const 1055{ 1056 // Stage 1 1057 int __base = this->__get_base(__iob); 1058 // Stage 2 1059 char_type __atoms[26]; 1060 char_type __thousands_sep; 1061 string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); 1062 string __buf; 1063 __buf.resize(__buf.capacity()); 1064 char* __a = &__buf[0]; 1065 char* __a_end = __a; 1066 unsigned __g[__num_get_base::__num_get_buf_sz]; 1067 unsigned* __g_end = __g; 1068 unsigned __dc = 0; 1069 for (; __b != __e; ++__b) 1070 { 1071 if (__a_end == __a + __buf.size()) 1072 { 1073 size_t __tmp = __buf.size(); 1074 __buf.resize(2*__buf.size()); 1075 __buf.resize(__buf.capacity()); 1076 __a = &__buf[0]; 1077 __a_end = __a + __tmp; 1078 } 1079 if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, 1080 __thousands_sep, __grouping, __g, __g_end, 1081 __atoms)) 1082 break; 1083 } 1084 if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) 1085 *__g_end++ = __dc; 1086 // Stage 3 1087 __v = __num_get_unsigned_integral<_Unsigned>(__a, __a_end, __err, __base); 1088 // Digit grouping checked 1089 __check_grouping(__grouping, __g, __g_end, __err); 1090 // EOF checked 1091 if (__b == __e) 1092 __err |= ios_base::eofbit; 1093 return __b; 1094} 1095 1096// floating point 1097 1098template <class _CharT, class _InputIterator> 1099template <class _Fp> 1100_InputIterator 1101num_get<_CharT, _InputIterator>::__do_get_floating_point(iter_type __b, iter_type __e, 1102 ios_base& __iob, 1103 ios_base::iostate& __err, 1104 _Fp& __v) const 1105{ 1106 // Stage 1, nothing to do 1107 // Stage 2 1108 char_type __atoms[32]; 1109 char_type __decimal_point; 1110 char_type __thousands_sep; 1111 string __grouping = this->__stage2_float_prep(__iob, __atoms, 1112 __decimal_point, 1113 __thousands_sep); 1114 string __buf; 1115 __buf.resize(__buf.capacity()); 1116 char* __a = &__buf[0]; 1117 char* __a_end = __a; 1118 unsigned __g[__num_get_base::__num_get_buf_sz]; 1119 unsigned* __g_end = __g; 1120 unsigned __dc = 0; 1121 bool __in_units = true; 1122 char __exp = 'E'; 1123 for (; __b != __e; ++__b) 1124 { 1125 if (__a_end == __a + __buf.size()) 1126 { 1127 size_t __tmp = __buf.size(); 1128 __buf.resize(2*__buf.size()); 1129 __buf.resize(__buf.capacity()); 1130 __a = &__buf[0]; 1131 __a_end = __a + __tmp; 1132 } 1133 if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end, 1134 __decimal_point, __thousands_sep, 1135 __grouping, __g, __g_end, 1136 __dc, __atoms)) 1137 break; 1138 } 1139 if (__grouping.size() != 0 && __in_units && __g_end-__g < __num_get_base::__num_get_buf_sz) 1140 *__g_end++ = __dc; 1141 // Stage 3 1142 __v = __num_get_float<_Fp>(__a, __a_end, __err); 1143 // Digit grouping checked 1144 __check_grouping(__grouping, __g, __g_end, __err); 1145 // EOF checked 1146 if (__b == __e) 1147 __err |= ios_base::eofbit; 1148 return __b; 1149} 1150 1151template <class _CharT, class _InputIterator> 1152_InputIterator 1153num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, 1154 ios_base& __iob, 1155 ios_base::iostate& __err, 1156 void*& __v) const 1157{ 1158 // Stage 1 1159 int __base = 16; 1160 // Stage 2 1161 char_type __atoms[26]; 1162 char_type __thousands_sep = 0; 1163 string __grouping; 1164 use_facet<ctype<_CharT> >(__iob.getloc()).widen(__num_get_base::__src, 1165 __num_get_base::__src + 26, __atoms); 1166 string __buf; 1167 __buf.resize(__buf.capacity()); 1168 char* __a = &__buf[0]; 1169 char* __a_end = __a; 1170 unsigned __g[__num_get_base::__num_get_buf_sz]; 1171 unsigned* __g_end = __g; 1172 unsigned __dc = 0; 1173 for (; __b != __e; ++__b) 1174 { 1175 if (__a_end == __a + __buf.size()) 1176 { 1177 size_t __tmp = __buf.size(); 1178 __buf.resize(2*__buf.size()); 1179 __buf.resize(__buf.capacity()); 1180 __a = &__buf[0]; 1181 __a_end = __a + __tmp; 1182 } 1183 if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, 1184 __thousands_sep, __grouping, 1185 __g, __g_end, __atoms)) 1186 break; 1187 } 1188 // Stage 3 1189 __buf.resize(__a_end - __a); 1190#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1191 if (sscanf_l(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1) 1192#else 1193 if (__sscanf_l(__buf.c_str(), __cloc(), "%p", &__v) != 1) 1194#endif 1195 __err = ios_base::failbit; 1196 // EOF checked 1197 if (__b == __e) 1198 __err |= ios_base::eofbit; 1199 return __b; 1200} 1201 1202_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS num_get<char>) 1203_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS num_get<wchar_t>) 1204 1205struct _LIBCPP_TYPE_VIS __num_put_base 1206{ 1207protected: 1208 static void __format_int(char* __fmt, const char* __len, bool __signd, 1209 ios_base::fmtflags __flags); 1210 static bool __format_float(char* __fmt, const char* __len, 1211 ios_base::fmtflags __flags); 1212 static char* __identify_padding(char* __nb, char* __ne, 1213 const ios_base& __iob); 1214}; 1215 1216template <class _CharT> 1217struct __num_put 1218 : protected __num_put_base 1219{ 1220 static void __widen_and_group_int(char* __nb, char* __np, char* __ne, 1221 _CharT* __ob, _CharT*& __op, _CharT*& __oe, 1222 const locale& __loc); 1223 static void __widen_and_group_float(char* __nb, char* __np, char* __ne, 1224 _CharT* __ob, _CharT*& __op, _CharT*& __oe, 1225 const locale& __loc); 1226}; 1227 1228template <class _CharT> 1229void 1230__num_put<_CharT>::__widen_and_group_int(char* __nb, char* __np, char* __ne, 1231 _CharT* __ob, _CharT*& __op, _CharT*& __oe, 1232 const locale& __loc) 1233{ 1234 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> > (__loc); 1235 const numpunct<_CharT>& __npt = use_facet<numpunct<_CharT> >(__loc); 1236 string __grouping = __npt.grouping(); 1237 if (__grouping.empty()) 1238 { 1239 __ct.widen(__nb, __ne, __ob); 1240 __oe = __ob + (__ne - __nb); 1241 } 1242 else 1243 { 1244 __oe = __ob; 1245 char* __nf = __nb; 1246 if (*__nf == '-' || *__nf == '+') 1247 *__oe++ = __ct.widen(*__nf++); 1248 if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' || 1249 __nf[1] == 'X')) 1250 { 1251 *__oe++ = __ct.widen(*__nf++); 1252 *__oe++ = __ct.widen(*__nf++); 1253 } 1254 reverse(__nf, __ne); 1255 _CharT __thousands_sep = __npt.thousands_sep(); 1256 unsigned __dc = 0; 1257 unsigned __dg = 0; 1258 for (char* __p = __nf; __p < __ne; ++__p) 1259 { 1260 if (static_cast<unsigned>(__grouping[__dg]) > 0 && 1261 __dc == static_cast<unsigned>(__grouping[__dg])) 1262 { 1263 *__oe++ = __thousands_sep; 1264 __dc = 0; 1265 if (__dg < __grouping.size()-1) 1266 ++__dg; 1267 } 1268 *__oe++ = __ct.widen(*__p); 1269 ++__dc; 1270 } 1271 reverse(__ob + (__nf - __nb), __oe); 1272 } 1273 if (__np == __ne) 1274 __op = __oe; 1275 else 1276 __op = __ob + (__np - __nb); 1277} 1278 1279template <class _CharT> 1280void 1281__num_put<_CharT>::__widen_and_group_float(char* __nb, char* __np, char* __ne, 1282 _CharT* __ob, _CharT*& __op, _CharT*& __oe, 1283 const locale& __loc) 1284{ 1285 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> > (__loc); 1286 const numpunct<_CharT>& __npt = use_facet<numpunct<_CharT> >(__loc); 1287 string __grouping = __npt.grouping(); 1288 __oe = __ob; 1289 char* __nf = __nb; 1290 if (*__nf == '-' || *__nf == '+') 1291 *__oe++ = __ct.widen(*__nf++); 1292 char* __ns; 1293 if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' || 1294 __nf[1] == 'X')) 1295 { 1296 *__oe++ = __ct.widen(*__nf++); 1297 *__oe++ = __ct.widen(*__nf++); 1298 for (__ns = __nf; __ns < __ne; ++__ns) 1299 if (!isxdigit_l(*__ns, _LIBCPP_GET_C_LOCALE)) 1300 break; 1301 } 1302 else 1303 { 1304 for (__ns = __nf; __ns < __ne; ++__ns) 1305 if (!isdigit_l(*__ns, _LIBCPP_GET_C_LOCALE)) 1306 break; 1307 } 1308 if (__grouping.empty()) 1309 { 1310 __ct.widen(__nf, __ns, __oe); 1311 __oe += __ns - __nf; 1312 } 1313 else 1314 { 1315 reverse(__nf, __ns); 1316 _CharT __thousands_sep = __npt.thousands_sep(); 1317 unsigned __dc = 0; 1318 unsigned __dg = 0; 1319 for (char* __p = __nf; __p < __ns; ++__p) 1320 { 1321 if (__grouping[__dg] > 0 && __dc == static_cast<unsigned>(__grouping[__dg])) 1322 { 1323 *__oe++ = __thousands_sep; 1324 __dc = 0; 1325 if (__dg < __grouping.size()-1) 1326 ++__dg; 1327 } 1328 *__oe++ = __ct.widen(*__p); 1329 ++__dc; 1330 } 1331 reverse(__ob + (__nf - __nb), __oe); 1332 } 1333 for (__nf = __ns; __nf < __ne; ++__nf) 1334 { 1335 if (*__nf == '.') 1336 { 1337 *__oe++ = __npt.decimal_point(); 1338 ++__nf; 1339 break; 1340 } 1341 else 1342 *__oe++ = __ct.widen(*__nf); 1343 } 1344 __ct.widen(__nf, __ne, __oe); 1345 __oe += __ne - __nf; 1346 if (__np == __ne) 1347 __op = __oe; 1348 else 1349 __op = __ob + (__np - __nb); 1350} 1351 1352_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_TYPE_VIS __num_put<char>) 1353_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_TYPE_VIS __num_put<wchar_t>) 1354 1355template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > 1356class _LIBCPP_TYPE_VIS_ONLY num_put 1357 : public locale::facet, 1358 private __num_put<_CharT> 1359{ 1360public: 1361 typedef _CharT char_type; 1362 typedef _OutputIterator iter_type; 1363 1364 _LIBCPP_ALWAYS_INLINE 1365 explicit num_put(size_t __refs = 0) 1366 : locale::facet(__refs) {} 1367 1368 _LIBCPP_ALWAYS_INLINE 1369 iter_type put(iter_type __s, ios_base& __iob, char_type __fl, 1370 bool __v) const 1371 { 1372 return do_put(__s, __iob, __fl, __v); 1373 } 1374 1375 _LIBCPP_ALWAYS_INLINE 1376 iter_type put(iter_type __s, ios_base& __iob, char_type __fl, 1377 long __v) const 1378 { 1379 return do_put(__s, __iob, __fl, __v); 1380 } 1381 1382 _LIBCPP_ALWAYS_INLINE 1383 iter_type put(iter_type __s, ios_base& __iob, char_type __fl, 1384 long long __v) const 1385 { 1386 return do_put(__s, __iob, __fl, __v); 1387 } 1388 1389 _LIBCPP_ALWAYS_INLINE 1390 iter_type put(iter_type __s, ios_base& __iob, char_type __fl, 1391 unsigned long __v) const 1392 { 1393 return do_put(__s, __iob, __fl, __v); 1394 } 1395 1396 _LIBCPP_ALWAYS_INLINE 1397 iter_type put(iter_type __s, ios_base& __iob, char_type __fl, 1398 unsigned long long __v) const 1399 { 1400 return do_put(__s, __iob, __fl, __v); 1401 } 1402 1403 _LIBCPP_ALWAYS_INLINE 1404 iter_type put(iter_type __s, ios_base& __iob, char_type __fl, 1405 double __v) const 1406 { 1407 return do_put(__s, __iob, __fl, __v); 1408 } 1409 1410 _LIBCPP_ALWAYS_INLINE 1411 iter_type put(iter_type __s, ios_base& __iob, char_type __fl, 1412 long double __v) const 1413 { 1414 return do_put(__s, __iob, __fl, __v); 1415 } 1416 1417 _LIBCPP_ALWAYS_INLINE 1418 iter_type put(iter_type __s, ios_base& __iob, char_type __fl, 1419 const void* __v) const 1420 { 1421 return do_put(__s, __iob, __fl, __v); 1422 } 1423 1424 static locale::id id; 1425 1426protected: 1427 _LIBCPP_ALWAYS_INLINE 1428 ~num_put() {} 1429 1430 virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, 1431 bool __v) const; 1432 virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, 1433 long __v) const; 1434 virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, 1435 long long __v) const; 1436 virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, 1437 unsigned long) const; 1438 virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, 1439 unsigned long long) const; 1440 virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, 1441 double __v) const; 1442 virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, 1443 long double __v) const; 1444 virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, 1445 const void* __v) const; 1446}; 1447 1448template <class _CharT, class _OutputIterator> 1449locale::id 1450num_put<_CharT, _OutputIterator>::id; 1451 1452template <class _CharT, class _OutputIterator> 1453_LIBCPP_HIDDEN 1454_OutputIterator 1455__pad_and_output(_OutputIterator __s, 1456 const _CharT* __ob, const _CharT* __op, const _CharT* __oe, 1457 ios_base& __iob, _CharT __fl) 1458{ 1459 streamsize __sz = __oe - __ob; 1460 streamsize __ns = __iob.width(); 1461 if (__ns > __sz) 1462 __ns -= __sz; 1463 else 1464 __ns = 0; 1465 for (;__ob < __op; ++__ob, ++__s) 1466 *__s = *__ob; 1467 for (; __ns; --__ns, ++__s) 1468 *__s = __fl; 1469 for (; __ob < __oe; ++__ob, ++__s) 1470 *__s = *__ob; 1471 __iob.width(0); 1472 return __s; 1473} 1474 1475#if !defined(__APPLE__) || \ 1476 (defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED > __MAC_10_8) || \ 1477 (defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED > __IPHONE_6_0) 1478 1479template <class _CharT, class _Traits> 1480_LIBCPP_HIDDEN 1481ostreambuf_iterator<_CharT, _Traits> 1482__pad_and_output(ostreambuf_iterator<_CharT, _Traits> __s, 1483 const _CharT* __ob, const _CharT* __op, const _CharT* __oe, 1484 ios_base& __iob, _CharT __fl) 1485{ 1486 if (__s.__sbuf_ == nullptr) 1487 return __s; 1488 streamsize __sz = __oe - __ob; 1489 streamsize __ns = __iob.width(); 1490 if (__ns > __sz) 1491 __ns -= __sz; 1492 else 1493 __ns = 0; 1494 streamsize __np = __op - __ob; 1495 if (__np > 0) 1496 { 1497 if (__s.__sbuf_->sputn(__ob, __np) != __np) 1498 { 1499 __s.__sbuf_ = nullptr; 1500 return __s; 1501 } 1502 } 1503 if (__ns > 0) 1504 { 1505 basic_string<_CharT, _Traits> __sp(__ns, __fl); 1506 if (__s.__sbuf_->sputn(__sp.data(), __ns) != __ns) 1507 { 1508 __s.__sbuf_ = nullptr; 1509 return __s; 1510 } 1511 } 1512 __np = __oe - __op; 1513 if (__np > 0) 1514 { 1515 if (__s.__sbuf_->sputn(__op, __np) != __np) 1516 { 1517 __s.__sbuf_ = nullptr; 1518 return __s; 1519 } 1520 } 1521 __iob.width(0); 1522 return __s; 1523} 1524 1525#endif 1526 1527template <class _CharT, class _OutputIterator> 1528_OutputIterator 1529num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, 1530 char_type __fl, bool __v) const 1531{ 1532 if ((__iob.flags() & ios_base::boolalpha) == 0) 1533 return do_put(__s, __iob, __fl, (unsigned long)__v); 1534 const numpunct<char_type>& __np = use_facet<numpunct<char_type> >(__iob.getloc()); 1535 typedef typename numpunct<char_type>::string_type string_type; 1536#if _LIBCPP_DEBUG_LEVEL >= 2 1537 string_type __tmp(__v ? __np.truename() : __np.falsename()); 1538 string_type __nm = _VSTD::move(__tmp); 1539#else 1540 string_type __nm = __v ? __np.truename() : __np.falsename(); 1541#endif 1542 for (typename string_type::iterator __i = __nm.begin(); __i != __nm.end(); ++__i, ++__s) 1543 *__s = *__i; 1544 return __s; 1545} 1546 1547template <class _CharT, class _OutputIterator> 1548_OutputIterator 1549num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, 1550 char_type __fl, long __v) const 1551{ 1552 // Stage 1 - Get number in narrow char 1553 char __fmt[6] = {'%', 0}; 1554 const char* __len = "l"; 1555 this->__format_int(__fmt+1, __len, true, __iob.flags()); 1556 const unsigned __nbuf = (numeric_limits<long>::digits / 3) 1557 + ((numeric_limits<long>::digits % 3) != 0) 1558 + ((__iob.flags() & ios_base::showbase) != 0) 1559 + 2; 1560 char __nar[__nbuf]; 1561#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1562 int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); 1563#else 1564 int __nc = __snprintf_l(__nar, sizeof(__nar), __cloc(), __fmt, __v); 1565#endif 1566 char* __ne = __nar + __nc; 1567 char* __np = this->__identify_padding(__nar, __ne, __iob); 1568 // Stage 2 - Widen __nar while adding thousands separators 1569 char_type __o[2*(__nbuf-1) - 1]; 1570 char_type* __op; // pad here 1571 char_type* __oe; // end of output 1572 this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc()); 1573 // [__o, __oe) contains thousands_sep'd wide number 1574 // Stage 3 & 4 1575 return __pad_and_output(__s, __o, __op, __oe, __iob, __fl); 1576} 1577 1578template <class _CharT, class _OutputIterator> 1579_OutputIterator 1580num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, 1581 char_type __fl, long long __v) const 1582{ 1583 // Stage 1 - Get number in narrow char 1584 char __fmt[8] = {'%', 0}; 1585 const char* __len = "ll"; 1586 this->__format_int(__fmt+1, __len, true, __iob.flags()); 1587 const unsigned __nbuf = (numeric_limits<long long>::digits / 3) 1588 + ((numeric_limits<long long>::digits % 3) != 0) 1589 + ((__iob.flags() & ios_base::showbase) != 0) 1590 + 2; 1591 char __nar[__nbuf]; 1592#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1593 int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); 1594#else 1595 int __nc = __snprintf_l(__nar, sizeof(__nar), __cloc(), __fmt, __v); 1596#endif 1597 char* __ne = __nar + __nc; 1598 char* __np = this->__identify_padding(__nar, __ne, __iob); 1599 // Stage 2 - Widen __nar while adding thousands separators 1600 char_type __o[2*(__nbuf-1) - 1]; 1601 char_type* __op; // pad here 1602 char_type* __oe; // end of output 1603 this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc()); 1604 // [__o, __oe) contains thousands_sep'd wide number 1605 // Stage 3 & 4 1606 return __pad_and_output(__s, __o, __op, __oe, __iob, __fl); 1607} 1608 1609template <class _CharT, class _OutputIterator> 1610_OutputIterator 1611num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, 1612 char_type __fl, unsigned long __v) const 1613{ 1614 // Stage 1 - Get number in narrow char 1615 char __fmt[6] = {'%', 0}; 1616 const char* __len = "l"; 1617 this->__format_int(__fmt+1, __len, false, __iob.flags()); 1618 const unsigned __nbuf = (numeric_limits<unsigned long>::digits / 3) 1619 + ((numeric_limits<unsigned long>::digits % 3) != 0) 1620 + ((__iob.flags() & ios_base::showbase) != 0) 1621 + 1; 1622 char __nar[__nbuf]; 1623#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1624 int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); 1625#else 1626 int __nc = __snprintf_l(__nar, sizeof(__nar), __cloc(), __fmt, __v); 1627#endif 1628 char* __ne = __nar + __nc; 1629 char* __np = this->__identify_padding(__nar, __ne, __iob); 1630 // Stage 2 - Widen __nar while adding thousands separators 1631 char_type __o[2*(__nbuf-1) - 1]; 1632 char_type* __op; // pad here 1633 char_type* __oe; // end of output 1634 this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc()); 1635 // [__o, __oe) contains thousands_sep'd wide number 1636 // Stage 3 & 4 1637 return __pad_and_output(__s, __o, __op, __oe, __iob, __fl); 1638} 1639 1640template <class _CharT, class _OutputIterator> 1641_OutputIterator 1642num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, 1643 char_type __fl, unsigned long long __v) const 1644{ 1645 // Stage 1 - Get number in narrow char 1646 char __fmt[8] = {'%', 0}; 1647 const char* __len = "ll"; 1648 this->__format_int(__fmt+1, __len, false, __iob.flags()); 1649 const unsigned __nbuf = (numeric_limits<unsigned long long>::digits / 3) 1650 + ((numeric_limits<unsigned long long>::digits % 3) != 0) 1651 + ((__iob.flags() & ios_base::showbase) != 0) 1652 + 1; 1653 char __nar[__nbuf]; 1654#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1655 int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); 1656#else 1657 int __nc = __snprintf_l(__nar, sizeof(__nar), __cloc(), __fmt, __v); 1658#endif 1659 char* __ne = __nar + __nc; 1660 char* __np = this->__identify_padding(__nar, __ne, __iob); 1661 // Stage 2 - Widen __nar while adding thousands separators 1662 char_type __o[2*(__nbuf-1) - 1]; 1663 char_type* __op; // pad here 1664 char_type* __oe; // end of output 1665 this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc()); 1666 // [__o, __oe) contains thousands_sep'd wide number 1667 // Stage 3 & 4 1668 return __pad_and_output(__s, __o, __op, __oe, __iob, __fl); 1669} 1670 1671template <class _CharT, class _OutputIterator> 1672_OutputIterator 1673num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, 1674 char_type __fl, double __v) const 1675{ 1676 // Stage 1 - Get number in narrow char 1677 char __fmt[8] = {'%', 0}; 1678 const char* __len = ""; 1679 bool __specify_precision = this->__format_float(__fmt+1, __len, __iob.flags()); 1680 const unsigned __nbuf = 30; 1681 char __nar[__nbuf]; 1682 char* __nb = __nar; 1683 int __nc; 1684 if (__specify_precision) 1685#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1686 __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, 1687 (int)__iob.precision(), __v); 1688#else 1689 __nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt, 1690 (int)__iob.precision(), __v); 1691#endif 1692 else 1693#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1694 __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v); 1695#else 1696 __nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt, __v); 1697#endif 1698 unique_ptr<char, void(*)(void*)> __nbh(0, free); 1699 if (__nc > static_cast<int>(__nbuf-1)) 1700 { 1701 if (__specify_precision) 1702#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1703 __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v); 1704#else 1705 __nc = __asprintf_l(&__nb, __cloc(), __fmt, 1706 (int)__iob.precision(), __v); 1707#endif 1708 else 1709#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1710 __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v); 1711#else 1712 __nc = __asprintf_l(&__nb, __cloc(), __fmt, (int)__iob.precision(), __v); 1713#endif 1714 if (__nb == 0) 1715 __throw_bad_alloc(); 1716 __nbh.reset(__nb); 1717 } 1718 char* __ne = __nb + __nc; 1719 char* __np = this->__identify_padding(__nb, __ne, __iob); 1720 // Stage 2 - Widen __nar while adding thousands separators 1721 char_type __o[2*(__nbuf-1) - 1]; 1722 char_type* __ob = __o; 1723 unique_ptr<char_type, void(*)(void*)> __obh(0, free); 1724 if (__nb != __nar) 1725 { 1726 __ob = (char_type*)malloc(2*static_cast<size_t>(__nc)*sizeof(char_type)); 1727 if (__ob == 0) 1728 __throw_bad_alloc(); 1729 __obh.reset(__ob); 1730 } 1731 char_type* __op; // pad here 1732 char_type* __oe; // end of output 1733 this->__widen_and_group_float(__nb, __np, __ne, __ob, __op, __oe, __iob.getloc()); 1734 // [__o, __oe) contains thousands_sep'd wide number 1735 // Stage 3 & 4 1736 __s = __pad_and_output(__s, __ob, __op, __oe, __iob, __fl); 1737 return __s; 1738} 1739 1740template <class _CharT, class _OutputIterator> 1741_OutputIterator 1742num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, 1743 char_type __fl, long double __v) const 1744{ 1745 // Stage 1 - Get number in narrow char 1746 char __fmt[8] = {'%', 0}; 1747 const char* __len = "L"; 1748 bool __specify_precision = this->__format_float(__fmt+1, __len, __iob.flags()); 1749 const unsigned __nbuf = 30; 1750 char __nar[__nbuf]; 1751 char* __nb = __nar; 1752 int __nc; 1753 if (__specify_precision) 1754#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1755 __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, 1756 (int)__iob.precision(), __v); 1757#else 1758 __nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt, 1759 (int)__iob.precision(), __v); 1760#endif 1761 else 1762#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1763 __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v); 1764#else 1765 __nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt, __v); 1766#endif 1767 unique_ptr<char, void(*)(void*)> __nbh(0, free); 1768 if (__nc > static_cast<int>(__nbuf-1)) 1769 { 1770 if (__specify_precision) 1771#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1772 __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v); 1773#else 1774 __nc = __asprintf_l(&__nb, __cloc(), __fmt, 1775 (int)__iob.precision(), __v); 1776#endif 1777 else 1778#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1779 __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v); 1780#else 1781 __nc = __asprintf_l(&__nb, __cloc(), __fmt, __v); 1782#endif 1783 if (__nb == 0) 1784 __throw_bad_alloc(); 1785 __nbh.reset(__nb); 1786 } 1787 char* __ne = __nb + __nc; 1788 char* __np = this->__identify_padding(__nb, __ne, __iob); 1789 // Stage 2 - Widen __nar while adding thousands separators 1790 char_type __o[2*(__nbuf-1) - 1]; 1791 char_type* __ob = __o; 1792 unique_ptr<char_type, void(*)(void*)> __obh(0, free); 1793 if (__nb != __nar) 1794 { 1795 __ob = (char_type*)malloc(2*static_cast<size_t>(__nc)*sizeof(char_type)); 1796 if (__ob == 0) 1797 __throw_bad_alloc(); 1798 __obh.reset(__ob); 1799 } 1800 char_type* __op; // pad here 1801 char_type* __oe; // end of output 1802 this->__widen_and_group_float(__nb, __np, __ne, __ob, __op, __oe, __iob.getloc()); 1803 // [__o, __oe) contains thousands_sep'd wide number 1804 // Stage 3 & 4 1805 __s = __pad_and_output(__s, __ob, __op, __oe, __iob, __fl); 1806 return __s; 1807} 1808 1809template <class _CharT, class _OutputIterator> 1810_OutputIterator 1811num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, 1812 char_type __fl, const void* __v) const 1813{ 1814 // Stage 1 - Get pointer in narrow char 1815 char __fmt[6] = "%p"; 1816 const unsigned __nbuf = 20; 1817 char __nar[__nbuf]; 1818#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 1819 int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); 1820#else 1821 int __nc = __snprintf_l(__nar, sizeof(__nar), __cloc(), __fmt, __v); 1822#endif 1823 char* __ne = __nar + __nc; 1824 char* __np = this->__identify_padding(__nar, __ne, __iob); 1825 // Stage 2 - Widen __nar 1826 char_type __o[2*(__nbuf-1) - 1]; 1827 char_type* __op; // pad here 1828 char_type* __oe; // end of output 1829 const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc()); 1830 __ct.widen(__nar, __ne, __o); 1831 __oe = __o + (__ne - __nar); 1832 if (__np == __ne) 1833 __op = __oe; 1834 else 1835 __op = __o + (__np - __nar); 1836 // [__o, __oe) contains wide number 1837 // Stage 3 & 4 1838 return __pad_and_output(__s, __o, __op, __oe, __iob, __fl); 1839} 1840 1841_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS num_put<char>) 1842_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS num_put<wchar_t>) 1843 1844template <class _CharT, class _InputIterator> 1845_LIBCPP_HIDDEN 1846int 1847__get_up_to_n_digits(_InputIterator& __b, _InputIterator __e, 1848 ios_base::iostate& __err, const ctype<_CharT>& __ct, int __n) 1849{ 1850 // Precondition: __n >= 1 1851 if (__b == __e) 1852 { 1853 __err |= ios_base::eofbit | ios_base::failbit; 1854 return 0; 1855 } 1856 // get first digit 1857 _CharT __c = *__b; 1858 if (!__ct.is(ctype_base::digit, __c)) 1859 { 1860 __err |= ios_base::failbit; 1861 return 0; 1862 } 1863 int __r = __ct.narrow(__c, 0) - '0'; 1864 for (++__b, (void) --__n; __b != __e && __n > 0; ++__b, (void) --__n) 1865 { 1866 // get next digit 1867 __c = *__b; 1868 if (!__ct.is(ctype_base::digit, __c)) 1869 return __r; 1870 __r = __r * 10 + __ct.narrow(__c, 0) - '0'; 1871 } 1872 if (__b == __e) 1873 __err |= ios_base::eofbit; 1874 return __r; 1875} 1876 1877class _LIBCPP_TYPE_VIS time_base 1878{ 1879public: 1880 enum dateorder {no_order, dmy, mdy, ymd, ydm}; 1881}; 1882 1883template <class _CharT> 1884class _LIBCPP_TYPE_VIS_ONLY __time_get_c_storage 1885{ 1886protected: 1887 typedef basic_string<_CharT> string_type; 1888 1889 virtual const string_type* __weeks() const; 1890 virtual const string_type* __months() const; 1891 virtual const string_type* __am_pm() const; 1892 virtual const string_type& __c() const; 1893 virtual const string_type& __r() const; 1894 virtual const string_type& __x() const; 1895 virtual const string_type& __X() const; 1896}; 1897 1898template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > 1899class _LIBCPP_TYPE_VIS_ONLY time_get 1900 : public locale::facet, 1901 public time_base, 1902 private __time_get_c_storage<_CharT> 1903{ 1904public: 1905 typedef _CharT char_type; 1906 typedef _InputIterator iter_type; 1907 typedef time_base::dateorder dateorder; 1908 typedef basic_string<char_type> string_type; 1909 1910 _LIBCPP_ALWAYS_INLINE 1911 explicit time_get(size_t __refs = 0) 1912 : locale::facet(__refs) {} 1913 1914 _LIBCPP_ALWAYS_INLINE 1915 dateorder date_order() const 1916 { 1917 return this->do_date_order(); 1918 } 1919 1920 _LIBCPP_ALWAYS_INLINE 1921 iter_type get_time(iter_type __b, iter_type __e, ios_base& __iob, 1922 ios_base::iostate& __err, tm* __tm) const 1923 { 1924 return do_get_time(__b, __e, __iob, __err, __tm); 1925 } 1926 1927 _LIBCPP_ALWAYS_INLINE 1928 iter_type get_date(iter_type __b, iter_type __e, ios_base& __iob, 1929 ios_base::iostate& __err, tm* __tm) const 1930 { 1931 return do_get_date(__b, __e, __iob, __err, __tm); 1932 } 1933 1934 _LIBCPP_ALWAYS_INLINE 1935 iter_type get_weekday(iter_type __b, iter_type __e, ios_base& __iob, 1936 ios_base::iostate& __err, tm* __tm) const 1937 { 1938 return do_get_weekday(__b, __e, __iob, __err, __tm); 1939 } 1940 1941 _LIBCPP_ALWAYS_INLINE 1942 iter_type get_monthname(iter_type __b, iter_type __e, ios_base& __iob, 1943 ios_base::iostate& __err, tm* __tm) const 1944 { 1945 return do_get_monthname(__b, __e, __iob, __err, __tm); 1946 } 1947 1948 _LIBCPP_ALWAYS_INLINE 1949 iter_type get_year(iter_type __b, iter_type __e, ios_base& __iob, 1950 ios_base::iostate& __err, tm* __tm) const 1951 { 1952 return do_get_year(__b, __e, __iob, __err, __tm); 1953 } 1954 1955 _LIBCPP_ALWAYS_INLINE 1956 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 1957 ios_base::iostate& __err, tm *__tm, 1958 char __fmt, char __mod = 0) const 1959 { 1960 return do_get(__b, __e, __iob, __err, __tm, __fmt, __mod); 1961 } 1962 1963 iter_type get(iter_type __b, iter_type __e, ios_base& __iob, 1964 ios_base::iostate& __err, tm* __tm, 1965 const char_type* __fmtb, const char_type* __fmte) const; 1966 1967 static locale::id id; 1968 1969protected: 1970 _LIBCPP_ALWAYS_INLINE 1971 ~time_get() {} 1972 1973 virtual dateorder do_date_order() const; 1974 virtual iter_type do_get_time(iter_type __b, iter_type __e, ios_base& __iob, 1975 ios_base::iostate& __err, tm* __tm) const; 1976 virtual iter_type do_get_date(iter_type __b, iter_type __e, ios_base& __iob, 1977 ios_base::iostate& __err, tm* __tm) const; 1978 virtual iter_type do_get_weekday(iter_type __b, iter_type __e, ios_base& __iob, 1979 ios_base::iostate& __err, tm* __tm) const; 1980 virtual iter_type do_get_monthname(iter_type __b, iter_type __e, ios_base& __iob, 1981 ios_base::iostate& __err, tm* __tm) const; 1982 virtual iter_type do_get_year(iter_type __b, iter_type __e, ios_base& __iob, 1983 ios_base::iostate& __err, tm* __tm) const; 1984 virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, 1985 ios_base::iostate& __err, tm* __tm, 1986 char __fmt, char __mod) const; 1987private: 1988 void __get_white_space(iter_type& __b, iter_type __e, 1989 ios_base::iostate& __err, const ctype<char_type>& __ct) const; 1990 void __get_percent(iter_type& __b, iter_type __e, ios_base::iostate& __err, 1991 const ctype<char_type>& __ct) const; 1992 1993 void __get_weekdayname(int& __m, 1994 iter_type& __b, iter_type __e, 1995 ios_base::iostate& __err, 1996 const ctype<char_type>& __ct) const; 1997 void __get_monthname(int& __m, 1998 iter_type& __b, iter_type __e, 1999 ios_base::iostate& __err, 2000 const ctype<char_type>& __ct) const; 2001 void __get_day(int& __d, 2002 iter_type& __b, iter_type __e, 2003 ios_base::iostate& __err, 2004 const ctype<char_type>& __ct) const; 2005 void __get_month(int& __m, 2006 iter_type& __b, iter_type __e, 2007 ios_base::iostate& __err, 2008 const ctype<char_type>& __ct) const; 2009 void __get_year(int& __y, 2010 iter_type& __b, iter_type __e, 2011 ios_base::iostate& __err, 2012 const ctype<char_type>& __ct) const; 2013 void __get_year4(int& __y, 2014 iter_type& __b, iter_type __e, 2015 ios_base::iostate& __err, 2016 const ctype<char_type>& __ct) const; 2017 void __get_hour(int& __d, 2018 iter_type& __b, iter_type __e, 2019 ios_base::iostate& __err, 2020 const ctype<char_type>& __ct) const; 2021 void __get_12_hour(int& __h, 2022 iter_type& __b, iter_type __e, 2023 ios_base::iostate& __err, 2024 const ctype<char_type>& __ct) const; 2025 void __get_am_pm(int& __h, 2026 iter_type& __b, iter_type __e, 2027 ios_base::iostate& __err, 2028 const ctype<char_type>& __ct) const; 2029 void __get_minute(int& __m, 2030 iter_type& __b, iter_type __e, 2031 ios_base::iostate& __err, 2032 const ctype<char_type>& __ct) const; 2033 void __get_second(int& __s, 2034 iter_type& __b, iter_type __e, 2035 ios_base::iostate& __err, 2036 const ctype<char_type>& __ct) const; 2037 void __get_weekday(int& __w, 2038 iter_type& __b, iter_type __e, 2039 ios_base::iostate& __err, 2040 const ctype<char_type>& __ct) const; 2041 void __get_day_year_num(int& __w, 2042 iter_type& __b, iter_type __e, 2043 ios_base::iostate& __err, 2044 const ctype<char_type>& __ct) const; 2045}; 2046 2047template <class _CharT, class _InputIterator> 2048locale::id 2049time_get<_CharT, _InputIterator>::id; 2050 2051// time_get primitives 2052 2053template <class _CharT, class _InputIterator> 2054void 2055time_get<_CharT, _InputIterator>::__get_weekdayname(int& __w, 2056 iter_type& __b, iter_type __e, 2057 ios_base::iostate& __err, 2058 const ctype<char_type>& __ct) const 2059{ 2060 // Note: ignoring case comes from the POSIX strptime spec 2061 const string_type* __wk = this->__weeks(); 2062 ptrdiff_t __i = __scan_keyword(__b, __e, __wk, __wk+14, __ct, __err, false) - __wk; 2063 if (__i < 14) 2064 __w = __i % 7; 2065} 2066 2067template <class _CharT, class _InputIterator> 2068void 2069time_get<_CharT, _InputIterator>::__get_monthname(int& __m, 2070 iter_type& __b, iter_type __e, 2071 ios_base::iostate& __err, 2072 const ctype<char_type>& __ct) const 2073{ 2074 // Note: ignoring case comes from the POSIX strptime spec 2075 const string_type* __month = this->__months(); 2076 ptrdiff_t __i = __scan_keyword(__b, __e, __month, __month+24, __ct, __err, false) - __month; 2077 if (__i < 24) 2078 __m = __i % 12; 2079} 2080 2081template <class _CharT, class _InputIterator> 2082void 2083time_get<_CharT, _InputIterator>::__get_day(int& __d, 2084 iter_type& __b, iter_type __e, 2085 ios_base::iostate& __err, 2086 const ctype<char_type>& __ct) const 2087{ 2088 int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2); 2089 if (!(__err & ios_base::failbit) && 1 <= __t && __t <= 31) 2090 __d = __t; 2091 else 2092 __err |= ios_base::failbit; 2093} 2094 2095template <class _CharT, class _InputIterator> 2096void 2097time_get<_CharT, _InputIterator>::__get_month(int& __m, 2098 iter_type& __b, iter_type __e, 2099 ios_base::iostate& __err, 2100 const ctype<char_type>& __ct) const 2101{ 2102 int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2) - 1; 2103 if (!(__err & ios_base::failbit) && __t <= 11) 2104 __m = __t; 2105 else 2106 __err |= ios_base::failbit; 2107} 2108 2109template <class _CharT, class _InputIterator> 2110void 2111time_get<_CharT, _InputIterator>::__get_year(int& __y, 2112 iter_type& __b, iter_type __e, 2113 ios_base::iostate& __err, 2114 const ctype<char_type>& __ct) const 2115{ 2116 int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 4); 2117 if (!(__err & ios_base::failbit)) 2118 { 2119 if (__t < 69) 2120 __t += 2000; 2121 else if (69 <= __t && __t <= 99) 2122 __t += 1900; 2123 __y = __t - 1900; 2124 } 2125} 2126 2127template <class _CharT, class _InputIterator> 2128void 2129time_get<_CharT, _InputIterator>::__get_year4(int& __y, 2130 iter_type& __b, iter_type __e, 2131 ios_base::iostate& __err, 2132 const ctype<char_type>& __ct) const 2133{ 2134 int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 4); 2135 if (!(__err & ios_base::failbit)) 2136 __y = __t - 1900; 2137} 2138 2139template <class _CharT, class _InputIterator> 2140void 2141time_get<_CharT, _InputIterator>::__get_hour(int& __h, 2142 iter_type& __b, iter_type __e, 2143 ios_base::iostate& __err, 2144 const ctype<char_type>& __ct) const 2145{ 2146 int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2); 2147 if (!(__err & ios_base::failbit) && __t <= 23) 2148 __h = __t; 2149 else 2150 __err |= ios_base::failbit; 2151} 2152 2153template <class _CharT, class _InputIterator> 2154void 2155time_get<_CharT, _InputIterator>::__get_12_hour(int& __h, 2156 iter_type& __b, iter_type __e, 2157 ios_base::iostate& __err, 2158 const ctype<char_type>& __ct) const 2159{ 2160 int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2); 2161 if (!(__err & ios_base::failbit) && 1 <= __t && __t <= 12) 2162 __h = __t; 2163 else 2164 __err |= ios_base::failbit; 2165} 2166 2167template <class _CharT, class _InputIterator> 2168void 2169time_get<_CharT, _InputIterator>::__get_minute(int& __m, 2170 iter_type& __b, iter_type __e, 2171 ios_base::iostate& __err, 2172 const ctype<char_type>& __ct) const 2173{ 2174 int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2); 2175 if (!(__err & ios_base::failbit) && __t <= 59) 2176 __m = __t; 2177 else 2178 __err |= ios_base::failbit; 2179} 2180 2181template <class _CharT, class _InputIterator> 2182void 2183time_get<_CharT, _InputIterator>::__get_second(int& __s, 2184 iter_type& __b, iter_type __e, 2185 ios_base::iostate& __err, 2186 const ctype<char_type>& __ct) const 2187{ 2188 int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2); 2189 if (!(__err & ios_base::failbit) && __t <= 60) 2190 __s = __t; 2191 else 2192 __err |= ios_base::failbit; 2193} 2194 2195template <class _CharT, class _InputIterator> 2196void 2197time_get<_CharT, _InputIterator>::__get_weekday(int& __w, 2198 iter_type& __b, iter_type __e, 2199 ios_base::iostate& __err, 2200 const ctype<char_type>& __ct) const 2201{ 2202 int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 1); 2203 if (!(__err & ios_base::failbit) && __t <= 6) 2204 __w = __t; 2205 else 2206 __err |= ios_base::failbit; 2207} 2208 2209template <class _CharT, class _InputIterator> 2210void 2211time_get<_CharT, _InputIterator>::__get_day_year_num(int& __d, 2212 iter_type& __b, iter_type __e, 2213 ios_base::iostate& __err, 2214 const ctype<char_type>& __ct) const 2215{ 2216 int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 3); 2217 if (!(__err & ios_base::failbit) && __t <= 365) 2218 __d = __t; 2219 else 2220 __err |= ios_base::failbit; 2221} 2222 2223template <class _CharT, class _InputIterator> 2224void 2225time_get<_CharT, _InputIterator>::__get_white_space(iter_type& __b, iter_type __e, 2226 ios_base::iostate& __err, 2227 const ctype<char_type>& __ct) const 2228{ 2229 for (; __b != __e && __ct.is(ctype_base::space, *__b); ++__b) 2230 ; 2231 if (__b == __e) 2232 __err |= ios_base::eofbit; 2233} 2234 2235template <class _CharT, class _InputIterator> 2236void 2237time_get<_CharT, _InputIterator>::__get_am_pm(int& __h, 2238 iter_type& __b, iter_type __e, 2239 ios_base::iostate& __err, 2240 const ctype<char_type>& __ct) const 2241{ 2242 const string_type* __ap = this->__am_pm(); 2243 if (__ap[0].size() + __ap[1].size() == 0) 2244 { 2245 __err |= ios_base::failbit; 2246 return; 2247 } 2248 ptrdiff_t __i = __scan_keyword(__b, __e, __ap, __ap+2, __ct, __err, false) - __ap; 2249 if (__i == 0 && __h == 12) 2250 __h = 0; 2251 else if (__i == 1 && __h < 12) 2252 __h += 12; 2253} 2254 2255template <class _CharT, class _InputIterator> 2256void 2257time_get<_CharT, _InputIterator>::__get_percent(iter_type& __b, iter_type __e, 2258 ios_base::iostate& __err, 2259 const ctype<char_type>& __ct) const 2260{ 2261 if (__b == __e) 2262 { 2263 __err |= ios_base::eofbit | ios_base::failbit; 2264 return; 2265 } 2266 if (__ct.narrow(*__b, 0) != '%') 2267 __err |= ios_base::failbit; 2268 else if(++__b == __e) 2269 __err |= ios_base::eofbit; 2270} 2271 2272// time_get end primitives 2273 2274template <class _CharT, class _InputIterator> 2275_InputIterator 2276time_get<_CharT, _InputIterator>::get(iter_type __b, iter_type __e, 2277 ios_base& __iob, 2278 ios_base::iostate& __err, tm* __tm, 2279 const char_type* __fmtb, const char_type* __fmte) const 2280{ 2281 const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc()); 2282 __err = ios_base::goodbit; 2283 while (__fmtb != __fmte && __err == ios_base::goodbit) 2284 { 2285 if (__b == __e) 2286 { 2287 __err = ios_base::failbit; 2288 break; 2289 } 2290 if (__ct.narrow(*__fmtb, 0) == '%') 2291 { 2292 if (++__fmtb == __fmte) 2293 { 2294 __err = ios_base::failbit; 2295 break; 2296 } 2297 char __cmd = __ct.narrow(*__fmtb, 0); 2298 char __opt = '\0'; 2299 if (__cmd == 'E' || __cmd == '0') 2300 { 2301 if (++__fmtb == __fmte) 2302 { 2303 __err = ios_base::failbit; 2304 break; 2305 } 2306 __opt = __cmd; 2307 __cmd = __ct.narrow(*__fmtb, 0); 2308 } 2309 __b = do_get(__b, __e, __iob, __err, __tm, __cmd, __opt); 2310 ++__fmtb; 2311 } 2312 else if (__ct.is(ctype_base::space, *__fmtb)) 2313 { 2314 for (++__fmtb; __fmtb != __fmte && __ct.is(ctype_base::space, *__fmtb); ++__fmtb) 2315 ; 2316 for ( ; __b != __e && __ct.is(ctype_base::space, *__b); ++__b) 2317 ; 2318 } 2319 else if (__ct.toupper(*__b) == __ct.toupper(*__fmtb)) 2320 { 2321 ++__b; 2322 ++__fmtb; 2323 } 2324 else 2325 __err = ios_base::failbit; 2326 } 2327 if (__b == __e) 2328 __err |= ios_base::eofbit; 2329 return __b; 2330} 2331 2332template <class _CharT, class _InputIterator> 2333typename time_get<_CharT, _InputIterator>::dateorder 2334time_get<_CharT, _InputIterator>::do_date_order() const 2335{ 2336 return mdy; 2337} 2338 2339template <class _CharT, class _InputIterator> 2340_InputIterator 2341time_get<_CharT, _InputIterator>::do_get_time(iter_type __b, iter_type __e, 2342 ios_base& __iob, 2343 ios_base::iostate& __err, 2344 tm* __tm) const 2345{ 2346 const char_type __fmt[] = {'%', 'H', ':', '%', 'M', ':', '%', 'S'}; 2347 return get(__b, __e, __iob, __err, __tm, __fmt, __fmt + sizeof(__fmt)/sizeof(__fmt[0])); 2348} 2349 2350template <class _CharT, class _InputIterator> 2351_InputIterator 2352time_get<_CharT, _InputIterator>::do_get_date(iter_type __b, iter_type __e, 2353 ios_base& __iob, 2354 ios_base::iostate& __err, 2355 tm* __tm) const 2356{ 2357 const string_type& __fmt = this->__x(); 2358 return get(__b, __e, __iob, __err, __tm, __fmt.data(), __fmt.data() + __fmt.size()); 2359} 2360 2361template <class _CharT, class _InputIterator> 2362_InputIterator 2363time_get<_CharT, _InputIterator>::do_get_weekday(iter_type __b, iter_type __e, 2364 ios_base& __iob, 2365 ios_base::iostate& __err, 2366 tm* __tm) const 2367{ 2368 const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc()); 2369 __get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct); 2370 return __b; 2371} 2372 2373template <class _CharT, class _InputIterator> 2374_InputIterator 2375time_get<_CharT, _InputIterator>::do_get_monthname(iter_type __b, iter_type __e, 2376 ios_base& __iob, 2377 ios_base::iostate& __err, 2378 tm* __tm) const 2379{ 2380 const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc()); 2381 __get_monthname(__tm->tm_mon, __b, __e, __err, __ct); 2382 return __b; 2383} 2384 2385template <class _CharT, class _InputIterator> 2386_InputIterator 2387time_get<_CharT, _InputIterator>::do_get_year(iter_type __b, iter_type __e, 2388 ios_base& __iob, 2389 ios_base::iostate& __err, 2390 tm* __tm) const 2391{ 2392 const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc()); 2393 __get_year(__tm->tm_year, __b, __e, __err, __ct); 2394 return __b; 2395} 2396 2397template <class _CharT, class _InputIterator> 2398_InputIterator 2399time_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, 2400 ios_base& __iob, 2401 ios_base::iostate& __err, tm* __tm, 2402 char __fmt, char) const 2403{ 2404 __err = ios_base::goodbit; 2405 const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc()); 2406 switch (__fmt) 2407 { 2408 case 'a': 2409 case 'A': 2410 __get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct); 2411 break; 2412 case 'b': 2413 case 'B': 2414 case 'h': 2415 __get_monthname(__tm->tm_mon, __b, __e, __err, __ct); 2416 break; 2417 case 'c': 2418 { 2419 const string_type& __fm = this->__c(); 2420 __b = get(__b, __e, __iob, __err, __tm, __fm.data(), __fm.data() + __fm.size()); 2421 } 2422 break; 2423 case 'd': 2424 case 'e': 2425 __get_day(__tm->tm_mday, __b, __e, __err, __ct); 2426 break; 2427 case 'D': 2428 { 2429 const char_type __fm[] = {'%', 'm', '/', '%', 'd', '/', '%', 'y'}; 2430 __b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0])); 2431 } 2432 break; 2433 case 'F': 2434 { 2435 const char_type __fm[] = {'%', 'Y', '-', '%', 'm', '-', '%', 'd'}; 2436 __b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0])); 2437 } 2438 break; 2439 case 'H': 2440 __get_hour(__tm->tm_hour, __b, __e, __err, __ct); 2441 break; 2442 case 'I': 2443 __get_12_hour(__tm->tm_hour, __b, __e, __err, __ct); 2444 break; 2445 case 'j': 2446 __get_day_year_num(__tm->tm_yday, __b, __e, __err, __ct); 2447 break; 2448 case 'm': 2449 __get_month(__tm->tm_mon, __b, __e, __err, __ct); 2450 break; 2451 case 'M': 2452 __get_minute(__tm->tm_min, __b, __e, __err, __ct); 2453 break; 2454 case 'n': 2455 case 't': 2456 __get_white_space(__b, __e, __err, __ct); 2457 break; 2458 case 'p': 2459 __get_am_pm(__tm->tm_hour, __b, __e, __err, __ct); 2460 break; 2461 case 'r': 2462 { 2463 const char_type __fm[] = {'%', 'I', ':', '%', 'M', ':', '%', 'S', ' ', '%', 'p'}; 2464 __b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0])); 2465 } 2466 break; 2467 case 'R': 2468 { 2469 const char_type __fm[] = {'%', 'H', ':', '%', 'M'}; 2470 __b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0])); 2471 } 2472 break; 2473 case 'S': 2474 __get_second(__tm->tm_sec, __b, __e, __err, __ct); 2475 break; 2476 case 'T': 2477 { 2478 const char_type __fm[] = {'%', 'H', ':', '%', 'M', ':', '%', 'S'}; 2479 __b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0])); 2480 } 2481 break; 2482 case 'w': 2483 __get_weekday(__tm->tm_wday, __b, __e, __err, __ct); 2484 break; 2485 case 'x': 2486 return do_get_date(__b, __e, __iob, __err, __tm); 2487 case 'X': 2488 { 2489 const string_type& __fm = this->__X(); 2490 __b = get(__b, __e, __iob, __err, __tm, __fm.data(), __fm.data() + __fm.size()); 2491 } 2492 break; 2493 case 'y': 2494 __get_year(__tm->tm_year, __b, __e, __err, __ct); 2495 break; 2496 case 'Y': 2497 __get_year4(__tm->tm_year, __b, __e, __err, __ct); 2498 break; 2499 case '%': 2500 __get_percent(__b, __e, __err, __ct); 2501 break; 2502 default: 2503 __err |= ios_base::failbit; 2504 } 2505 return __b; 2506} 2507 2508_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_get<char>) 2509_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_get<wchar_t>) 2510 2511class _LIBCPP_TYPE_VIS __time_get 2512{ 2513protected: 2514 locale_t __loc_; 2515 2516 __time_get(const char* __nm); 2517 __time_get(const string& __nm); 2518 ~__time_get(); 2519}; 2520 2521template <class _CharT> 2522class _LIBCPP_TYPE_VIS_ONLY __time_get_storage 2523 : public __time_get 2524{ 2525protected: 2526 typedef basic_string<_CharT> string_type; 2527 2528 string_type __weeks_[14]; 2529 string_type __months_[24]; 2530 string_type __am_pm_[2]; 2531 string_type __c_; 2532 string_type __r_; 2533 string_type __x_; 2534 string_type __X_; 2535 2536 explicit __time_get_storage(const char* __nm); 2537 explicit __time_get_storage(const string& __nm); 2538 2539 _LIBCPP_ALWAYS_INLINE ~__time_get_storage() {} 2540 2541 time_base::dateorder __do_date_order() const; 2542 2543private: 2544 void init(const ctype<_CharT>&); 2545 string_type __analyze(char __fmt, const ctype<_CharT>&); 2546}; 2547 2548template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > 2549class _LIBCPP_TYPE_VIS_ONLY time_get_byname 2550 : public time_get<_CharT, _InputIterator>, 2551 private __time_get_storage<_CharT> 2552{ 2553public: 2554 typedef time_base::dateorder dateorder; 2555 typedef _InputIterator iter_type; 2556 typedef _CharT char_type; 2557 typedef basic_string<char_type> string_type; 2558 2559 _LIBCPP_INLINE_VISIBILITY 2560 explicit time_get_byname(const char* __nm, size_t __refs = 0) 2561 : time_get<_CharT, _InputIterator>(__refs), 2562 __time_get_storage<_CharT>(__nm) {} 2563 _LIBCPP_INLINE_VISIBILITY 2564 explicit time_get_byname(const string& __nm, size_t __refs = 0) 2565 : time_get<_CharT, _InputIterator>(__refs), 2566 __time_get_storage<_CharT>(__nm) {} 2567 2568protected: 2569 _LIBCPP_INLINE_VISIBILITY 2570 ~time_get_byname() {} 2571 2572 _LIBCPP_INLINE_VISIBILITY 2573 virtual dateorder do_date_order() const {return this->__do_date_order();} 2574private: 2575 _LIBCPP_INLINE_VISIBILITY 2576 virtual const string_type* __weeks() const {return this->__weeks_;} 2577 _LIBCPP_INLINE_VISIBILITY 2578 virtual const string_type* __months() const {return this->__months_;} 2579 _LIBCPP_INLINE_VISIBILITY 2580 virtual const string_type* __am_pm() const {return this->__am_pm_;} 2581 _LIBCPP_INLINE_VISIBILITY 2582 virtual const string_type& __c() const {return this->__c_;} 2583 _LIBCPP_INLINE_VISIBILITY 2584 virtual const string_type& __r() const {return this->__r_;} 2585 _LIBCPP_INLINE_VISIBILITY 2586 virtual const string_type& __x() const {return this->__x_;} 2587 _LIBCPP_INLINE_VISIBILITY 2588 virtual const string_type& __X() const {return this->__X_;} 2589}; 2590 2591_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_get_byname<char>) 2592_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_get_byname<wchar_t>) 2593 2594class _LIBCPP_TYPE_VIS __time_put 2595{ 2596 locale_t __loc_; 2597protected: 2598 _LIBCPP_ALWAYS_INLINE __time_put() : __loc_(_LIBCPP_GET_C_LOCALE) {} 2599 __time_put(const char* __nm); 2600 __time_put(const string& __nm); 2601 ~__time_put(); 2602 void __do_put(char* __nb, char*& __ne, const tm* __tm, 2603 char __fmt, char __mod) const; 2604 void __do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm, 2605 char __fmt, char __mod) const; 2606}; 2607 2608template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > 2609class _LIBCPP_TYPE_VIS_ONLY time_put 2610 : public locale::facet, 2611 private __time_put 2612{ 2613public: 2614 typedef _CharT char_type; 2615 typedef _OutputIterator iter_type; 2616 2617 _LIBCPP_ALWAYS_INLINE 2618 explicit time_put(size_t __refs = 0) 2619 : locale::facet(__refs) {} 2620 2621 iter_type put(iter_type __s, ios_base& __iob, char_type __fl, const tm* __tm, 2622 const char_type* __pb, const char_type* __pe) const; 2623 2624 _LIBCPP_ALWAYS_INLINE 2625 iter_type put(iter_type __s, ios_base& __iob, char_type __fl, 2626 const tm* __tm, char __fmt, char __mod = 0) const 2627 { 2628 return do_put(__s, __iob, __fl, __tm, __fmt, __mod); 2629 } 2630 2631 static locale::id id; 2632 2633protected: 2634 _LIBCPP_ALWAYS_INLINE 2635 ~time_put() {} 2636 virtual iter_type do_put(iter_type __s, ios_base&, char_type, const tm* __tm, 2637 char __fmt, char __mod) const; 2638 2639 _LIBCPP_ALWAYS_INLINE 2640 explicit time_put(const char* __nm, size_t __refs) 2641 : locale::facet(__refs), 2642 __time_put(__nm) {} 2643 _LIBCPP_ALWAYS_INLINE 2644 explicit time_put(const string& __nm, size_t __refs) 2645 : locale::facet(__refs), 2646 __time_put(__nm) {} 2647}; 2648 2649template <class _CharT, class _OutputIterator> 2650locale::id 2651time_put<_CharT, _OutputIterator>::id; 2652 2653template <class _CharT, class _OutputIterator> 2654_OutputIterator 2655time_put<_CharT, _OutputIterator>::put(iter_type __s, ios_base& __iob, 2656 char_type __fl, const tm* __tm, 2657 const char_type* __pb, 2658 const char_type* __pe) const 2659{ 2660 const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc()); 2661 for (; __pb != __pe; ++__pb) 2662 { 2663 if (__ct.narrow(*__pb, 0) == '%') 2664 { 2665 if (++__pb == __pe) 2666 { 2667 *__s++ = __pb[-1]; 2668 break; 2669 } 2670 char __mod = 0; 2671 char __fmt = __ct.narrow(*__pb, 0); 2672 if (__fmt == 'E' || __fmt == 'O') 2673 { 2674 if (++__pb == __pe) 2675 { 2676 *__s++ = __pb[-2]; 2677 *__s++ = __pb[-1]; 2678 break; 2679 } 2680 __mod = __fmt; 2681 __fmt = __ct.narrow(*__pb, 0); 2682 } 2683 __s = do_put(__s, __iob, __fl, __tm, __fmt, __mod); 2684 } 2685 else 2686 *__s++ = *__pb; 2687 } 2688 return __s; 2689} 2690 2691template <class _CharT, class _OutputIterator> 2692_OutputIterator 2693time_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base&, 2694 char_type, const tm* __tm, 2695 char __fmt, char __mod) const 2696{ 2697 char_type __nar[100]; 2698 char_type* __nb = __nar; 2699 char_type* __ne = __nb + 100; 2700 __do_put(__nb, __ne, __tm, __fmt, __mod); 2701 return _VSTD::copy(__nb, __ne, __s); 2702} 2703 2704_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_put<char>) 2705_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_put<wchar_t>) 2706 2707template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > 2708class _LIBCPP_TYPE_VIS_ONLY time_put_byname 2709 : public time_put<_CharT, _OutputIterator> 2710{ 2711public: 2712 _LIBCPP_ALWAYS_INLINE 2713 explicit time_put_byname(const char* __nm, size_t __refs = 0) 2714 : time_put<_CharT, _OutputIterator>(__nm, __refs) {} 2715 2716 _LIBCPP_ALWAYS_INLINE 2717 explicit time_put_byname(const string& __nm, size_t __refs = 0) 2718 : time_put<_CharT, _OutputIterator>(__nm, __refs) {} 2719 2720protected: 2721 _LIBCPP_ALWAYS_INLINE 2722 ~time_put_byname() {} 2723}; 2724 2725_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_put_byname<char>) 2726_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_put_byname<wchar_t>) 2727 2728// money_base 2729 2730class _LIBCPP_TYPE_VIS money_base 2731{ 2732public: 2733 enum part {none, space, symbol, sign, value}; 2734 struct pattern {char field[4];}; 2735 2736 _LIBCPP_ALWAYS_INLINE money_base() {} 2737}; 2738 2739// moneypunct 2740 2741template <class _CharT, bool _International = false> 2742class _LIBCPP_TYPE_VIS_ONLY moneypunct 2743 : public locale::facet, 2744 public money_base 2745{ 2746public: 2747 typedef _CharT char_type; 2748 typedef basic_string<char_type> string_type; 2749 2750 _LIBCPP_ALWAYS_INLINE 2751 explicit moneypunct(size_t __refs = 0) 2752 : locale::facet(__refs) {} 2753 2754 _LIBCPP_ALWAYS_INLINE char_type decimal_point() const {return do_decimal_point();} 2755 _LIBCPP_ALWAYS_INLINE char_type thousands_sep() const {return do_thousands_sep();} 2756 _LIBCPP_ALWAYS_INLINE string grouping() const {return do_grouping();} 2757 _LIBCPP_ALWAYS_INLINE string_type curr_symbol() const {return do_curr_symbol();} 2758 _LIBCPP_ALWAYS_INLINE string_type positive_sign() const {return do_positive_sign();} 2759 _LIBCPP_ALWAYS_INLINE string_type negative_sign() const {return do_negative_sign();} 2760 _LIBCPP_ALWAYS_INLINE int frac_digits() const {return do_frac_digits();} 2761 _LIBCPP_ALWAYS_INLINE pattern pos_format() const {return do_pos_format();} 2762 _LIBCPP_ALWAYS_INLINE pattern neg_format() const {return do_neg_format();} 2763 2764 static locale::id id; 2765 static const bool intl = _International; 2766 2767protected: 2768 _LIBCPP_ALWAYS_INLINE 2769 ~moneypunct() {} 2770 2771 virtual char_type do_decimal_point() const {return numeric_limits<char_type>::max();} 2772 virtual char_type do_thousands_sep() const {return numeric_limits<char_type>::max();} 2773 virtual string do_grouping() const {return string();} 2774 virtual string_type do_curr_symbol() const {return string_type();} 2775 virtual string_type do_positive_sign() const {return string_type();} 2776 virtual string_type do_negative_sign() const {return string_type(1, '-');} 2777 virtual int do_frac_digits() const {return 0;} 2778 virtual pattern do_pos_format() const 2779 {pattern __p = {{symbol, sign, none, value}}; return __p;} 2780 virtual pattern do_neg_format() const 2781 {pattern __p = {{symbol, sign, none, value}}; return __p;} 2782}; 2783 2784template <class _CharT, bool _International> 2785locale::id 2786moneypunct<_CharT, _International>::id; 2787 2788template <class _CharT, bool _International> 2789const bool 2790moneypunct<_CharT, _International>::intl; 2791 2792_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct<char, false>) 2793_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct<char, true>) 2794_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct<wchar_t, false>) 2795_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct<wchar_t, true>) 2796 2797// moneypunct_byname 2798 2799template <class _CharT, bool _International = false> 2800class _LIBCPP_TYPE_VIS_ONLY moneypunct_byname 2801 : public moneypunct<_CharT, _International> 2802{ 2803public: 2804 typedef money_base::pattern pattern; 2805 typedef _CharT char_type; 2806 typedef basic_string<char_type> string_type; 2807 2808 _LIBCPP_ALWAYS_INLINE 2809 explicit moneypunct_byname(const char* __nm, size_t __refs = 0) 2810 : moneypunct<_CharT, _International>(__refs) {init(__nm);} 2811 2812 _LIBCPP_ALWAYS_INLINE 2813 explicit moneypunct_byname(const string& __nm, size_t __refs = 0) 2814 : moneypunct<_CharT, _International>(__refs) {init(__nm.c_str());} 2815 2816protected: 2817 _LIBCPP_ALWAYS_INLINE 2818 ~moneypunct_byname() {} 2819 2820 virtual char_type do_decimal_point() const {return __decimal_point_;} 2821 virtual char_type do_thousands_sep() const {return __thousands_sep_;} 2822 virtual string do_grouping() const {return __grouping_;} 2823 virtual string_type do_curr_symbol() const {return __curr_symbol_;} 2824 virtual string_type do_positive_sign() const {return __positive_sign_;} 2825 virtual string_type do_negative_sign() const {return __negative_sign_;} 2826 virtual int do_frac_digits() const {return __frac_digits_;} 2827 virtual pattern do_pos_format() const {return __pos_format_;} 2828 virtual pattern do_neg_format() const {return __neg_format_;} 2829 2830private: 2831 char_type __decimal_point_; 2832 char_type __thousands_sep_; 2833 string __grouping_; 2834 string_type __curr_symbol_; 2835 string_type __positive_sign_; 2836 string_type __negative_sign_; 2837 int __frac_digits_; 2838 pattern __pos_format_; 2839 pattern __neg_format_; 2840 2841 void init(const char*); 2842}; 2843 2844template<> void moneypunct_byname<char, false>::init(const char*); 2845template<> void moneypunct_byname<char, true>::init(const char*); 2846template<> void moneypunct_byname<wchar_t, false>::init(const char*); 2847template<> void moneypunct_byname<wchar_t, true>::init(const char*); 2848 2849_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct_byname<char, false>) 2850_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct_byname<char, true>) 2851_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct_byname<wchar_t, false>) 2852_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct_byname<wchar_t, true>) 2853 2854// money_get 2855 2856template <class _CharT> 2857class __money_get 2858{ 2859protected: 2860 typedef _CharT char_type; 2861 typedef basic_string<char_type> string_type; 2862 2863 _LIBCPP_ALWAYS_INLINE __money_get() {} 2864 2865 static void __gather_info(bool __intl, const locale& __loc, 2866 money_base::pattern& __pat, char_type& __dp, 2867 char_type& __ts, string& __grp, 2868 string_type& __sym, string_type& __psn, 2869 string_type& __nsn, int& __fd); 2870}; 2871 2872template <class _CharT> 2873void 2874__money_get<_CharT>::__gather_info(bool __intl, const locale& __loc, 2875 money_base::pattern& __pat, char_type& __dp, 2876 char_type& __ts, string& __grp, 2877 string_type& __sym, string_type& __psn, 2878 string_type& __nsn, int& __fd) 2879{ 2880 if (__intl) 2881 { 2882 const moneypunct<char_type, true>& __mp = 2883 use_facet<moneypunct<char_type, true> >(__loc); 2884 __pat = __mp.neg_format(); 2885 __nsn = __mp.negative_sign(); 2886 __psn = __mp.positive_sign(); 2887 __dp = __mp.decimal_point(); 2888 __ts = __mp.thousands_sep(); 2889 __grp = __mp.grouping(); 2890 __sym = __mp.curr_symbol(); 2891 __fd = __mp.frac_digits(); 2892 } 2893 else 2894 { 2895 const moneypunct<char_type, false>& __mp = 2896 use_facet<moneypunct<char_type, false> >(__loc); 2897 __pat = __mp.neg_format(); 2898 __nsn = __mp.negative_sign(); 2899 __psn = __mp.positive_sign(); 2900 __dp = __mp.decimal_point(); 2901 __ts = __mp.thousands_sep(); 2902 __grp = __mp.grouping(); 2903 __sym = __mp.curr_symbol(); 2904 __fd = __mp.frac_digits(); 2905 } 2906} 2907 2908_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS __money_get<char>) 2909_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS __money_get<wchar_t>) 2910 2911template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > 2912class _LIBCPP_TYPE_VIS_ONLY money_get 2913 : public locale::facet, 2914 private __money_get<_CharT> 2915{ 2916public: 2917 typedef _CharT char_type; 2918 typedef _InputIterator iter_type; 2919 typedef basic_string<char_type> string_type; 2920 2921 _LIBCPP_ALWAYS_INLINE 2922 explicit money_get(size_t __refs = 0) 2923 : locale::facet(__refs) {} 2924 2925 _LIBCPP_ALWAYS_INLINE 2926 iter_type get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, 2927 ios_base::iostate& __err, long double& __v) const 2928 { 2929 return do_get(__b, __e, __intl, __iob, __err, __v); 2930 } 2931 2932 _LIBCPP_ALWAYS_INLINE 2933 iter_type get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, 2934 ios_base::iostate& __err, string_type& __v) const 2935 { 2936 return do_get(__b, __e, __intl, __iob, __err, __v); 2937 } 2938 2939 static locale::id id; 2940 2941protected: 2942 2943 _LIBCPP_ALWAYS_INLINE 2944 ~money_get() {} 2945 2946 virtual iter_type do_get(iter_type __b, iter_type __e, bool __intl, 2947 ios_base& __iob, ios_base::iostate& __err, 2948 long double& __v) const; 2949 virtual iter_type do_get(iter_type __b, iter_type __e, bool __intl, 2950 ios_base& __iob, ios_base::iostate& __err, 2951 string_type& __v) const; 2952 2953private: 2954 static bool __do_get(iter_type& __b, iter_type __e, 2955 bool __intl, const locale& __loc, 2956 ios_base::fmtflags __flags, ios_base::iostate& __err, 2957 bool& __neg, const ctype<char_type>& __ct, 2958 unique_ptr<char_type, void(*)(void*)>& __wb, 2959 char_type*& __wn, char_type* __we); 2960}; 2961 2962template <class _CharT, class _InputIterator> 2963locale::id 2964money_get<_CharT, _InputIterator>::id; 2965 2966_LIBCPP_FUNC_VIS void __do_nothing(void*); 2967 2968template <class _Tp> 2969_LIBCPP_HIDDEN 2970void 2971__double_or_nothing(unique_ptr<_Tp, void(*)(void*)>& __b, _Tp*& __n, _Tp*& __e) 2972{ 2973 bool __owns = __b.get_deleter() != __do_nothing; 2974 size_t __cur_cap = static_cast<size_t>(__e-__b.get()) * sizeof(_Tp); 2975 size_t __new_cap = __cur_cap < numeric_limits<size_t>::max() / 2 ? 2976 2 * __cur_cap : numeric_limits<size_t>::max(); 2977 if (__new_cap == 0) 2978 __new_cap = sizeof(_Tp); 2979 size_t __n_off = static_cast<size_t>(__n - __b.get()); 2980 _Tp* __t = (_Tp*)realloc(__owns ? __b.get() : 0, __new_cap); 2981 if (__t == 0) 2982 __throw_bad_alloc(); 2983 if (__owns) 2984 __b.release(); 2985 __b = unique_ptr<_Tp, void(*)(void*)>(__t, free); 2986 __new_cap /= sizeof(_Tp); 2987 __n = __b.get() + __n_off; 2988 __e = __b.get() + __new_cap; 2989} 2990 2991// true == success 2992template <class _CharT, class _InputIterator> 2993bool 2994money_get<_CharT, _InputIterator>::__do_get(iter_type& __b, iter_type __e, 2995 bool __intl, const locale& __loc, 2996 ios_base::fmtflags __flags, 2997 ios_base::iostate& __err, 2998 bool& __neg, 2999 const ctype<char_type>& __ct, 3000 unique_ptr<char_type, void(*)(void*)>& __wb, 3001 char_type*& __wn, char_type* __we) 3002{ 3003 const unsigned __bz = 100; 3004 unsigned __gbuf[__bz]; 3005 unique_ptr<unsigned, void(*)(void*)> __gb(__gbuf, __do_nothing); 3006 unsigned* __gn = __gb.get(); 3007 unsigned* __ge = __gn + __bz; 3008 money_base::pattern __pat; 3009 char_type __dp; 3010 char_type __ts; 3011 string __grp; 3012 string_type __sym; 3013 string_type __psn; 3014 string_type __nsn; 3015 // Capture the spaces read into money_base::{space,none} so they 3016 // can be compared to initial spaces in __sym. 3017 string_type __spaces; 3018 int __fd; 3019 __money_get<_CharT>::__gather_info(__intl, __loc, __pat, __dp, __ts, __grp, 3020 __sym, __psn, __nsn, __fd); 3021 const string_type* __trailing_sign = 0; 3022 __wn = __wb.get(); 3023 for (unsigned __p = 0; __p < 4 && __b != __e; ++__p) 3024 { 3025 switch (__pat.field[__p]) 3026 { 3027 case money_base::space: 3028 if (__p != 3) 3029 { 3030 if (__ct.is(ctype_base::space, *__b)) 3031 __spaces.push_back(*__b++); 3032 else 3033 { 3034 __err |= ios_base::failbit; 3035 return false; 3036 } 3037 } 3038 // drop through 3039 case money_base::none: 3040 if (__p != 3) 3041 { 3042 while (__b != __e && __ct.is(ctype_base::space, *__b)) 3043 __spaces.push_back(*__b++); 3044 } 3045 break; 3046 case money_base::sign: 3047 if (__psn.size() + __nsn.size() > 0) 3048 { 3049 if (__psn.size() == 0 || __nsn.size() == 0) 3050 { // sign is optional 3051 if (__psn.size() > 0) 3052 { // __nsn.size() == 0 3053 if (*__b == __psn[0]) 3054 { 3055 ++__b; 3056 if (__psn.size() > 1) 3057 __trailing_sign = &__psn; 3058 } 3059 else 3060 __neg = true; 3061 } 3062 else if (*__b == __nsn[0]) // __nsn.size() > 0 && __psn.size() == 0 3063 { 3064 ++__b; 3065 __neg = true; 3066 if (__nsn.size() > 1) 3067 __trailing_sign = &__nsn; 3068 } 3069 } 3070 else // sign is required 3071 { 3072 if (*__b == __psn[0]) 3073 { 3074 ++__b; 3075 if (__psn.size() > 1) 3076 __trailing_sign = &__psn; 3077 } 3078 else if (*__b == __nsn[0]) 3079 { 3080 ++__b; 3081 __neg = true; 3082 if (__nsn.size() > 1) 3083 __trailing_sign = &__nsn; 3084 } 3085 else 3086 { 3087 __err |= ios_base::failbit; 3088 return false; 3089 } 3090 } 3091 } 3092 break; 3093 case money_base::symbol: 3094 { 3095 bool __more_needed = __trailing_sign || 3096 (__p < 2) || 3097 (__p == 2 && __pat.field[3] != static_cast<char>(money_base::none)); 3098 bool __sb = (__flags & ios_base::showbase) != 0; 3099 if (__sb || __more_needed) 3100 { 3101 typename string_type::const_iterator __sym_space_end = __sym.begin(); 3102 if (__p > 0 && (__pat.field[__p - 1] == money_base::none || 3103 __pat.field[__p - 1] == money_base::space)) { 3104 // Match spaces we've already read against spaces at 3105 // the beginning of __sym. 3106 while (__sym_space_end != __sym.end() && 3107 __ct.is(ctype_base::space, *__sym_space_end)) 3108 ++__sym_space_end; 3109 const size_t __num_spaces = __sym_space_end - __sym.begin(); 3110 if (__num_spaces > __spaces.size() || 3111 !equal(__spaces.end() - __num_spaces, __spaces.end(), 3112 __sym.begin())) { 3113 // No match. Put __sym_space_end back at the 3114 // beginning of __sym, which will prevent a 3115 // match in the next loop. 3116 __sym_space_end = __sym.begin(); 3117 } 3118 } 3119 typename string_type::const_iterator __sym_curr_char = __sym_space_end; 3120 while (__sym_curr_char != __sym.end() && __b != __e && 3121 *__b == *__sym_curr_char) { 3122 ++__b; 3123 ++__sym_curr_char; 3124 } 3125 if (__sb && __sym_curr_char != __sym.end()) 3126 { 3127 __err |= ios_base::failbit; 3128 return false; 3129 } 3130 } 3131 } 3132 break; 3133 case money_base::value: 3134 { 3135 unsigned __ng = 0; 3136 for (; __b != __e; ++__b) 3137 { 3138 char_type __c = *__b; 3139 if (__ct.is(ctype_base::digit, __c)) 3140 { 3141 if (__wn == __we) 3142 __double_or_nothing(__wb, __wn, __we); 3143 *__wn++ = __c; 3144 ++__ng; 3145 } 3146 else if (__grp.size() > 0 && __ng > 0 && __c == __ts) 3147 { 3148 if (__gn == __ge) 3149 __double_or_nothing(__gb, __gn, __ge); 3150 *__gn++ = __ng; 3151 __ng = 0; 3152 } 3153 else 3154 break; 3155 } 3156 if (__gb.get() != __gn && __ng > 0) 3157 { 3158 if (__gn == __ge) 3159 __double_or_nothing(__gb, __gn, __ge); 3160 *__gn++ = __ng; 3161 } 3162 if (__fd > 0) 3163 { 3164 if (__b == __e || *__b != __dp) 3165 { 3166 __err |= ios_base::failbit; 3167 return false; 3168 } 3169 for (++__b; __fd > 0; --__fd, ++__b) 3170 { 3171 if (__b == __e || !__ct.is(ctype_base::digit, *__b)) 3172 { 3173 __err |= ios_base::failbit; 3174 return false; 3175 } 3176 if (__wn == __we) 3177 __double_or_nothing(__wb, __wn, __we); 3178 *__wn++ = *__b; 3179 } 3180 } 3181 if (__wn == __wb.get()) 3182 { 3183 __err |= ios_base::failbit; 3184 return false; 3185 } 3186 } 3187 break; 3188 } 3189 } 3190 if (__trailing_sign) 3191 { 3192 for (unsigned __i = 1; __i < __trailing_sign->size(); ++__i, ++__b) 3193 { 3194 if (__b == __e || *__b != (*__trailing_sign)[__i]) 3195 { 3196 __err |= ios_base::failbit; 3197 return false; 3198 } 3199 } 3200 } 3201 if (__gb.get() != __gn) 3202 { 3203 ios_base::iostate __et = ios_base::goodbit; 3204 __check_grouping(__grp, __gb.get(), __gn, __et); 3205 if (__et) 3206 { 3207 __err |= ios_base::failbit; 3208 return false; 3209 } 3210 } 3211 return true; 3212} 3213 3214template <class _CharT, class _InputIterator> 3215_InputIterator 3216money_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, 3217 bool __intl, ios_base& __iob, 3218 ios_base::iostate& __err, 3219 long double& __v) const 3220{ 3221 const int __bz = 100; 3222 char_type __wbuf[__bz]; 3223 unique_ptr<char_type, void(*)(void*)> __wb(__wbuf, __do_nothing); 3224 char_type* __wn; 3225 char_type* __we = __wbuf + __bz; 3226 locale __loc = __iob.getloc(); 3227 const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc); 3228 bool __neg = false; 3229 if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct, 3230 __wb, __wn, __we)) 3231 { 3232 const char __src[] = "0123456789"; 3233 char_type __atoms[sizeof(__src)-1]; 3234 __ct.widen(__src, __src + (sizeof(__src)-1), __atoms); 3235 char __nbuf[__bz]; 3236 char* __nc = __nbuf; 3237 unique_ptr<char, void(*)(void*)> __h(0, free); 3238 if (__wn - __wb.get() > __bz-2) 3239 { 3240 __h.reset((char*)malloc(static_cast<size_t>(__wn - __wb.get() + 2))); 3241 if (__h.get() == 0) 3242 __throw_bad_alloc(); 3243 __nc = __h.get(); 3244 } 3245 if (__neg) 3246 *__nc++ = '-'; 3247 for (const char_type* __w = __wb.get(); __w < __wn; ++__w, ++__nc) 3248 *__nc = __src[find(__atoms, _VSTD::end(__atoms), *__w) - __atoms]; 3249 *__nc = char(); 3250 if (sscanf(__nbuf, "%Lf", &__v) != 1) 3251 __throw_runtime_error("money_get error"); 3252 } 3253 if (__b == __e) 3254 __err |= ios_base::eofbit; 3255 return __b; 3256} 3257 3258template <class _CharT, class _InputIterator> 3259_InputIterator 3260money_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, 3261 bool __intl, ios_base& __iob, 3262 ios_base::iostate& __err, 3263 string_type& __v) const 3264{ 3265 const int __bz = 100; 3266 char_type __wbuf[__bz]; 3267 unique_ptr<char_type, void(*)(void*)> __wb(__wbuf, __do_nothing); 3268 char_type* __wn; 3269 char_type* __we = __wbuf + __bz; 3270 locale __loc = __iob.getloc(); 3271 const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc); 3272 bool __neg = false; 3273 if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct, 3274 __wb, __wn, __we)) 3275 { 3276 __v.clear(); 3277 if (__neg) 3278 __v.push_back(__ct.widen('-')); 3279 char_type __z = __ct.widen('0'); 3280 char_type* __w; 3281 for (__w = __wb.get(); __w < __wn-1; ++__w) 3282 if (*__w != __z) 3283 break; 3284 __v.append(__w, __wn); 3285 } 3286 if (__b == __e) 3287 __err |= ios_base::eofbit; 3288 return __b; 3289} 3290 3291_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS money_get<char>) 3292_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS money_get<wchar_t>) 3293 3294// money_put 3295 3296template <class _CharT> 3297class __money_put 3298{ 3299protected: 3300 typedef _CharT char_type; 3301 typedef basic_string<char_type> string_type; 3302 3303 _LIBCPP_ALWAYS_INLINE __money_put() {} 3304 3305 static void __gather_info(bool __intl, bool __neg, const locale& __loc, 3306 money_base::pattern& __pat, char_type& __dp, 3307 char_type& __ts, string& __grp, 3308 string_type& __sym, string_type& __sn, 3309 int& __fd); 3310 static void __format(char_type* __mb, char_type*& __mi, char_type*& __me, 3311 ios_base::fmtflags __flags, 3312 const char_type* __db, const char_type* __de, 3313 const ctype<char_type>& __ct, bool __neg, 3314 const money_base::pattern& __pat, char_type __dp, 3315 char_type __ts, const string& __grp, 3316 const string_type& __sym, const string_type& __sn, 3317 int __fd); 3318}; 3319 3320template <class _CharT> 3321void 3322__money_put<_CharT>::__gather_info(bool __intl, bool __neg, const locale& __loc, 3323 money_base::pattern& __pat, char_type& __dp, 3324 char_type& __ts, string& __grp, 3325 string_type& __sym, string_type& __sn, 3326 int& __fd) 3327{ 3328 if (__intl) 3329 { 3330 const moneypunct<char_type, true>& __mp = 3331 use_facet<moneypunct<char_type, true> >(__loc); 3332 if (__neg) 3333 { 3334 __pat = __mp.neg_format(); 3335 __sn = __mp.negative_sign(); 3336 } 3337 else 3338 { 3339 __pat = __mp.pos_format(); 3340 __sn = __mp.positive_sign(); 3341 } 3342 __dp = __mp.decimal_point(); 3343 __ts = __mp.thousands_sep(); 3344 __grp = __mp.grouping(); 3345 __sym = __mp.curr_symbol(); 3346 __fd = __mp.frac_digits(); 3347 } 3348 else 3349 { 3350 const moneypunct<char_type, false>& __mp = 3351 use_facet<moneypunct<char_type, false> >(__loc); 3352 if (__neg) 3353 { 3354 __pat = __mp.neg_format(); 3355 __sn = __mp.negative_sign(); 3356 } 3357 else 3358 { 3359 __pat = __mp.pos_format(); 3360 __sn = __mp.positive_sign(); 3361 } 3362 __dp = __mp.decimal_point(); 3363 __ts = __mp.thousands_sep(); 3364 __grp = __mp.grouping(); 3365 __sym = __mp.curr_symbol(); 3366 __fd = __mp.frac_digits(); 3367 } 3368} 3369 3370template <class _CharT> 3371void 3372__money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __me, 3373 ios_base::fmtflags __flags, 3374 const char_type* __db, const char_type* __de, 3375 const ctype<char_type>& __ct, bool __neg, 3376 const money_base::pattern& __pat, char_type __dp, 3377 char_type __ts, const string& __grp, 3378 const string_type& __sym, const string_type& __sn, 3379 int __fd) 3380{ 3381 __me = __mb; 3382 for (unsigned __p = 0; __p < 4; ++__p) 3383 { 3384 switch (__pat.field[__p]) 3385 { 3386 case money_base::none: 3387 __mi = __me; 3388 break; 3389 case money_base::space: 3390 __mi = __me; 3391 *__me++ = __ct.widen(' '); 3392 break; 3393 case money_base::sign: 3394 if (!__sn.empty()) 3395 *__me++ = __sn[0]; 3396 break; 3397 case money_base::symbol: 3398 if (!__sym.empty() && (__flags & ios_base::showbase)) 3399 __me = _VSTD::copy(__sym.begin(), __sym.end(), __me); 3400 break; 3401 case money_base::value: 3402 { 3403 // remember start of value so we can reverse it 3404 char_type* __t = __me; 3405 // find beginning of digits 3406 if (__neg) 3407 ++__db; 3408 // find end of digits 3409 const char_type* __d; 3410 for (__d = __db; __d < __de; ++__d) 3411 if (!__ct.is(ctype_base::digit, *__d)) 3412 break; 3413 // print fractional part 3414 if (__fd > 0) 3415 { 3416 int __f; 3417 for (__f = __fd; __d > __db && __f > 0; --__f) 3418 *__me++ = *--__d; 3419 char_type __z = __f > 0 ? __ct.widen('0') : char_type(); 3420 for (; __f > 0; --__f) 3421 *__me++ = __z; 3422 *__me++ = __dp; 3423 } 3424 // print units part 3425 if (__d == __db) 3426 { 3427 *__me++ = __ct.widen('0'); 3428 } 3429 else 3430 { 3431 unsigned __ng = 0; 3432 unsigned __ig = 0; 3433 unsigned __gl = __grp.empty() ? numeric_limits<unsigned>::max() 3434 : static_cast<unsigned>(__grp[__ig]); 3435 while (__d != __db) 3436 { 3437 if (__ng == __gl) 3438 { 3439 *__me++ = __ts; 3440 __ng = 0; 3441 if (++__ig < __grp.size()) 3442 __gl = __grp[__ig] == numeric_limits<char>::max() ? 3443 numeric_limits<unsigned>::max() : 3444 static_cast<unsigned>(__grp[__ig]); 3445 } 3446 *__me++ = *--__d; 3447 ++__ng; 3448 } 3449 } 3450 // reverse it 3451 reverse(__t, __me); 3452 } 3453 break; 3454 } 3455 } 3456 // print rest of sign, if any 3457 if (__sn.size() > 1) 3458 __me = _VSTD::copy(__sn.begin()+1, __sn.end(), __me); 3459 // set alignment 3460 if ((__flags & ios_base::adjustfield) == ios_base::left) 3461 __mi = __me; 3462 else if ((__flags & ios_base::adjustfield) != ios_base::internal) 3463 __mi = __mb; 3464} 3465 3466_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS __money_put<char>) 3467_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS __money_put<wchar_t>) 3468 3469template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > 3470class _LIBCPP_TYPE_VIS_ONLY money_put 3471 : public locale::facet, 3472 private __money_put<_CharT> 3473{ 3474public: 3475 typedef _CharT char_type; 3476 typedef _OutputIterator iter_type; 3477 typedef basic_string<char_type> string_type; 3478 3479 _LIBCPP_ALWAYS_INLINE 3480 explicit money_put(size_t __refs = 0) 3481 : locale::facet(__refs) {} 3482 3483 _LIBCPP_ALWAYS_INLINE 3484 iter_type put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, 3485 long double __units) const 3486 { 3487 return do_put(__s, __intl, __iob, __fl, __units); 3488 } 3489 3490 _LIBCPP_ALWAYS_INLINE 3491 iter_type put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, 3492 const string_type& __digits) const 3493 { 3494 return do_put(__s, __intl, __iob, __fl, __digits); 3495 } 3496 3497 static locale::id id; 3498 3499protected: 3500 _LIBCPP_ALWAYS_INLINE 3501 ~money_put() {} 3502 3503 virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob, 3504 char_type __fl, long double __units) const; 3505 virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob, 3506 char_type __fl, const string_type& __digits) const; 3507}; 3508 3509template <class _CharT, class _OutputIterator> 3510locale::id 3511money_put<_CharT, _OutputIterator>::id; 3512 3513template <class _CharT, class _OutputIterator> 3514_OutputIterator 3515money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl, 3516 ios_base& __iob, char_type __fl, 3517 long double __units) const 3518{ 3519 // convert to char 3520 const size_t __bs = 100; 3521 char __buf[__bs]; 3522 char* __bb = __buf; 3523 char_type __digits[__bs]; 3524 char_type* __db = __digits; 3525 size_t __n = static_cast<size_t>(snprintf(__bb, __bs, "%.0Lf", __units)); 3526 unique_ptr<char, void(*)(void*)> __hn(0, free); 3527 unique_ptr<char_type, void(*)(void*)> __hd(0, free); 3528 // secure memory for digit storage 3529 if (__n > __bs-1) 3530 { 3531#ifdef _LIBCPP_LOCALE__L_EXTENSIONS 3532 __n = static_cast<size_t>(asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units)); 3533#else 3534 __n = __asprintf_l(&__bb, __cloc(), "%.0Lf", __units); 3535#endif 3536 if (__bb == 0) 3537 __throw_bad_alloc(); 3538 __hn.reset(__bb); 3539 __hd.reset((char_type*)malloc(__n * sizeof(char_type))); 3540 if (__hd == nullptr) 3541 __throw_bad_alloc(); 3542 __db = __hd.get(); 3543 } 3544 // gather info 3545 locale __loc = __iob.getloc(); 3546 const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc); 3547 __ct.widen(__bb, __bb + __n, __db); 3548 bool __neg = __n > 0 && __bb[0] == '-'; 3549 money_base::pattern __pat; 3550 char_type __dp; 3551 char_type __ts; 3552 string __grp; 3553 string_type __sym; 3554 string_type __sn; 3555 int __fd; 3556 this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd); 3557 // secure memory for formatting 3558 char_type __mbuf[__bs]; 3559 char_type* __mb = __mbuf; 3560 unique_ptr<char_type, void(*)(void*)> __hw(0, free); 3561 size_t __exn = static_cast<int>(__n) > __fd ? 3562 (__n - static_cast<size_t>(__fd)) * 2 + __sn.size() + 3563 __sym.size() + static_cast<size_t>(__fd) + 1 3564 : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2; 3565 if (__exn > __bs) 3566 { 3567 __hw.reset((char_type*)malloc(__exn * sizeof(char_type))); 3568 __mb = __hw.get(); 3569 if (__mb == 0) 3570 __throw_bad_alloc(); 3571 } 3572 // format 3573 char_type* __mi; 3574 char_type* __me; 3575 this->__format(__mb, __mi, __me, __iob.flags(), 3576 __db, __db + __n, __ct, 3577 __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd); 3578 return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl); 3579} 3580 3581template <class _CharT, class _OutputIterator> 3582_OutputIterator 3583money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl, 3584 ios_base& __iob, char_type __fl, 3585 const string_type& __digits) const 3586{ 3587 // gather info 3588 locale __loc = __iob.getloc(); 3589 const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc); 3590 bool __neg = __digits.size() > 0 && __digits[0] == __ct.widen('-'); 3591 money_base::pattern __pat; 3592 char_type __dp; 3593 char_type __ts; 3594 string __grp; 3595 string_type __sym; 3596 string_type __sn; 3597 int __fd; 3598 this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd); 3599 // secure memory for formatting 3600 char_type __mbuf[100]; 3601 char_type* __mb = __mbuf; 3602 unique_ptr<char_type, void(*)(void*)> __h(0, free); 3603 size_t __exn = static_cast<int>(__digits.size()) > __fd ? 3604 (__digits.size() - static_cast<size_t>(__fd)) * 2 + 3605 __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 1 3606 : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2; 3607 if (__exn > 100) 3608 { 3609 __h.reset((char_type*)malloc(__exn * sizeof(char_type))); 3610 __mb = __h.get(); 3611 if (__mb == 0) 3612 __throw_bad_alloc(); 3613 } 3614 // format 3615 char_type* __mi; 3616 char_type* __me; 3617 this->__format(__mb, __mi, __me, __iob.flags(), 3618 __digits.data(), __digits.data() + __digits.size(), __ct, 3619 __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd); 3620 return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl); 3621} 3622 3623_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS money_put<char>) 3624_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS money_put<wchar_t>) 3625 3626// messages 3627 3628class _LIBCPP_TYPE_VIS messages_base 3629{ 3630public: 3631 typedef ptrdiff_t catalog; 3632 3633 _LIBCPP_ALWAYS_INLINE messages_base() {} 3634}; 3635 3636template <class _CharT> 3637class _LIBCPP_TYPE_VIS_ONLY messages 3638 : public locale::facet, 3639 public messages_base 3640{ 3641public: 3642 typedef _CharT char_type; 3643 typedef basic_string<_CharT> string_type; 3644 3645 _LIBCPP_ALWAYS_INLINE 3646 explicit messages(size_t __refs = 0) 3647 : locale::facet(__refs) {} 3648 3649 _LIBCPP_ALWAYS_INLINE 3650 catalog open(const basic_string<char>& __nm, const locale& __loc) const 3651 { 3652 return do_open(__nm, __loc); 3653 } 3654 3655 _LIBCPP_ALWAYS_INLINE 3656 string_type get(catalog __c, int __set, int __msgid, 3657 const string_type& __dflt) const 3658 { 3659 return do_get(__c, __set, __msgid, __dflt); 3660 } 3661 3662 _LIBCPP_ALWAYS_INLINE 3663 void close(catalog __c) const 3664 { 3665 do_close(__c); 3666 } 3667 3668 static locale::id id; 3669 3670protected: 3671 _LIBCPP_ALWAYS_INLINE 3672 ~messages() {} 3673 3674 virtual catalog do_open(const basic_string<char>&, const locale&) const; 3675 virtual string_type do_get(catalog, int __set, int __msgid, 3676 const string_type& __dflt) const; 3677 virtual void do_close(catalog) const; 3678}; 3679 3680template <class _CharT> 3681locale::id 3682messages<_CharT>::id; 3683 3684template <class _CharT> 3685typename messages<_CharT>::catalog 3686messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const 3687{ 3688#if defined(_WIN32) || defined(__ANDROID__) || defined(_NEWLIB_VERSION) 3689 return -1; 3690#else // _WIN32 || __ANDROID__ 3691 catalog __cat = (catalog)catopen(__nm.c_str(), NL_CAT_LOCALE); 3692 if (__cat != -1) 3693 __cat = static_cast<catalog>((static_cast<size_t>(__cat) >> 1)); 3694 return __cat; 3695#endif // _WIN32 || __ANDROID__ 3696} 3697 3698template <class _CharT> 3699typename messages<_CharT>::string_type 3700messages<_CharT>::do_get(catalog __c, int __set, int __msgid, 3701 const string_type& __dflt) const 3702{ 3703#if defined(_WIN32) || defined(__ANDROID__) || defined(_NEWLIB_VERSION) 3704 return __dflt; 3705#else // _WIN32 3706 string __ndflt; 3707 __narrow_to_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__ndflt), 3708 __dflt.c_str(), 3709 __dflt.c_str() + __dflt.size()); 3710 if (__c != -1) 3711 __c <<= 1; 3712 nl_catd __cat = (nl_catd)__c; 3713 char* __n = catgets(__cat, __set, __msgid, __ndflt.c_str()); 3714 string_type __w; 3715 __widen_from_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__w), 3716 __n, __n + strlen(__n)); 3717 return __w; 3718#endif // _WIN32 3719} 3720 3721template <class _CharT> 3722void 3723messages<_CharT>::do_close(catalog __c) const 3724{ 3725#if !defined(_WIN32) && !defined(__ANDROID__) && !defined(_NEWLIB_VERSION) 3726 if (__c != -1) 3727 __c <<= 1; 3728 nl_catd __cat = (nl_catd)__c; 3729 catclose(__cat); 3730#endif // !_WIN32 3731} 3732 3733_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS messages<char>) 3734_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS messages<wchar_t>) 3735 3736template <class _CharT> 3737class _LIBCPP_TYPE_VIS_ONLY messages_byname 3738 : public messages<_CharT> 3739{ 3740public: 3741 typedef messages_base::catalog catalog; 3742 typedef basic_string<_CharT> string_type; 3743 3744 _LIBCPP_ALWAYS_INLINE 3745 explicit messages_byname(const char*, size_t __refs = 0) 3746 : messages<_CharT>(__refs) {} 3747 3748 _LIBCPP_ALWAYS_INLINE 3749 explicit messages_byname(const string&, size_t __refs = 0) 3750 : messages<_CharT>(__refs) {} 3751 3752protected: 3753 _LIBCPP_ALWAYS_INLINE 3754 ~messages_byname() {} 3755}; 3756 3757_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS messages_byname<char>) 3758_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS messages_byname<wchar_t>) 3759 3760template<class _Codecvt, class _Elem = wchar_t, 3761 class _Wide_alloc = allocator<_Elem>, 3762 class _Byte_alloc = allocator<char> > 3763class _LIBCPP_TYPE_VIS_ONLY wstring_convert 3764{ 3765public: 3766 typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string; 3767 typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string; 3768 typedef typename _Codecvt::state_type state_type; 3769 typedef typename wide_string::traits_type::int_type int_type; 3770 3771private: 3772 byte_string __byte_err_string_; 3773 wide_string __wide_err_string_; 3774 _Codecvt* __cvtptr_; 3775 state_type __cvtstate_; 3776 size_t __cvtcount_; 3777 3778 wstring_convert(const wstring_convert& __wc); 3779 wstring_convert& operator=(const wstring_convert& __wc); 3780public: 3781 _LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(_Codecvt* __pcvt = new _Codecvt); 3782 wstring_convert(_Codecvt* __pcvt, state_type __state); 3783 _LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(const byte_string& __byte_err, 3784 const wide_string& __wide_err = wide_string()); 3785#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3786 wstring_convert(wstring_convert&& __wc); 3787#endif 3788 ~wstring_convert(); 3789 3790 _LIBCPP_ALWAYS_INLINE 3791 wide_string from_bytes(char __byte) 3792 {return from_bytes(&__byte, &__byte+1);} 3793 _LIBCPP_ALWAYS_INLINE 3794 wide_string from_bytes(const char* __ptr) 3795 {return from_bytes(__ptr, __ptr + char_traits<char>::length(__ptr));} 3796 _LIBCPP_ALWAYS_INLINE 3797 wide_string from_bytes(const byte_string& __str) 3798 {return from_bytes(__str.data(), __str.data() + __str.size());} 3799 wide_string from_bytes(const char* __first, const char* __last); 3800 3801 _LIBCPP_ALWAYS_INLINE 3802 byte_string to_bytes(_Elem __wchar) 3803 {return to_bytes(&__wchar, &__wchar+1);} 3804 _LIBCPP_ALWAYS_INLINE 3805 byte_string to_bytes(const _Elem* __wptr) 3806 {return to_bytes(__wptr, __wptr + char_traits<_Elem>::length(__wptr));} 3807 _LIBCPP_ALWAYS_INLINE 3808 byte_string to_bytes(const wide_string& __wstr) 3809 {return to_bytes(__wstr.data(), __wstr.data() + __wstr.size());} 3810 byte_string to_bytes(const _Elem* __first, const _Elem* __last); 3811 3812 _LIBCPP_ALWAYS_INLINE 3813 size_t converted() const _NOEXCEPT {return __cvtcount_;} 3814 _LIBCPP_ALWAYS_INLINE 3815 state_type state() const {return __cvtstate_;} 3816}; 3817 3818template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc> 3819inline _LIBCPP_ALWAYS_INLINE 3820wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>:: 3821 wstring_convert(_Codecvt* __pcvt) 3822 : __cvtptr_(__pcvt), __cvtstate_(), __cvtcount_(0) 3823{ 3824} 3825 3826template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc> 3827inline _LIBCPP_ALWAYS_INLINE 3828wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>:: 3829 wstring_convert(_Codecvt* __pcvt, state_type __state) 3830 : __cvtptr_(__pcvt), __cvtstate_(__state), __cvtcount_(0) 3831{ 3832} 3833 3834template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc> 3835wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>:: 3836 wstring_convert(const byte_string& __byte_err, const wide_string& __wide_err) 3837 : __byte_err_string_(__byte_err), __wide_err_string_(__wide_err), 3838 __cvtstate_(), __cvtcount_(0) 3839{ 3840 __cvtptr_ = new _Codecvt; 3841} 3842 3843#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3844 3845template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc> 3846inline _LIBCPP_ALWAYS_INLINE 3847wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>:: 3848 wstring_convert(wstring_convert&& __wc) 3849 : __byte_err_string_(_VSTD::move(__wc.__byte_err_string_)), 3850 __wide_err_string_(_VSTD::move(__wc.__wide_err_string_)), 3851 __cvtptr_(__wc.__cvtptr_), 3852 __cvtstate_(__wc.__cvtstate_), __cvtcount_(__wc.__cvtstate_) 3853{ 3854 __wc.__cvtptr_ = nullptr; 3855} 3856 3857#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3858 3859template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc> 3860wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::~wstring_convert() 3861{ 3862 delete __cvtptr_; 3863} 3864 3865template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc> 3866typename wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::wide_string 3867wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>:: 3868 from_bytes(const char* __frm, const char* __frm_end) 3869{ 3870 __cvtcount_ = 0; 3871 if (__cvtptr_ != nullptr) 3872 { 3873 wide_string __ws(2*(__frm_end - __frm), _Elem()); 3874 if (__frm != __frm_end) 3875 __ws.resize(__ws.capacity()); 3876 codecvt_base::result __r = codecvt_base::ok; 3877 state_type __st = __cvtstate_; 3878 if (__frm != __frm_end) 3879 { 3880 _Elem* __to = &__ws[0]; 3881 _Elem* __to_end = __to + __ws.size(); 3882 const char* __frm_nxt; 3883 do 3884 { 3885 _Elem* __to_nxt; 3886 __r = __cvtptr_->in(__st, __frm, __frm_end, __frm_nxt, 3887 __to, __to_end, __to_nxt); 3888 __cvtcount_ += __frm_nxt - __frm; 3889 if (__frm_nxt == __frm) 3890 { 3891 __r = codecvt_base::error; 3892 } 3893 else if (__r == codecvt_base::noconv) 3894 { 3895 __ws.resize(__to - &__ws[0]); 3896 // This only gets executed if _Elem is char 3897 __ws.append((const _Elem*)__frm, (const _Elem*)__frm_end); 3898 __frm = __frm_nxt; 3899 __r = codecvt_base::ok; 3900 } 3901 else if (__r == codecvt_base::ok) 3902 { 3903 __ws.resize(__to_nxt - &__ws[0]); 3904 __frm = __frm_nxt; 3905 } 3906 else if (__r == codecvt_base::partial) 3907 { 3908 ptrdiff_t __s = __to_nxt - &__ws[0]; 3909 __ws.resize(2 * __s); 3910 __to = &__ws[0] + __s; 3911 __to_end = &__ws[0] + __ws.size(); 3912 __frm = __frm_nxt; 3913 } 3914 } while (__r == codecvt_base::partial && __frm_nxt < __frm_end); 3915 } 3916 if (__r == codecvt_base::ok) 3917 return __ws; 3918 } 3919#ifndef _LIBCPP_NO_EXCEPTIONS 3920 if (__wide_err_string_.empty()) 3921 throw range_error("wstring_convert: from_bytes error"); 3922#endif // _LIBCPP_NO_EXCEPTIONS 3923 return __wide_err_string_; 3924} 3925 3926template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc> 3927typename wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::byte_string 3928wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>:: 3929 to_bytes(const _Elem* __frm, const _Elem* __frm_end) 3930{ 3931 __cvtcount_ = 0; 3932 if (__cvtptr_ != nullptr) 3933 { 3934 byte_string __bs(2*(__frm_end - __frm), char()); 3935 if (__frm != __frm_end) 3936 __bs.resize(__bs.capacity()); 3937 codecvt_base::result __r = codecvt_base::ok; 3938 state_type __st = __cvtstate_; 3939 if (__frm != __frm_end) 3940 { 3941 char* __to = &__bs[0]; 3942 char* __to_end = __to + __bs.size(); 3943 const _Elem* __frm_nxt; 3944 do 3945 { 3946 char* __to_nxt; 3947 __r = __cvtptr_->out(__st, __frm, __frm_end, __frm_nxt, 3948 __to, __to_end, __to_nxt); 3949 __cvtcount_ += __frm_nxt - __frm; 3950 if (__frm_nxt == __frm) 3951 { 3952 __r = codecvt_base::error; 3953 } 3954 else if (__r == codecvt_base::noconv) 3955 { 3956 __bs.resize(__to - &__bs[0]); 3957 // This only gets executed if _Elem is char 3958 __bs.append((const char*)__frm, (const char*)__frm_end); 3959 __frm = __frm_nxt; 3960 __r = codecvt_base::ok; 3961 } 3962 else if (__r == codecvt_base::ok) 3963 { 3964 __bs.resize(__to_nxt - &__bs[0]); 3965 __frm = __frm_nxt; 3966 } 3967 else if (__r == codecvt_base::partial) 3968 { 3969 ptrdiff_t __s = __to_nxt - &__bs[0]; 3970 __bs.resize(2 * __s); 3971 __to = &__bs[0] + __s; 3972 __to_end = &__bs[0] + __bs.size(); 3973 __frm = __frm_nxt; 3974 } 3975 } while (__r == codecvt_base::partial && __frm_nxt < __frm_end); 3976 } 3977 if (__r == codecvt_base::ok) 3978 { 3979 size_t __s = __bs.size(); 3980 __bs.resize(__bs.capacity()); 3981 char* __to = &__bs[0] + __s; 3982 char* __to_end = __to + __bs.size(); 3983 do 3984 { 3985 char* __to_nxt; 3986 __r = __cvtptr_->unshift(__st, __to, __to_end, __to_nxt); 3987 if (__r == codecvt_base::noconv) 3988 { 3989 __bs.resize(__to - &__bs[0]); 3990 __r = codecvt_base::ok; 3991 } 3992 else if (__r == codecvt_base::ok) 3993 { 3994 __bs.resize(__to_nxt - &__bs[0]); 3995 } 3996 else if (__r == codecvt_base::partial) 3997 { 3998 ptrdiff_t __sp = __to_nxt - &__bs[0]; 3999 __bs.resize(2 * __sp); 4000 __to = &__bs[0] + __sp; 4001 __to_end = &__bs[0] + __bs.size(); 4002 } 4003 } while (__r == codecvt_base::partial); 4004 if (__r == codecvt_base::ok) 4005 return __bs; 4006 } 4007 } 4008#ifndef _LIBCPP_NO_EXCEPTIONS 4009 if (__byte_err_string_.empty()) 4010 throw range_error("wstring_convert: to_bytes error"); 4011#endif // _LIBCPP_NO_EXCEPTIONS 4012 return __byte_err_string_; 4013} 4014 4015template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> > 4016class _LIBCPP_TYPE_VIS_ONLY wbuffer_convert 4017 : public basic_streambuf<_Elem, _Tr> 4018{ 4019public: 4020 // types: 4021 typedef _Elem char_type; 4022 typedef _Tr traits_type; 4023 typedef typename traits_type::int_type int_type; 4024 typedef typename traits_type::pos_type pos_type; 4025 typedef typename traits_type::off_type off_type; 4026 typedef typename _Codecvt::state_type state_type; 4027 4028private: 4029 char* __extbuf_; 4030 const char* __extbufnext_; 4031 const char* __extbufend_; 4032 char __extbuf_min_[8]; 4033 size_t __ebs_; 4034 char_type* __intbuf_; 4035 size_t __ibs_; 4036 streambuf* __bufptr_; 4037 _Codecvt* __cv_; 4038 state_type __st_; 4039 ios_base::openmode __cm_; 4040 bool __owns_eb_; 4041 bool __owns_ib_; 4042 bool __always_noconv_; 4043 4044 wbuffer_convert(const wbuffer_convert&); 4045 wbuffer_convert& operator=(const wbuffer_convert&); 4046public: 4047 _LIBCPP_EXPLICIT_AFTER_CXX11 wbuffer_convert(streambuf* __bytebuf = 0, 4048 _Codecvt* __pcvt = new _Codecvt, state_type __state = state_type()); 4049 ~wbuffer_convert(); 4050 4051 _LIBCPP_INLINE_VISIBILITY 4052 streambuf* rdbuf() const {return __bufptr_;} 4053 _LIBCPP_INLINE_VISIBILITY 4054 streambuf* rdbuf(streambuf* __bytebuf) 4055 { 4056 streambuf* __r = __bufptr_; 4057 __bufptr_ = __bytebuf; 4058 return __r; 4059 } 4060 4061 _LIBCPP_INLINE_VISIBILITY 4062 state_type state() const {return __st_;} 4063 4064protected: 4065 virtual int_type underflow(); 4066 virtual int_type pbackfail(int_type __c = traits_type::eof()); 4067 virtual int_type overflow (int_type __c = traits_type::eof()); 4068 virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, 4069 streamsize __n); 4070 virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, 4071 ios_base::openmode __wch = ios_base::in | ios_base::out); 4072 virtual pos_type seekpos(pos_type __sp, 4073 ios_base::openmode __wch = ios_base::in | ios_base::out); 4074 virtual int sync(); 4075 4076private: 4077 bool __read_mode(); 4078 void __write_mode(); 4079 wbuffer_convert* __close(); 4080}; 4081 4082template <class _Codecvt, class _Elem, class _Tr> 4083wbuffer_convert<_Codecvt, _Elem, _Tr>:: 4084 wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt, state_type __state) 4085 : __extbuf_(0), 4086 __extbufnext_(0), 4087 __extbufend_(0), 4088 __ebs_(0), 4089 __intbuf_(0), 4090 __ibs_(0), 4091 __bufptr_(__bytebuf), 4092 __cv_(__pcvt), 4093 __st_(__state), 4094 __cm_(0), 4095 __owns_eb_(false), 4096 __owns_ib_(false), 4097 __always_noconv_(__cv_ ? __cv_->always_noconv() : false) 4098{ 4099 setbuf(0, 4096); 4100} 4101 4102template <class _Codecvt, class _Elem, class _Tr> 4103wbuffer_convert<_Codecvt, _Elem, _Tr>::~wbuffer_convert() 4104{ 4105 __close(); 4106 delete __cv_; 4107 if (__owns_eb_) 4108 delete [] __extbuf_; 4109 if (__owns_ib_) 4110 delete [] __intbuf_; 4111} 4112 4113template <class _Codecvt, class _Elem, class _Tr> 4114typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type 4115wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow() 4116{ 4117 if (__cv_ == 0 || __bufptr_ == 0) 4118 return traits_type::eof(); 4119 bool __initial = __read_mode(); 4120 char_type __1buf; 4121 if (this->gptr() == 0) 4122 this->setg(&__1buf, &__1buf+1, &__1buf+1); 4123 const size_t __unget_sz = __initial ? 0 : min<size_t>((this->egptr() - this->eback()) / 2, 4); 4124 int_type __c = traits_type::eof(); 4125 if (this->gptr() == this->egptr()) 4126 { 4127 memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type)); 4128 if (__always_noconv_) 4129 { 4130 streamsize __nmemb = static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz); 4131 __nmemb = __bufptr_->sgetn((char*)this->eback() + __unget_sz, __nmemb); 4132 if (__nmemb != 0) 4133 { 4134 this->setg(this->eback(), 4135 this->eback() + __unget_sz, 4136 this->eback() + __unget_sz + __nmemb); 4137 __c = *this->gptr(); 4138 } 4139 } 4140 else 4141 { 4142 memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_); 4143 __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_); 4144 __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_); 4145 streamsize __nmemb = _VSTD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz), 4146 static_cast<streamsize>(__extbufend_ - __extbufnext_)); 4147 codecvt_base::result __r; 4148 state_type __svs = __st_; 4149 streamsize __nr = __bufptr_->sgetn(const_cast<char*>(__extbufnext_), __nmemb); 4150 if (__nr != 0) 4151 { 4152 __extbufend_ = __extbufnext_ + __nr; 4153 char_type* __inext; 4154 __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_, 4155 this->eback() + __unget_sz, 4156 this->egptr(), __inext); 4157 if (__r == codecvt_base::noconv) 4158 { 4159 this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, (char_type*)__extbufend_); 4160 __c = *this->gptr(); 4161 } 4162 else if (__inext != this->eback() + __unget_sz) 4163 { 4164 this->setg(this->eback(), this->eback() + __unget_sz, __inext); 4165 __c = *this->gptr(); 4166 } 4167 } 4168 } 4169 } 4170 else 4171 __c = *this->gptr(); 4172 if (this->eback() == &__1buf) 4173 this->setg(0, 0, 0); 4174 return __c; 4175} 4176 4177template <class _Codecvt, class _Elem, class _Tr> 4178typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type 4179wbuffer_convert<_Codecvt, _Elem, _Tr>::pbackfail(int_type __c) 4180{ 4181 if (__cv_ != 0 && __bufptr_ != 0 && this->eback() < this->gptr()) 4182 { 4183 if (traits_type::eq_int_type(__c, traits_type::eof())) 4184 { 4185 this->gbump(-1); 4186 return traits_type::not_eof(__c); 4187 } 4188 if (traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])) 4189 { 4190 this->gbump(-1); 4191 *this->gptr() = traits_type::to_char_type(__c); 4192 return __c; 4193 } 4194 } 4195 return traits_type::eof(); 4196} 4197 4198template <class _Codecvt, class _Elem, class _Tr> 4199typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type 4200wbuffer_convert<_Codecvt, _Elem, _Tr>::overflow(int_type __c) 4201{ 4202 if (__cv_ == 0 || __bufptr_ == 0) 4203 return traits_type::eof(); 4204 __write_mode(); 4205 char_type __1buf; 4206 char_type* __pb_save = this->pbase(); 4207 char_type* __epb_save = this->epptr(); 4208 if (!traits_type::eq_int_type(__c, traits_type::eof())) 4209 { 4210 if (this->pptr() == 0) 4211 this->setp(&__1buf, &__1buf+1); 4212 *this->pptr() = traits_type::to_char_type(__c); 4213 this->pbump(1); 4214 } 4215 if (this->pptr() != this->pbase()) 4216 { 4217 if (__always_noconv_) 4218 { 4219 streamsize __nmemb = static_cast<streamsize>(this->pptr() - this->pbase()); 4220 if (__bufptr_->sputn((const char*)this->pbase(), __nmemb) != __nmemb) 4221 return traits_type::eof(); 4222 } 4223 else 4224 { 4225 char* __extbe = __extbuf_; 4226 codecvt_base::result __r; 4227 do 4228 { 4229 const char_type* __e; 4230 __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, 4231 __extbuf_, __extbuf_ + __ebs_, __extbe); 4232 if (__e == this->pbase()) 4233 return traits_type::eof(); 4234 if (__r == codecvt_base::noconv) 4235 { 4236 streamsize __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); 4237 if (__bufptr_->sputn((const char*)this->pbase(), __nmemb) != __nmemb) 4238 return traits_type::eof(); 4239 } 4240 else if (__r == codecvt_base::ok || __r == codecvt_base::partial) 4241 { 4242 streamsize __nmemb = static_cast<size_t>(__extbe - __extbuf_); 4243 if (__bufptr_->sputn(__extbuf_, __nmemb) != __nmemb) 4244 return traits_type::eof(); 4245 if (__r == codecvt_base::partial) 4246 { 4247 this->setp((char_type*)__e, this->pptr()); 4248 this->pbump(this->epptr() - this->pbase()); 4249 } 4250 } 4251 else 4252 return traits_type::eof(); 4253 } while (__r == codecvt_base::partial); 4254 } 4255 this->setp(__pb_save, __epb_save); 4256 } 4257 return traits_type::not_eof(__c); 4258} 4259 4260template <class _Codecvt, class _Elem, class _Tr> 4261basic_streambuf<_Elem, _Tr>* 4262wbuffer_convert<_Codecvt, _Elem, _Tr>::setbuf(char_type* __s, streamsize __n) 4263{ 4264 this->setg(0, 0, 0); 4265 this->setp(0, 0); 4266 if (__owns_eb_) 4267 delete [] __extbuf_; 4268 if (__owns_ib_) 4269 delete [] __intbuf_; 4270 __ebs_ = __n; 4271 if (__ebs_ > sizeof(__extbuf_min_)) 4272 { 4273 if (__always_noconv_ && __s) 4274 { 4275 __extbuf_ = (char*)__s; 4276 __owns_eb_ = false; 4277 } 4278 else 4279 { 4280 __extbuf_ = new char[__ebs_]; 4281 __owns_eb_ = true; 4282 } 4283 } 4284 else 4285 { 4286 __extbuf_ = __extbuf_min_; 4287 __ebs_ = sizeof(__extbuf_min_); 4288 __owns_eb_ = false; 4289 } 4290 if (!__always_noconv_) 4291 { 4292 __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_)); 4293 if (__s && __ibs_ >= sizeof(__extbuf_min_)) 4294 { 4295 __intbuf_ = __s; 4296 __owns_ib_ = false; 4297 } 4298 else 4299 { 4300 __intbuf_ = new char_type[__ibs_]; 4301 __owns_ib_ = true; 4302 } 4303 } 4304 else 4305 { 4306 __ibs_ = 0; 4307 __intbuf_ = 0; 4308 __owns_ib_ = false; 4309 } 4310 return this; 4311} 4312 4313template <class _Codecvt, class _Elem, class _Tr> 4314typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type 4315wbuffer_convert<_Codecvt, _Elem, _Tr>::seekoff(off_type __off, ios_base::seekdir __way, 4316 ios_base::openmode __om) 4317{ 4318 int __width = __cv_->encoding(); 4319 if (__cv_ == 0 || __bufptr_ == 0 || (__width <= 0 && __off != 0) || sync()) 4320 return pos_type(off_type(-1)); 4321 // __width > 0 || __off == 0 4322 switch (__way) 4323 { 4324 case ios_base::beg: 4325 break; 4326 case ios_base::cur: 4327 break; 4328 case ios_base::end: 4329 break; 4330 default: 4331 return pos_type(off_type(-1)); 4332 } 4333 pos_type __r = __bufptr_->pubseekoff(__width * __off, __way, __om); 4334 __r.state(__st_); 4335 return __r; 4336} 4337 4338template <class _Codecvt, class _Elem, class _Tr> 4339typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type 4340wbuffer_convert<_Codecvt, _Elem, _Tr>::seekpos(pos_type __sp, ios_base::openmode __wch) 4341{ 4342 if (__cv_ == 0 || __bufptr_ == 0 || sync()) 4343 return pos_type(off_type(-1)); 4344 if (__bufptr_->pubseekpos(__sp, __wch) == pos_type(off_type(-1))) 4345 return pos_type(off_type(-1)); 4346 return __sp; 4347} 4348 4349template <class _Codecvt, class _Elem, class _Tr> 4350int 4351wbuffer_convert<_Codecvt, _Elem, _Tr>::sync() 4352{ 4353 if (__cv_ == 0 || __bufptr_ == 0) 4354 return 0; 4355 if (__cm_ & ios_base::out) 4356 { 4357 if (this->pptr() != this->pbase()) 4358 if (overflow() == traits_type::eof()) 4359 return -1; 4360 codecvt_base::result __r; 4361 do 4362 { 4363 char* __extbe; 4364 __r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe); 4365 streamsize __nmemb = static_cast<streamsize>(__extbe - __extbuf_); 4366 if (__bufptr_->sputn(__extbuf_, __nmemb) != __nmemb) 4367 return -1; 4368 } while (__r == codecvt_base::partial); 4369 if (__r == codecvt_base::error) 4370 return -1; 4371 if (__bufptr_->pubsync()) 4372 return -1; 4373 } 4374 else if (__cm_ & ios_base::in) 4375 { 4376 off_type __c; 4377 if (__always_noconv_) 4378 __c = this->egptr() - this->gptr(); 4379 else 4380 { 4381 int __width = __cv_->encoding(); 4382 __c = __extbufend_ - __extbufnext_; 4383 if (__width > 0) 4384 __c += __width * (this->egptr() - this->gptr()); 4385 else 4386 { 4387 if (this->gptr() != this->egptr()) 4388 { 4389 reverse(this->gptr(), this->egptr()); 4390 codecvt_base::result __r; 4391 const char_type* __e = this->gptr(); 4392 char* __extbe; 4393 do 4394 { 4395 __r = __cv_->out(__st_, __e, this->egptr(), __e, 4396 __extbuf_, __extbuf_ + __ebs_, __extbe); 4397 switch (__r) 4398 { 4399 case codecvt_base::noconv: 4400 __c += this->egptr() - this->gptr(); 4401 break; 4402 case codecvt_base::ok: 4403 case codecvt_base::partial: 4404 __c += __extbe - __extbuf_; 4405 break; 4406 default: 4407 return -1; 4408 } 4409 } while (__r == codecvt_base::partial); 4410 } 4411 } 4412 } 4413 if (__bufptr_->pubseekoff(-__c, ios_base::cur, __cm_) == pos_type(off_type(-1))) 4414 return -1; 4415 this->setg(0, 0, 0); 4416 __cm_ = 0; 4417 } 4418 return 0; 4419} 4420 4421template <class _Codecvt, class _Elem, class _Tr> 4422bool 4423wbuffer_convert<_Codecvt, _Elem, _Tr>::__read_mode() 4424{ 4425 if (!(__cm_ & ios_base::in)) 4426 { 4427 this->setp(0, 0); 4428 if (__always_noconv_) 4429 this->setg((char_type*)__extbuf_, 4430 (char_type*)__extbuf_ + __ebs_, 4431 (char_type*)__extbuf_ + __ebs_); 4432 else 4433 this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_); 4434 __cm_ = ios_base::in; 4435 return true; 4436 } 4437 return false; 4438} 4439 4440template <class _Codecvt, class _Elem, class _Tr> 4441void 4442wbuffer_convert<_Codecvt, _Elem, _Tr>::__write_mode() 4443{ 4444 if (!(__cm_ & ios_base::out)) 4445 { 4446 this->setg(0, 0, 0); 4447 if (__ebs_ > sizeof(__extbuf_min_)) 4448 { 4449 if (__always_noconv_) 4450 this->setp((char_type*)__extbuf_, 4451 (char_type*)__extbuf_ + (__ebs_ - 1)); 4452 else 4453 this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1)); 4454 } 4455 else 4456 this->setp(0, 0); 4457 __cm_ = ios_base::out; 4458 } 4459} 4460 4461template <class _Codecvt, class _Elem, class _Tr> 4462wbuffer_convert<_Codecvt, _Elem, _Tr>* 4463wbuffer_convert<_Codecvt, _Elem, _Tr>::__close() 4464{ 4465 wbuffer_convert* __rt = 0; 4466 if (__cv_ != 0 && __bufptr_ != 0) 4467 { 4468 __rt = this; 4469 if ((__cm_ & ios_base::out) && sync()) 4470 __rt = 0; 4471 } 4472 return __rt; 4473} 4474 4475_LIBCPP_END_NAMESPACE_STD 4476 4477#endif // _LIBCPP_LOCALE 4478