include/__locale

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