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