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