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