1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 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 #include <__config> 15 #include <string> 16 #include <memory> 17 #include <utility> 18 #include <mutex> 19 #include <cstdint> 20 #include <cctype> 21 #include <locale.h> 22 #if defined(_LIBCPP_MSVCRT_LIKE) 23 # include <support/win32/locale_win32.h> 24 #elif defined(_AIX) 25 # include <support/ibm/xlocale.h> 26 #elif defined(__ANDROID__) 27 // Android gained the locale aware functions in L (API level 21) 28 # include <android/api-level.h> 29 # if __ANDROID_API__ <= 20 30 # include <support/android/locale_bionic.h> 31 # endif 32 #elif defined(__sun__) 33 # include <xlocale.h> 34 # include <support/solaris/xlocale.h> 35 #elif defined(_NEWLIB_VERSION) 36 # include <support/newlib/xlocale.h> 37 #elif (defined(__APPLE__) || defined(__FreeBSD__) \ 38 || defined(__EMSCRIPTEN__) || defined(__IBMCPP__)) 39 # include <xlocale.h> 40 #elif defined(__Fuchsia__) 41 # include <support/fuchsia/xlocale.h> 42 #elif defined(_LIBCPP_HAS_MUSL_LIBC) 43 # include <support/musl/xlocale.h> 44 #endif 45 46 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 47 #pragma GCC system_header 48 #endif 49 50 _LIBCPP_BEGIN_NAMESPACE_STD 51 52 #if !defined(_LIBCPP_LOCALE__L_EXTENSIONS) 53 struct __libcpp_locale_guard { 54 _LIBCPP_INLINE_VISIBILITY 55 __libcpp_locale_guard(locale_t& __loc) : __old_loc_(uselocale(__loc)) {} 56 57 _LIBCPP_INLINE_VISIBILITY 58 ~__libcpp_locale_guard() { 59 if (__old_loc_) 60 uselocale(__old_loc_); 61 } 62 63 locale_t __old_loc_; 64 private: 65 __libcpp_locale_guard(__libcpp_locale_guard const&); 66 __libcpp_locale_guard& operator=(__libcpp_locale_guard const&); 67 }; 68 #elif defined(_LIBCPP_MSVCRT_LIKE) 69 struct __libcpp_locale_guard { 70 __libcpp_locale_guard(locale_t __l) : 71 __status(_configthreadlocale(_ENABLE_PER_THREAD_LOCALE)), 72 __locale_collate(setlocale(LC_COLLATE, __l.__get_locale())), 73 __locale_ctype(setlocale(LC_CTYPE, __l.__get_locale())), 74 __locale_monetary(setlocale(LC_MONETARY, __l.__get_locale())), 75 __locale_numeric(setlocale(LC_NUMERIC, __l.__get_locale())), 76 __locale_time(setlocale(LC_TIME, __l.__get_locale())) 77 // LC_MESSAGES is not supported on Windows. 78 {} 79 ~__libcpp_locale_guard() { 80 setlocale(LC_COLLATE, __locale_collate); 81 setlocale(LC_CTYPE, __locale_ctype); 82 setlocale(LC_MONETARY, __locale_monetary); 83 setlocale(LC_NUMERIC, __locale_numeric); 84 setlocale(LC_TIME, __locale_time); 85 _configthreadlocale(__status); 86 } 87 int __status; 88 char* __locale_collate; 89 char* __locale_ctype; 90 char* __locale_monetary; 91 char* __locale_numeric; 92 char* __locale_time; 93 }; 94 #endif 95 96 97 class _LIBCPP_TYPE_VIS locale; 98 99 template <class _Facet> 100 _LIBCPP_INLINE_VISIBILITY 101 bool 102 has_facet(const locale&) _NOEXCEPT; 103 104 template <class _Facet> 105 _LIBCPP_INLINE_VISIBILITY 106 const _Facet& 107 use_facet(const locale&); 108 109 class _LIBCPP_TYPE_VIS locale 110 { 111 public: 112 // types: 113 class _LIBCPP_TYPE_VIS facet; 114 class _LIBCPP_TYPE_VIS id; 115 116 typedef int category; 117 _LIBCPP_AVAILABILITY_LOCALE_CATEGORY 118 static const category // values assigned here are for exposition only 119 none = 0, 120 collate = LC_COLLATE_MASK, 121 ctype = LC_CTYPE_MASK, 122 monetary = LC_MONETARY_MASK, 123 numeric = LC_NUMERIC_MASK, 124 time = LC_TIME_MASK, 125 messages = LC_MESSAGES_MASK, 126 all = collate | ctype | monetary | numeric | time | messages; 127 128 // construct/copy/destroy: 129 locale() _NOEXCEPT; 130 locale(const locale&) _NOEXCEPT; 131 explicit locale(const char*); 132 explicit locale(const string&); 133 locale(const locale&, const char*, category); 134 locale(const locale&, const string&, category); 135 template <class _Facet> 136 _LIBCPP_INLINE_VISIBILITY locale(const locale&, _Facet*); 137 locale(const locale&, const locale&, category); 138 139 ~locale(); 140 141 const locale& operator=(const locale&) _NOEXCEPT; 142 143 template <class _Facet> 144 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 145 locale combine(const locale&) const; 146 147 // locale operations: 148 string name() const; 149 bool operator==(const locale&) const; 150 bool operator!=(const locale& __y) const {return !(*this == __y);} 151 template <class _CharT, class _Traits, class _Allocator> 152 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 153 bool operator()(const basic_string<_CharT, _Traits, _Allocator>&, 154 const basic_string<_CharT, _Traits, _Allocator>&) const; 155 156 // global locale objects: 157 static locale global(const locale&); 158 static const locale& classic(); 159 160 private: 161 class __imp; 162 __imp* __locale_; 163 164 void __install_ctor(const locale&, facet*, long); 165 static locale& __global(); 166 bool has_facet(id&) const; 167 const facet* use_facet(id&) const; 168 169 template <class _Facet> friend bool has_facet(const locale&) _NOEXCEPT; 170 template <class _Facet> friend const _Facet& use_facet(const locale&); 171 }; 172 173 class _LIBCPP_TYPE_VIS locale::facet 174 : public __shared_count 175 { 176 protected: 177 _LIBCPP_INLINE_VISIBILITY 178 explicit facet(size_t __refs = 0) 179 : __shared_count(static_cast<long>(__refs)-1) {} 180 181 virtual ~facet(); 182 183 // facet(const facet&) = delete; // effectively done in __shared_count 184 // void operator=(const facet&) = delete; 185 private: 186 virtual void __on_zero_shared() _NOEXCEPT; 187 }; 188 189 class _LIBCPP_TYPE_VIS locale::id 190 { 191 once_flag __flag_; 192 int32_t __id_; 193 194 static int32_t __next_id; 195 public: 196 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR id() :__id_(0) {} 197 private: 198 void __init(); 199 void operator=(const id&); // = delete; 200 id(const id&); // = delete; 201 public: // only needed for tests 202 long __get(); 203 204 friend class locale; 205 friend class locale::__imp; 206 }; 207 208 template <class _Facet> 209 inline _LIBCPP_INLINE_VISIBILITY 210 locale::locale(const locale& __other, _Facet* __f) 211 { 212 __install_ctor(__other, __f, __f ? __f->id.__get() : 0); 213 } 214 215 template <class _Facet> 216 locale 217 locale::combine(const locale& __other) const 218 { 219 if (!_VSTD::has_facet<_Facet>(__other)) 220 __throw_runtime_error("locale::combine: locale missing facet"); 221 222 return locale(*this, &const_cast<_Facet&>(_VSTD::use_facet<_Facet>(__other))); 223 } 224 225 template <class _Facet> 226 inline _LIBCPP_INLINE_VISIBILITY 227 bool 228 has_facet(const locale& __l) _NOEXCEPT 229 { 230 return __l.has_facet(_Facet::id); 231 } 232 233 template <class _Facet> 234 inline _LIBCPP_INLINE_VISIBILITY 235 const _Facet& 236 use_facet(const locale& __l) 237 { 238 return static_cast<const _Facet&>(*__l.use_facet(_Facet::id)); 239 } 240 241 // template <class _CharT> class collate; 242 243 template <class _CharT> 244 class _LIBCPP_TEMPLATE_VIS collate 245 : public locale::facet 246 { 247 public: 248 typedef _CharT char_type; 249 typedef basic_string<char_type> string_type; 250 251 _LIBCPP_INLINE_VISIBILITY 252 explicit collate(size_t __refs = 0) 253 : locale::facet(__refs) {} 254 255 _LIBCPP_INLINE_VISIBILITY 256 int compare(const char_type* __lo1, const char_type* __hi1, 257 const char_type* __lo2, const char_type* __hi2) const 258 { 259 return do_compare(__lo1, __hi1, __lo2, __hi2); 260 } 261 262 _LIBCPP_INLINE_VISIBILITY 263 string_type transform(const char_type* __lo, const char_type* __hi) const 264 { 265 return do_transform(__lo, __hi); 266 } 267 268 _LIBCPP_INLINE_VISIBILITY 269 long hash(const char_type* __lo, const char_type* __hi) const 270 { 271 return do_hash(__lo, __hi); 272 } 273 274 static locale::id id; 275 276 protected: 277 ~collate(); 278 virtual int do_compare(const char_type* __lo1, const char_type* __hi1, 279 const char_type* __lo2, const char_type* __hi2) const; 280 virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const 281 {return string_type(__lo, __hi);} 282 virtual long do_hash(const char_type* __lo, const char_type* __hi) const; 283 }; 284 285 template <class _CharT> locale::id collate<_CharT>::id; 286 287 template <class _CharT> 288 collate<_CharT>::~collate() 289 { 290 } 291 292 template <class _CharT> 293 int 294 collate<_CharT>::do_compare(const char_type* __lo1, const char_type* __hi1, 295 const char_type* __lo2, const char_type* __hi2) const 296 { 297 for (; __lo2 != __hi2; ++__lo1, ++__lo2) 298 { 299 if (__lo1 == __hi1 || *__lo1 < *__lo2) 300 return -1; 301 if (*__lo2 < *__lo1) 302 return 1; 303 } 304 return __lo1 != __hi1; 305 } 306 307 template <class _CharT> 308 long 309 collate<_CharT>::do_hash(const char_type* __lo, const char_type* __hi) const 310 { 311 size_t __h = 0; 312 const size_t __sr = __CHAR_BIT__ * sizeof(size_t) - 8; 313 const size_t __mask = size_t(0xF) << (__sr + 4); 314 for(const char_type* __p = __lo; __p != __hi; ++__p) 315 { 316 __h = (__h << 4) + static_cast<size_t>(*__p); 317 size_t __g = __h & __mask; 318 __h ^= __g | (__g >> __sr); 319 } 320 return static_cast<long>(__h); 321 } 322 323 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS collate<char>) 324 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS collate<wchar_t>) 325 326 // template <class CharT> class collate_byname; 327 328 template <class _CharT> class _LIBCPP_TEMPLATE_VIS collate_byname; 329 330 template <> 331 class _LIBCPP_TYPE_VIS collate_byname<char> 332 : public collate<char> 333 { 334 locale_t __l; 335 public: 336 typedef char char_type; 337 typedef basic_string<char_type> string_type; 338 339 explicit collate_byname(const char* __n, size_t __refs = 0); 340 explicit collate_byname(const string& __n, size_t __refs = 0); 341 342 protected: 343 ~collate_byname(); 344 virtual int do_compare(const char_type* __lo1, const char_type* __hi1, 345 const char_type* __lo2, const char_type* __hi2) const; 346 virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const; 347 }; 348 349 template <> 350 class _LIBCPP_TYPE_VIS collate_byname<wchar_t> 351 : public collate<wchar_t> 352 { 353 locale_t __l; 354 public: 355 typedef wchar_t char_type; 356 typedef basic_string<char_type> string_type; 357 358 explicit collate_byname(const char* __n, size_t __refs = 0); 359 explicit collate_byname(const string& __n, size_t __refs = 0); 360 361 protected: 362 ~collate_byname(); 363 364 virtual int do_compare(const char_type* __lo1, const char_type* __hi1, 365 const char_type* __lo2, const char_type* __hi2) const; 366 virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const; 367 }; 368 369 template <class _CharT, class _Traits, class _Allocator> 370 bool 371 locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x, 372 const basic_string<_CharT, _Traits, _Allocator>& __y) const 373 { 374 return _VSTD::use_facet<_VSTD::collate<_CharT> >(*this).compare( 375 __x.data(), __x.data() + __x.size(), 376 __y.data(), __y.data() + __y.size()) < 0; 377 } 378 379 // template <class charT> class ctype 380 381 class _LIBCPP_TYPE_VIS ctype_base 382 { 383 public: 384 #if defined(__GLIBC__) 385 typedef unsigned short mask; 386 static const mask space = _ISspace; 387 static const mask print = _ISprint; 388 static const mask cntrl = _IScntrl; 389 static const mask upper = _ISupper; 390 static const mask lower = _ISlower; 391 static const mask alpha = _ISalpha; 392 static const mask digit = _ISdigit; 393 static const mask punct = _ISpunct; 394 static const mask xdigit = _ISxdigit; 395 static const mask blank = _ISblank; 396 #elif defined(_LIBCPP_MSVCRT_LIKE) 397 typedef unsigned short mask; 398 static const mask space = _SPACE; 399 static const mask print = _BLANK|_PUNCT|_ALPHA|_DIGIT; 400 static const mask cntrl = _CONTROL; 401 static const mask upper = _UPPER; 402 static const mask lower = _LOWER; 403 static const mask alpha = _ALPHA; 404 static const mask digit = _DIGIT; 405 static const mask punct = _PUNCT; 406 static const mask xdigit = _HEX; 407 static const mask blank = _BLANK; 408 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT 409 #elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) 410 # ifdef __APPLE__ 411 typedef __uint32_t mask; 412 # elif defined(__FreeBSD__) 413 typedef unsigned long mask; 414 # elif defined(__EMSCRIPTEN__) || defined(__NetBSD__) 415 typedef unsigned short mask; 416 # endif 417 static const mask space = _CTYPE_S; 418 static const mask print = _CTYPE_R; 419 static const mask cntrl = _CTYPE_C; 420 static const mask upper = _CTYPE_U; 421 static const mask lower = _CTYPE_L; 422 static const mask alpha = _CTYPE_A; 423 static const mask digit = _CTYPE_D; 424 static const mask punct = _CTYPE_P; 425 static const mask xdigit = _CTYPE_X; 426 427 # if defined(__NetBSD__) 428 static const mask blank = _CTYPE_BL; 429 # else 430 static const mask blank = _CTYPE_B; 431 # endif 432 #elif defined(__sun__) || defined(_AIX) 433 typedef unsigned int mask; 434 static const mask space = _ISSPACE; 435 static const mask print = _ISPRINT; 436 static const mask cntrl = _ISCNTRL; 437 static const mask upper = _ISUPPER; 438 static const mask lower = _ISLOWER; 439 static const mask alpha = _ISALPHA; 440 static const mask digit = _ISDIGIT; 441 static const mask punct = _ISPUNCT; 442 static const mask xdigit = _ISXDIGIT; 443 static const mask blank = _ISBLANK; 444 #elif defined(_NEWLIB_VERSION) 445 // Same type as Newlib's _ctype_ array in newlib/libc/include/ctype.h. 446 typedef char mask; 447 static const mask space = _S; 448 static const mask print = _P | _U | _L | _N | _B; 449 static const mask cntrl = _C; 450 static const mask upper = _U; 451 static const mask lower = _L; 452 static const mask alpha = _U | _L; 453 static const mask digit = _N; 454 static const mask punct = _P; 455 static const mask xdigit = _X | _N; 456 static const mask blank = _B; 457 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT 458 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA 459 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT 460 #else 461 typedef unsigned long mask; 462 static const mask space = 1<<0; 463 static const mask print = 1<<1; 464 static const mask cntrl = 1<<2; 465 static const mask upper = 1<<3; 466 static const mask lower = 1<<4; 467 static const mask alpha = 1<<5; 468 static const mask digit = 1<<6; 469 static const mask punct = 1<<7; 470 static const mask xdigit = 1<<8; 471 static const mask blank = 1<<9; 472 #endif 473 static const mask alnum = alpha | digit; 474 static const mask graph = alnum | punct; 475 476 _LIBCPP_ALWAYS_INLINE ctype_base() {} 477 }; 478 479 template <class _CharT> class _LIBCPP_TEMPLATE_VIS ctype; 480 481 template <> 482 class _LIBCPP_TYPE_VIS ctype<wchar_t> 483 : public locale::facet, 484 public ctype_base 485 { 486 public: 487 typedef wchar_t char_type; 488 489 _LIBCPP_ALWAYS_INLINE 490 explicit ctype(size_t __refs = 0) 491 : locale::facet(__refs) {} 492 493 _LIBCPP_ALWAYS_INLINE 494 bool is(mask __m, char_type __c) const 495 { 496 return do_is(__m, __c); 497 } 498 499 _LIBCPP_ALWAYS_INLINE 500 const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const 501 { 502 return do_is(__low, __high, __vec); 503 } 504 505 _LIBCPP_ALWAYS_INLINE 506 const char_type* scan_is(mask __m, const char_type* __low, const char_type* __high) const 507 { 508 return do_scan_is(__m, __low, __high); 509 } 510 511 _LIBCPP_ALWAYS_INLINE 512 const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const 513 { 514 return do_scan_not(__m, __low, __high); 515 } 516 517 _LIBCPP_ALWAYS_INLINE 518 char_type toupper(char_type __c) const 519 { 520 return do_toupper(__c); 521 } 522 523 _LIBCPP_ALWAYS_INLINE 524 const char_type* toupper(char_type* __low, const char_type* __high) const 525 { 526 return do_toupper(__low, __high); 527 } 528 529 _LIBCPP_ALWAYS_INLINE 530 char_type tolower(char_type __c) const 531 { 532 return do_tolower(__c); 533 } 534 535 _LIBCPP_ALWAYS_INLINE 536 const char_type* tolower(char_type* __low, const char_type* __high) const 537 { 538 return do_tolower(__low, __high); 539 } 540 541 _LIBCPP_ALWAYS_INLINE 542 char_type widen(char __c) const 543 { 544 return do_widen(__c); 545 } 546 547 _LIBCPP_ALWAYS_INLINE 548 const char* widen(const char* __low, const char* __high, char_type* __to) const 549 { 550 return do_widen(__low, __high, __to); 551 } 552 553 _LIBCPP_ALWAYS_INLINE 554 char narrow(char_type __c, char __dfault) const 555 { 556 return do_narrow(__c, __dfault); 557 } 558 559 _LIBCPP_ALWAYS_INLINE 560 const char_type* narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const 561 { 562 return do_narrow(__low, __high, __dfault, __to); 563 } 564 565 static locale::id id; 566 567 protected: 568 ~ctype(); 569 virtual bool do_is(mask __m, char_type __c) const; 570 virtual const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const; 571 virtual const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const; 572 virtual const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const; 573 virtual char_type do_toupper(char_type) const; 574 virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const; 575 virtual char_type do_tolower(char_type) const; 576 virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const; 577 virtual char_type do_widen(char) const; 578 virtual const char* do_widen(const char* __low, const char* __high, char_type* __dest) const; 579 virtual char do_narrow(char_type, char __dfault) const; 580 virtual const char_type* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const; 581 }; 582 583 template <> 584 class _LIBCPP_TYPE_VIS ctype<char> 585 : public locale::facet, public ctype_base 586 { 587 const mask* __tab_; 588 bool __del_; 589 public: 590 typedef char char_type; 591 592 explicit ctype(const mask* __tab = 0, bool __del = false, size_t __refs = 0); 593 594 _LIBCPP_ALWAYS_INLINE 595 bool is(mask __m, char_type __c) const 596 { 597 return isascii(__c) ? (__tab_[static_cast<int>(__c)] & __m) !=0 : false; 598 } 599 600 _LIBCPP_ALWAYS_INLINE 601 const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const 602 { 603 for (; __low != __high; ++__low, ++__vec) 604 *__vec = isascii(*__low) ? __tab_[static_cast<int>(*__low)] : 0; 605 return __low; 606 } 607 608 _LIBCPP_ALWAYS_INLINE 609 const char_type* scan_is (mask __m, const char_type* __low, const char_type* __high) const 610 { 611 for (; __low != __high; ++__low) 612 if (isascii(*__low) && (__tab_[static_cast<int>(*__low)] & __m)) 613 break; 614 return __low; 615 } 616 617 _LIBCPP_ALWAYS_INLINE 618 const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const 619 { 620 for (; __low != __high; ++__low) 621 if (!(isascii(*__low) && (__tab_[static_cast<int>(*__low)] & __m))) 622 break; 623 return __low; 624 } 625 626 _LIBCPP_ALWAYS_INLINE 627 char_type toupper(char_type __c) const 628 { 629 return do_toupper(__c); 630 } 631 632 _LIBCPP_ALWAYS_INLINE 633 const char_type* toupper(char_type* __low, const char_type* __high) const 634 { 635 return do_toupper(__low, __high); 636 } 637 638 _LIBCPP_ALWAYS_INLINE 639 char_type tolower(char_type __c) const 640 { 641 return do_tolower(__c); 642 } 643 644 _LIBCPP_ALWAYS_INLINE 645 const char_type* tolower(char_type* __low, const char_type* __high) const 646 { 647 return do_tolower(__low, __high); 648 } 649 650 _LIBCPP_ALWAYS_INLINE 651 char_type widen(char __c) const 652 { 653 return do_widen(__c); 654 } 655 656 _LIBCPP_ALWAYS_INLINE 657 const char* widen(const char* __low, const char* __high, char_type* __to) const 658 { 659 return do_widen(__low, __high, __to); 660 } 661 662 _LIBCPP_ALWAYS_INLINE 663 char narrow(char_type __c, char __dfault) const 664 { 665 return do_narrow(__c, __dfault); 666 } 667 668 _LIBCPP_ALWAYS_INLINE 669 const char* narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const 670 { 671 return do_narrow(__low, __high, __dfault, __to); 672 } 673 674 static locale::id id; 675 676 #ifdef _CACHED_RUNES 677 static const size_t table_size = _CACHED_RUNES; 678 #else 679 static const size_t table_size = 256; // FIXME: Don't hardcode this. 680 #endif 681 _LIBCPP_ALWAYS_INLINE const mask* table() const _NOEXCEPT {return __tab_;} 682 static const mask* classic_table() _NOEXCEPT; 683 #if defined(__GLIBC__) || defined(__EMSCRIPTEN__) 684 static const int* __classic_upper_table() _NOEXCEPT; 685 static const int* __classic_lower_table() _NOEXCEPT; 686 #endif 687 #if defined(__NetBSD__) 688 static const short* __classic_upper_table() _NOEXCEPT; 689 static const short* __classic_lower_table() _NOEXCEPT; 690 #endif 691 692 protected: 693 ~ctype(); 694 virtual char_type do_toupper(char_type __c) const; 695 virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const; 696 virtual char_type do_tolower(char_type __c) const; 697 virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const; 698 virtual char_type do_widen(char __c) const; 699 virtual const char* do_widen(const char* __low, const char* __high, char_type* __to) const; 700 virtual char do_narrow(char_type __c, char __dfault) const; 701 virtual const char* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const; 702 }; 703 704 // template <class CharT> class ctype_byname; 705 706 template <class _CharT> class _LIBCPP_TEMPLATE_VIS ctype_byname; 707 708 template <> 709 class _LIBCPP_TYPE_VIS ctype_byname<char> 710 : public ctype<char> 711 { 712 locale_t __l; 713 714 public: 715 explicit ctype_byname(const char*, size_t = 0); 716 explicit ctype_byname(const string&, size_t = 0); 717 718 protected: 719 ~ctype_byname(); 720 virtual char_type do_toupper(char_type) const; 721 virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const; 722 virtual char_type do_tolower(char_type) const; 723 virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const; 724 }; 725 726 template <> 727 class _LIBCPP_TYPE_VIS ctype_byname<wchar_t> 728 : public ctype<wchar_t> 729 { 730 locale_t __l; 731 732 public: 733 explicit ctype_byname(const char*, size_t = 0); 734 explicit ctype_byname(const string&, size_t = 0); 735 736 protected: 737 ~ctype_byname(); 738 virtual bool do_is(mask __m, char_type __c) const; 739 virtual const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const; 740 virtual const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const; 741 virtual const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const; 742 virtual char_type do_toupper(char_type) const; 743 virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const; 744 virtual char_type do_tolower(char_type) const; 745 virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const; 746 virtual char_type do_widen(char) const; 747 virtual const char* do_widen(const char* __low, const char* __high, char_type* __dest) const; 748 virtual char do_narrow(char_type, char __dfault) const; 749 virtual const char_type* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const; 750 }; 751 752 template <class _CharT> 753 inline _LIBCPP_INLINE_VISIBILITY 754 bool 755 isspace(_CharT __c, const locale& __loc) 756 { 757 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); 758 } 759 760 template <class _CharT> 761 inline _LIBCPP_INLINE_VISIBILITY 762 bool 763 isprint(_CharT __c, const locale& __loc) 764 { 765 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); 766 } 767 768 template <class _CharT> 769 inline _LIBCPP_INLINE_VISIBILITY 770 bool 771 iscntrl(_CharT __c, const locale& __loc) 772 { 773 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); 774 } 775 776 template <class _CharT> 777 inline _LIBCPP_INLINE_VISIBILITY 778 bool 779 isupper(_CharT __c, const locale& __loc) 780 { 781 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); 782 } 783 784 template <class _CharT> 785 inline _LIBCPP_INLINE_VISIBILITY 786 bool 787 islower(_CharT __c, const locale& __loc) 788 { 789 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); 790 } 791 792 template <class _CharT> 793 inline _LIBCPP_INLINE_VISIBILITY 794 bool 795 isalpha(_CharT __c, const locale& __loc) 796 { 797 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); 798 } 799 800 template <class _CharT> 801 inline _LIBCPP_INLINE_VISIBILITY 802 bool 803 isdigit(_CharT __c, const locale& __loc) 804 { 805 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); 806 } 807 808 template <class _CharT> 809 inline _LIBCPP_INLINE_VISIBILITY 810 bool 811 ispunct(_CharT __c, const locale& __loc) 812 { 813 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); 814 } 815 816 template <class _CharT> 817 inline _LIBCPP_INLINE_VISIBILITY 818 bool 819 isxdigit(_CharT __c, const locale& __loc) 820 { 821 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); 822 } 823 824 template <class _CharT> 825 inline _LIBCPP_INLINE_VISIBILITY 826 bool 827 isalnum(_CharT __c, const locale& __loc) 828 { 829 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); 830 } 831 832 template <class _CharT> 833 inline _LIBCPP_INLINE_VISIBILITY 834 bool 835 isgraph(_CharT __c, const locale& __loc) 836 { 837 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); 838 } 839 840 template <class _CharT> 841 inline _LIBCPP_INLINE_VISIBILITY 842 _CharT 843 toupper(_CharT __c, const locale& __loc) 844 { 845 return use_facet<ctype<_CharT> >(__loc).toupper(__c); 846 } 847 848 template <class _CharT> 849 inline _LIBCPP_INLINE_VISIBILITY 850 _CharT 851 tolower(_CharT __c, const locale& __loc) 852 { 853 return use_facet<ctype<_CharT> >(__loc).tolower(__c); 854 } 855 856 // codecvt_base 857 858 class _LIBCPP_TYPE_VIS codecvt_base 859 { 860 public: 861 _LIBCPP_ALWAYS_INLINE codecvt_base() {} 862 enum result {ok, partial, error, noconv}; 863 }; 864 865 // template <class internT, class externT, class stateT> class codecvt; 866 867 template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_TEMPLATE_VIS codecvt; 868 869 // template <> class codecvt<char, char, mbstate_t> 870 871 template <> 872 class _LIBCPP_TYPE_VIS codecvt<char, char, mbstate_t> 873 : public locale::facet, 874 public codecvt_base 875 { 876 public: 877 typedef char intern_type; 878 typedef char extern_type; 879 typedef mbstate_t state_type; 880 881 _LIBCPP_ALWAYS_INLINE 882 explicit codecvt(size_t __refs = 0) 883 : locale::facet(__refs) {} 884 885 _LIBCPP_ALWAYS_INLINE 886 result out(state_type& __st, 887 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt, 888 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const 889 { 890 return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt); 891 } 892 893 _LIBCPP_ALWAYS_INLINE 894 result unshift(state_type& __st, 895 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const 896 { 897 return do_unshift(__st, __to, __to_end, __to_nxt); 898 } 899 900 _LIBCPP_ALWAYS_INLINE 901 result in(state_type& __st, 902 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt, 903 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const 904 { 905 return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt); 906 } 907 908 _LIBCPP_ALWAYS_INLINE 909 int encoding() const _NOEXCEPT 910 { 911 return do_encoding(); 912 } 913 914 _LIBCPP_ALWAYS_INLINE 915 bool always_noconv() const _NOEXCEPT 916 { 917 return do_always_noconv(); 918 } 919 920 _LIBCPP_ALWAYS_INLINE 921 int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const 922 { 923 return do_length(__st, __frm, __end, __mx); 924 } 925 926 _LIBCPP_ALWAYS_INLINE 927 int max_length() const _NOEXCEPT 928 { 929 return do_max_length(); 930 } 931 932 static locale::id id; 933 934 protected: 935 _LIBCPP_ALWAYS_INLINE 936 explicit codecvt(const char*, size_t __refs = 0) 937 : locale::facet(__refs) {} 938 939 ~codecvt(); 940 941 virtual result do_out(state_type& __st, 942 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt, 943 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; 944 virtual result do_in(state_type& __st, 945 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt, 946 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const; 947 virtual result do_unshift(state_type& __st, 948 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; 949 virtual int do_encoding() const _NOEXCEPT; 950 virtual bool do_always_noconv() const _NOEXCEPT; 951 virtual int do_length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const; 952 virtual int do_max_length() const _NOEXCEPT; 953 }; 954 955 // template <> class codecvt<wchar_t, char, mbstate_t> 956 957 template <> 958 class _LIBCPP_TYPE_VIS codecvt<wchar_t, char, mbstate_t> 959 : public locale::facet, 960 public codecvt_base 961 { 962 locale_t __l; 963 public: 964 typedef wchar_t intern_type; 965 typedef char extern_type; 966 typedef mbstate_t state_type; 967 968 explicit codecvt(size_t __refs = 0); 969 970 _LIBCPP_ALWAYS_INLINE 971 result out(state_type& __st, 972 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt, 973 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const 974 { 975 return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt); 976 } 977 978 _LIBCPP_ALWAYS_INLINE 979 result unshift(state_type& __st, 980 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const 981 { 982 return do_unshift(__st, __to, __to_end, __to_nxt); 983 } 984 985 _LIBCPP_ALWAYS_INLINE 986 result in(state_type& __st, 987 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt, 988 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const 989 { 990 return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt); 991 } 992 993 _LIBCPP_ALWAYS_INLINE 994 int encoding() const _NOEXCEPT 995 { 996 return do_encoding(); 997 } 998 999 _LIBCPP_ALWAYS_INLINE 1000 bool always_noconv() const _NOEXCEPT 1001 { 1002 return do_always_noconv(); 1003 } 1004 1005 _LIBCPP_ALWAYS_INLINE 1006 int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const 1007 { 1008 return do_length(__st, __frm, __end, __mx); 1009 } 1010 1011 _LIBCPP_ALWAYS_INLINE 1012 int max_length() const _NOEXCEPT 1013 { 1014 return do_max_length(); 1015 } 1016 1017 static locale::id id; 1018 1019 protected: 1020 explicit codecvt(const char*, size_t __refs = 0); 1021 1022 ~codecvt(); 1023 1024 virtual result do_out(state_type& __st, 1025 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt, 1026 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; 1027 virtual result do_in(state_type& __st, 1028 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt, 1029 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const; 1030 virtual result do_unshift(state_type& __st, 1031 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; 1032 virtual int do_encoding() const _NOEXCEPT; 1033 virtual bool do_always_noconv() const _NOEXCEPT; 1034 virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const; 1035 virtual int do_max_length() const _NOEXCEPT; 1036 }; 1037 1038 // template <> class codecvt<char16_t, char, mbstate_t> 1039 1040 template <> 1041 class _LIBCPP_TYPE_VIS codecvt<char16_t, char, mbstate_t> 1042 : public locale::facet, 1043 public codecvt_base 1044 { 1045 public: 1046 typedef char16_t intern_type; 1047 typedef char extern_type; 1048 typedef mbstate_t state_type; 1049 1050 _LIBCPP_ALWAYS_INLINE 1051 explicit codecvt(size_t __refs = 0) 1052 : locale::facet(__refs) {} 1053 1054 _LIBCPP_ALWAYS_INLINE 1055 result out(state_type& __st, 1056 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt, 1057 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const 1058 { 1059 return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt); 1060 } 1061 1062 _LIBCPP_ALWAYS_INLINE 1063 result unshift(state_type& __st, 1064 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const 1065 { 1066 return do_unshift(__st, __to, __to_end, __to_nxt); 1067 } 1068 1069 _LIBCPP_ALWAYS_INLINE 1070 result in(state_type& __st, 1071 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt, 1072 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const 1073 { 1074 return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt); 1075 } 1076 1077 _LIBCPP_ALWAYS_INLINE 1078 int encoding() const _NOEXCEPT 1079 { 1080 return do_encoding(); 1081 } 1082 1083 _LIBCPP_ALWAYS_INLINE 1084 bool always_noconv() const _NOEXCEPT 1085 { 1086 return do_always_noconv(); 1087 } 1088 1089 _LIBCPP_ALWAYS_INLINE 1090 int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const 1091 { 1092 return do_length(__st, __frm, __end, __mx); 1093 } 1094 1095 _LIBCPP_ALWAYS_INLINE 1096 int max_length() const _NOEXCEPT 1097 { 1098 return do_max_length(); 1099 } 1100 1101 static locale::id id; 1102 1103 protected: 1104 _LIBCPP_ALWAYS_INLINE 1105 explicit codecvt(const char*, size_t __refs = 0) 1106 : locale::facet(__refs) {} 1107 1108 ~codecvt(); 1109 1110 virtual result do_out(state_type& __st, 1111 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt, 1112 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; 1113 virtual result do_in(state_type& __st, 1114 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt, 1115 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const; 1116 virtual result do_unshift(state_type& __st, 1117 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; 1118 virtual int do_encoding() const _NOEXCEPT; 1119 virtual bool do_always_noconv() const _NOEXCEPT; 1120 virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const; 1121 virtual int do_max_length() const _NOEXCEPT; 1122 }; 1123 1124 // template <> class codecvt<char32_t, char, mbstate_t> 1125 1126 template <> 1127 class _LIBCPP_TYPE_VIS codecvt<char32_t, char, mbstate_t> 1128 : public locale::facet, 1129 public codecvt_base 1130 { 1131 public: 1132 typedef char32_t intern_type; 1133 typedef char extern_type; 1134 typedef mbstate_t state_type; 1135 1136 _LIBCPP_ALWAYS_INLINE 1137 explicit codecvt(size_t __refs = 0) 1138 : locale::facet(__refs) {} 1139 1140 _LIBCPP_ALWAYS_INLINE 1141 result out(state_type& __st, 1142 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt, 1143 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const 1144 { 1145 return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt); 1146 } 1147 1148 _LIBCPP_ALWAYS_INLINE 1149 result unshift(state_type& __st, 1150 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const 1151 { 1152 return do_unshift(__st, __to, __to_end, __to_nxt); 1153 } 1154 1155 _LIBCPP_ALWAYS_INLINE 1156 result in(state_type& __st, 1157 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt, 1158 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const 1159 { 1160 return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt); 1161 } 1162 1163 _LIBCPP_ALWAYS_INLINE 1164 int encoding() const _NOEXCEPT 1165 { 1166 return do_encoding(); 1167 } 1168 1169 _LIBCPP_ALWAYS_INLINE 1170 bool always_noconv() const _NOEXCEPT 1171 { 1172 return do_always_noconv(); 1173 } 1174 1175 _LIBCPP_ALWAYS_INLINE 1176 int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const 1177 { 1178 return do_length(__st, __frm, __end, __mx); 1179 } 1180 1181 _LIBCPP_ALWAYS_INLINE 1182 int max_length() const _NOEXCEPT 1183 { 1184 return do_max_length(); 1185 } 1186 1187 static locale::id id; 1188 1189 protected: 1190 _LIBCPP_ALWAYS_INLINE 1191 explicit codecvt(const char*, size_t __refs = 0) 1192 : locale::facet(__refs) {} 1193 1194 ~codecvt(); 1195 1196 virtual result do_out(state_type& __st, 1197 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt, 1198 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; 1199 virtual result do_in(state_type& __st, 1200 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt, 1201 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const; 1202 virtual result do_unshift(state_type& __st, 1203 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; 1204 virtual int do_encoding() const _NOEXCEPT; 1205 virtual bool do_always_noconv() const _NOEXCEPT; 1206 virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const; 1207 virtual int do_max_length() const _NOEXCEPT; 1208 }; 1209 1210 // template <class _InternT, class _ExternT, class _StateT> class codecvt_byname 1211 1212 template <class _InternT, class _ExternT, class _StateT> 1213 class _LIBCPP_TEMPLATE_VIS codecvt_byname 1214 : public codecvt<_InternT, _ExternT, _StateT> 1215 { 1216 public: 1217 _LIBCPP_ALWAYS_INLINE 1218 explicit codecvt_byname(const char* __nm, size_t __refs = 0) 1219 : codecvt<_InternT, _ExternT, _StateT>(__nm, __refs) {} 1220 _LIBCPP_ALWAYS_INLINE 1221 explicit codecvt_byname(const string& __nm, size_t __refs = 0) 1222 : codecvt<_InternT, _ExternT, _StateT>(__nm.c_str(), __refs) {} 1223 protected: 1224 ~codecvt_byname(); 1225 }; 1226 1227 template <class _InternT, class _ExternT, class _StateT> 1228 codecvt_byname<_InternT, _ExternT, _StateT>::~codecvt_byname() 1229 { 1230 } 1231 1232 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char, char, mbstate_t>) 1233 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<wchar_t, char, mbstate_t>) 1234 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char16_t, char, mbstate_t>) 1235 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char32_t, char, mbstate_t>) 1236 1237 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*); 1238 1239 template <size_t _Np> 1240 struct __narrow_to_utf8 1241 { 1242 template <class _OutputIterator, class _CharT> 1243 _OutputIterator 1244 operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const; 1245 }; 1246 1247 template <> 1248 struct __narrow_to_utf8<8> 1249 { 1250 template <class _OutputIterator, class _CharT> 1251 _LIBCPP_ALWAYS_INLINE 1252 _OutputIterator 1253 operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const 1254 { 1255 for (; __wb < __we; ++__wb, ++__s) 1256 *__s = *__wb; 1257 return __s; 1258 } 1259 }; 1260 1261 template <> 1262 struct __narrow_to_utf8<16> 1263 : public codecvt<char16_t, char, mbstate_t> 1264 { 1265 _LIBCPP_ALWAYS_INLINE 1266 __narrow_to_utf8() : codecvt<char16_t, char, mbstate_t>(1) {} 1267 1268 ~__narrow_to_utf8(); 1269 1270 template <class _OutputIterator, class _CharT> 1271 _LIBCPP_ALWAYS_INLINE 1272 _OutputIterator 1273 operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const 1274 { 1275 result __r = ok; 1276 mbstate_t __mb; 1277 while (__wb < __we && __r != error) 1278 { 1279 const int __sz = 32; 1280 char __buf[__sz]; 1281 char* __bn; 1282 const char16_t* __wn = (const char16_t*)__wb; 1283 __r = do_out(__mb, (const char16_t*)__wb, (const char16_t*)__we, __wn, 1284 __buf, __buf+__sz, __bn); 1285 if (__r == codecvt_base::error || __wn == (const char16_t*)__wb) 1286 __throw_runtime_error("locale not supported"); 1287 for (const char* __p = __buf; __p < __bn; ++__p, ++__s) 1288 *__s = *__p; 1289 __wb = (const _CharT*)__wn; 1290 } 1291 return __s; 1292 } 1293 }; 1294 1295 template <> 1296 struct __narrow_to_utf8<32> 1297 : public codecvt<char32_t, char, mbstate_t> 1298 { 1299 _LIBCPP_ALWAYS_INLINE 1300 __narrow_to_utf8() : codecvt<char32_t, char, mbstate_t>(1) {} 1301 1302 ~__narrow_to_utf8(); 1303 1304 template <class _OutputIterator, class _CharT> 1305 _LIBCPP_ALWAYS_INLINE 1306 _OutputIterator 1307 operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const 1308 { 1309 result __r = ok; 1310 mbstate_t __mb; 1311 while (__wb < __we && __r != error) 1312 { 1313 const int __sz = 32; 1314 char __buf[__sz]; 1315 char* __bn; 1316 const char32_t* __wn = (const char32_t*)__wb; 1317 __r = do_out(__mb, (const char32_t*)__wb, (const char32_t*)__we, __wn, 1318 __buf, __buf+__sz, __bn); 1319 if (__r == codecvt_base::error || __wn == (const char32_t*)__wb) 1320 __throw_runtime_error("locale not supported"); 1321 for (const char* __p = __buf; __p < __bn; ++__p, ++__s) 1322 *__s = *__p; 1323 __wb = (const _CharT*)__wn; 1324 } 1325 return __s; 1326 } 1327 }; 1328 1329 template <size_t _Np> 1330 struct __widen_from_utf8 1331 { 1332 template <class _OutputIterator> 1333 _OutputIterator 1334 operator()(_OutputIterator __s, const char* __nb, const char* __ne) const; 1335 }; 1336 1337 template <> 1338 struct __widen_from_utf8<8> 1339 { 1340 template <class _OutputIterator> 1341 _LIBCPP_ALWAYS_INLINE 1342 _OutputIterator 1343 operator()(_OutputIterator __s, const char* __nb, const char* __ne) const 1344 { 1345 for (; __nb < __ne; ++__nb, ++__s) 1346 *__s = *__nb; 1347 return __s; 1348 } 1349 }; 1350 1351 template <> 1352 struct __widen_from_utf8<16> 1353 : public codecvt<char16_t, char, mbstate_t> 1354 { 1355 _LIBCPP_ALWAYS_INLINE 1356 __widen_from_utf8() : codecvt<char16_t, char, mbstate_t>(1) {} 1357 1358 ~__widen_from_utf8(); 1359 1360 template <class _OutputIterator> 1361 _LIBCPP_ALWAYS_INLINE 1362 _OutputIterator 1363 operator()(_OutputIterator __s, const char* __nb, const char* __ne) const 1364 { 1365 result __r = ok; 1366 mbstate_t __mb; 1367 while (__nb < __ne && __r != error) 1368 { 1369 const int __sz = 32; 1370 char16_t __buf[__sz]; 1371 char16_t* __bn; 1372 const char* __nn = __nb; 1373 __r = do_in(__mb, __nb, __ne - __nb > __sz ? __nb+__sz : __ne, __nn, 1374 __buf, __buf+__sz, __bn); 1375 if (__r == codecvt_base::error || __nn == __nb) 1376 __throw_runtime_error("locale not supported"); 1377 for (const char16_t* __p = __buf; __p < __bn; ++__p, ++__s) 1378 *__s = (wchar_t)*__p; 1379 __nb = __nn; 1380 } 1381 return __s; 1382 } 1383 }; 1384 1385 template <> 1386 struct __widen_from_utf8<32> 1387 : public codecvt<char32_t, char, mbstate_t> 1388 { 1389 _LIBCPP_ALWAYS_INLINE 1390 __widen_from_utf8() : codecvt<char32_t, char, mbstate_t>(1) {} 1391 1392 ~__widen_from_utf8(); 1393 1394 template <class _OutputIterator> 1395 _LIBCPP_ALWAYS_INLINE 1396 _OutputIterator 1397 operator()(_OutputIterator __s, const char* __nb, const char* __ne) const 1398 { 1399 result __r = ok; 1400 mbstate_t __mb; 1401 while (__nb < __ne && __r != error) 1402 { 1403 const int __sz = 32; 1404 char32_t __buf[__sz]; 1405 char32_t* __bn; 1406 const char* __nn = __nb; 1407 __r = do_in(__mb, __nb, __ne - __nb > __sz ? __nb+__sz : __ne, __nn, 1408 __buf, __buf+__sz, __bn); 1409 if (__r == codecvt_base::error || __nn == __nb) 1410 __throw_runtime_error("locale not supported"); 1411 for (const char32_t* __p = __buf; __p < __bn; ++__p, ++__s) 1412 *__s = (wchar_t)*__p; 1413 __nb = __nn; 1414 } 1415 return __s; 1416 } 1417 }; 1418 1419 // template <class charT> class numpunct 1420 1421 template <class _CharT> class _LIBCPP_TEMPLATE_VIS numpunct; 1422 1423 template <> 1424 class _LIBCPP_TYPE_VIS numpunct<char> 1425 : public locale::facet 1426 { 1427 public: 1428 typedef char char_type; 1429 typedef basic_string<char_type> string_type; 1430 1431 explicit numpunct(size_t __refs = 0); 1432 1433 _LIBCPP_ALWAYS_INLINE char_type decimal_point() const {return do_decimal_point();} 1434 _LIBCPP_ALWAYS_INLINE char_type thousands_sep() const {return do_thousands_sep();} 1435 _LIBCPP_ALWAYS_INLINE string grouping() const {return do_grouping();} 1436 _LIBCPP_ALWAYS_INLINE string_type truename() const {return do_truename();} 1437 _LIBCPP_ALWAYS_INLINE string_type falsename() const {return do_falsename();} 1438 1439 static locale::id id; 1440 1441 protected: 1442 ~numpunct(); 1443 virtual char_type do_decimal_point() const; 1444 virtual char_type do_thousands_sep() const; 1445 virtual string do_grouping() const; 1446 virtual string_type do_truename() const; 1447 virtual string_type do_falsename() const; 1448 1449 char_type __decimal_point_; 1450 char_type __thousands_sep_; 1451 string __grouping_; 1452 }; 1453 1454 template <> 1455 class _LIBCPP_TYPE_VIS numpunct<wchar_t> 1456 : public locale::facet 1457 { 1458 public: 1459 typedef wchar_t char_type; 1460 typedef basic_string<char_type> string_type; 1461 1462 explicit numpunct(size_t __refs = 0); 1463 1464 _LIBCPP_ALWAYS_INLINE char_type decimal_point() const {return do_decimal_point();} 1465 _LIBCPP_ALWAYS_INLINE char_type thousands_sep() const {return do_thousands_sep();} 1466 _LIBCPP_ALWAYS_INLINE string grouping() const {return do_grouping();} 1467 _LIBCPP_ALWAYS_INLINE string_type truename() const {return do_truename();} 1468 _LIBCPP_ALWAYS_INLINE string_type falsename() const {return do_falsename();} 1469 1470 static locale::id id; 1471 1472 protected: 1473 ~numpunct(); 1474 virtual char_type do_decimal_point() const; 1475 virtual char_type do_thousands_sep() const; 1476 virtual string do_grouping() const; 1477 virtual string_type do_truename() const; 1478 virtual string_type do_falsename() const; 1479 1480 char_type __decimal_point_; 1481 char_type __thousands_sep_; 1482 string __grouping_; 1483 }; 1484 1485 // template <class charT> class numpunct_byname 1486 1487 template <class _CharT> class _LIBCPP_TEMPLATE_VIS numpunct_byname; 1488 1489 template <> 1490 class _LIBCPP_TYPE_VIS numpunct_byname<char> 1491 : public numpunct<char> 1492 { 1493 public: 1494 typedef char char_type; 1495 typedef basic_string<char_type> string_type; 1496 1497 explicit numpunct_byname(const char* __nm, size_t __refs = 0); 1498 explicit numpunct_byname(const string& __nm, size_t __refs = 0); 1499 1500 protected: 1501 ~numpunct_byname(); 1502 1503 private: 1504 void __init(const char*); 1505 }; 1506 1507 template <> 1508 class _LIBCPP_TYPE_VIS numpunct_byname<wchar_t> 1509 : public numpunct<wchar_t> 1510 { 1511 public: 1512 typedef wchar_t char_type; 1513 typedef basic_string<char_type> string_type; 1514 1515 explicit numpunct_byname(const char* __nm, size_t __refs = 0); 1516 explicit numpunct_byname(const string& __nm, size_t __refs = 0); 1517 1518 protected: 1519 ~numpunct_byname(); 1520 1521 private: 1522 void __init(const char*); 1523 }; 1524 1525 _LIBCPP_END_NAMESPACE_STD 1526 1527 #endif // _LIBCPP___LOCALE 1528
