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