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