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