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