contrib/libc++/src/locale.cpp

   1 //===------------------------- locale.cpp ---------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // On Solaris, we need to define something to make the C99 parts of localeconv
  11 // visible.
  12 #ifdef __sun__
  13 #define _LCONV_C99
  14 #endif
  15
  16 #include "string"
  17 #include "locale"
  18 #include "codecvt"
  19 #include "vector"
  20 #include "algorithm"
  21 #include "typeinfo"
  22 #ifndef _LIBCPP_NO_EXCEPTIONS
  23 #  include "type_traits"
  24 #endif
  25 #include "clocale"
  26 #include "cstring"
  27 #if defined(_LIBCPP_MSVCRT)
  28 #define _CTYPE_DISABLE_MACROS
  29 #endif
  30 #include "cwctype"
  31 #include "__sso_allocator"
  32 #if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
  33 #include "support/win32/locale_win32.h"
  34 #elif !defined(__BIONIC__)
  35 #include <langinfo.h>
  36 #endif
  37 #include <stdlib.h>
  38 #include <stdio.h>
  39 #include "__undef_macros"
  40
  41 // On Linux, wint_t and wchar_t have different signed-ness, and this causes
  42 // lots of noise in the build log, but no bugs that I know of.
  43 #if defined(__clang__)
  44 #pragma clang diagnostic ignored "-Wsign-conversion"
  45 #endif
  46
  47 _LIBCPP_BEGIN_NAMESPACE_STD
  48
  49 struct __libcpp_unique_locale {
  50   __libcpp_unique_locale(const char* nm) : __loc_(newlocale(LC_ALL_MASK, nm, 0)) {}
  51
  52   ~__libcpp_unique_locale() {
  53     if (__loc_)
  54       freelocale(__loc_);
  55   }
  56
  57   explicit operator bool() const { return __loc_; }
  58
  59   locale_t& get() { return __loc_; }
  60
  61   locale_t __loc_;
  62 private:
  63   __libcpp_unique_locale(__libcpp_unique_locale const&);
  64   __libcpp_unique_locale& operator=(__libcpp_unique_locale const&);
  65 };
  66
  67 #ifdef __cloc_defined
  68 locale_t __cloc() {
  69   // In theory this could create a race condition. In practice
  70   // the race condition is non-fatal since it will just create
  71   // a little resource leak. Better approach would be appreciated.
  72   static locale_t result = newlocale(LC_ALL_MASK, "C", 0);
  73   return result;
  74 }
  75 #endif // __cloc_defined
  76
  77 namespace {
  78
  79 struct release
  80 {
  81     void operator()(locale::facet* p) {p->__release_shared();}
  82 };
  83
  84 template <class T, class A0>
  85 inline
  86 T&
  87 make(A0 a0)
  88 {
  89     static typename aligned_storage<sizeof(T)>::type buf;
  90     auto *obj = ::new (&buf) T(a0);
  91     return *obj;
  92 }
  93
  94 template <class T, class A0, class A1>
  95 inline
  96 T&
  97 make(A0 a0, A1 a1)
  98 {
  99     static typename aligned_storage<sizeof(T)>::type buf;
 100     ::new (&buf) T(a0, a1);
 101     return *reinterpret_cast<T*>(&buf);
 102 }
 103
 104 template <class T, class A0, class A1, class A2>
 105 inline
 106 T&
 107 make(A0 a0, A1 a1, A2 a2)
 108 {
 109     static typename aligned_storage<sizeof(T)>::type buf;
 110     auto *obj = ::new (&buf) T(a0, a1, a2);
 111     return *obj;
 112 }
 113
 114 template <typename T, size_t N>
 115 inline
 116 _LIBCPP_CONSTEXPR
 117 size_t
 118 countof(const T (&)[N])
 119 {
 120     return N;
 121 }
 122
 123 template <typename T>
 124 inline
 125 _LIBCPP_CONSTEXPR
 126 size_t
 127 countof(const T * const begin, const T * const end)
 128 {
 129     return static_cast<size_t>(end - begin);
 130 }
 131
 132 _LIBCPP_NORETURN static void __throw_runtime_error(const string &msg)
 133 {
 134 #ifndef _LIBCPP_NO_EXCEPTIONS
 135     throw runtime_error(msg);
 136 #else
 137     (void)msg;
 138     _VSTD::abort();
 139 #endif
 140 }
 141
 142 }
 143
 144 #if defined(_AIX)
 145 // Set priority to INT_MIN + 256 + 150
 146 # pragma priority ( -2147483242 )
 147 #endif
 148
 149 const locale::category locale::none;
 150 const locale::category locale::collate;
 151 const locale::category locale::ctype;
 152 const locale::category locale::monetary;
 153 const locale::category locale::numeric;
 154 const locale::category locale::time;
 155 const locale::category locale::messages;
 156 const locale::category locale::all;
 157
 158 class _LIBCPP_HIDDEN locale::__imp
 159     : public facet
 160 {
 161     enum {N = 28};
 162 #if defined(_LIBCPP_COMPILER_MSVC)
 163 // FIXME: MSVC doesn't support aligned parameters by value.
 164 // I can't get the __sso_allocator to work here
 165 // for MSVC I think for this reason.
 166     vector<facet*> facets_;
 167 #else
 168     vector<facet*, __sso_allocator<facet*, N> > facets_;
 169 #endif
 170     string         name_;
 171 public:
 172     explicit __imp(size_t refs = 0);
 173     explicit __imp(const string& name, size_t refs = 0);
 174     __imp(const __imp&);
 175     __imp(const __imp&, const string&, locale::category c);
 176     __imp(const __imp& other, const __imp& one, locale::category c);
 177     __imp(const __imp&, facet* f, long id);
 178     ~__imp();
 179
 180     const string& name() const {return name_;}
 181     bool has_facet(long id) const
 182         {return static_cast<size_t>(id) < facets_.size() && facets_[static_cast<size_t>(id)];}
 183     const locale::facet* use_facet(long id) const;
 184
 185     static const locale& make_classic();
 186     static       locale& make_global();
 187 private:
 188     void install(facet* f, long id);
 189     template <class F> void install(F* f) {install(f, f->id.__get());}
 190     template <class F> void install_from(const __imp& other);
 191 };
 192
 193 locale::__imp::__imp(size_t refs)
 194     : facet(refs),
 195       facets_(N),
 196       name_("C")
 197 {
 198     facets_.clear();
 199     install(&make<_VSTD::collate<char> >(1u));
 200     install(&make<_VSTD::collate<wchar_t> >(1u));
 201     install(&make<_VSTD::ctype<char> >(nullptr, false, 1u));
 202     install(&make<_VSTD::ctype<wchar_t> >(1u));
 203     install(&make<codecvt<char, char, mbstate_t> >(1u));
 204     install(&make<codecvt<wchar_t, char, mbstate_t> >(1u));
 205     install(&make<codecvt<char16_t, char, mbstate_t> >(1u));
 206     install(&make<codecvt<char32_t, char, mbstate_t> >(1u));
 207     install(&make<numpunct<char> >(1u));
 208     install(&make<numpunct<wchar_t> >(1u));
 209     install(&make<num_get<char> >(1u));
 210     install(&make<num_get<wchar_t> >(1u));
 211     install(&make<num_put<char> >(1u));
 212     install(&make<num_put<wchar_t> >(1u));
 213     install(&make<moneypunct<char, false> >(1u));
 214     install(&make<moneypunct<char, true> >(1u));
 215     install(&make<moneypunct<wchar_t, false> >(1u));
 216     install(&make<moneypunct<wchar_t, true> >(1u));
 217     install(&make<money_get<char> >(1u));
 218     install(&make<money_get<wchar_t> >(1u));
 219     install(&make<money_put<char> >(1u));
 220     install(&make<money_put<wchar_t> >(1u));
 221     install(&make<time_get<char> >(1u));
 222     install(&make<time_get<wchar_t> >(1u));
 223     install(&make<time_put<char> >(1u));
 224     install(&make<time_put<wchar_t> >(1u));
 225     install(&make<_VSTD::messages<char> >(1u));
 226     install(&make<_VSTD::messages<wchar_t> >(1u));
 227 }
 228
 229 locale::__imp::__imp(const string& name, size_t refs)
 230     : facet(refs),
 231       facets_(N),
 232       name_(name)
 233 {
 234 #ifndef _LIBCPP_NO_EXCEPTIONS
 235     try
 236     {
 237 #endif  // _LIBCPP_NO_EXCEPTIONS
 238         facets_ = locale::classic().__locale_->facets_;
 239         for (unsigned i = 0; i < facets_.size(); ++i)
 240             if (facets_[i])
 241                 facets_[i]->__add_shared();
 242         install(new collate_byname<char>(name_));
 243         install(new collate_byname<wchar_t>(name_));
 244         install(new ctype_byname<char>(name_));
 245         install(new ctype_byname<wchar_t>(name_));
 246         install(new codecvt_byname<char, char, mbstate_t>(name_));
 247         install(new codecvt_byname<wchar_t, char, mbstate_t>(name_));
 248         install(new codecvt_byname<char16_t, char, mbstate_t>(name_));
 249         install(new codecvt_byname<char32_t, char, mbstate_t>(name_));
 250         install(new numpunct_byname<char>(name_));
 251         install(new numpunct_byname<wchar_t>(name_));
 252         install(new moneypunct_byname<char, false>(name_));
 253         install(new moneypunct_byname<char, true>(name_));
 254         install(new moneypunct_byname<wchar_t, false>(name_));
 255         install(new moneypunct_byname<wchar_t, true>(name_));
 256         install(new time_get_byname<char>(name_));
 257         install(new time_get_byname<wchar_t>(name_));
 258         install(new time_put_byname<char>(name_));
 259         install(new time_put_byname<wchar_t>(name_));
 260         install(new messages_byname<char>(name_));
 261         install(new messages_byname<wchar_t>(name_));
 262 #ifndef _LIBCPP_NO_EXCEPTIONS
 263     }
 264     catch (...)
 265     {
 266         for (unsigned i = 0; i < facets_.size(); ++i)
 267             if (facets_[i])
 268                 facets_[i]->__release_shared();
 269         throw;
 270     }
 271 #endif  // _LIBCPP_NO_EXCEPTIONS
 272 }
 273
 274 // NOTE avoid the `base class should be explicitly initialized in the
 275 // copy constructor` warning emitted by GCC
 276 #if defined(__clang__) || _GNUC_VER >= 406
 277 #pragma GCC diagnostic push
 278 #pragma GCC diagnostic ignored "-Wextra"
 279 #endif
 280
 281 locale::__imp::__imp(const __imp& other)
 282     : facets_(max<size_t>(N, other.facets_.size())),
 283       name_(other.name_)
 284 {
 285     facets_ = other.facets_;
 286     for (unsigned i = 0; i < facets_.size(); ++i)
 287         if (facets_[i])
 288             facets_[i]->__add_shared();
 289 }
 290
 291 #if defined(__clang__) || _GNUC_VER >= 406
 292 #pragma GCC diagnostic pop
 293 #endif
 294
 295 locale::__imp::__imp(const __imp& other, const string& name, locale::category c)
 296     : facets_(N),
 297       name_("*")
 298 {
 299     facets_ = other.facets_;
 300     for (unsigned i = 0; i < facets_.size(); ++i)
 301         if (facets_[i])
 302             facets_[i]->__add_shared();
 303 #ifndef _LIBCPP_NO_EXCEPTIONS
 304     try
 305     {
 306 #endif  // _LIBCPP_NO_EXCEPTIONS
 307         if (c & locale::collate)
 308         {
 309             install(new collate_byname<char>(name));
 310             install(new collate_byname<wchar_t>(name));
 311         }
 312         if (c & locale::ctype)
 313         {
 314             install(new ctype_byname<char>(name));
 315             install(new ctype_byname<wchar_t>(name));
 316             install(new codecvt_byname<char, char, mbstate_t>(name));
 317             install(new codecvt_byname<wchar_t, char, mbstate_t>(name));
 318             install(new codecvt_byname<char16_t, char, mbstate_t>(name));
 319             install(new codecvt_byname<char32_t, char, mbstate_t>(name));
 320         }
 321         if (c & locale::monetary)
 322         {
 323             install(new moneypunct_byname<char, false>(name));
 324             install(new moneypunct_byname<char, true>(name));
 325             install(new moneypunct_byname<wchar_t, false>(name));
 326             install(new moneypunct_byname<wchar_t, true>(name));
 327         }
 328         if (c & locale::numeric)
 329         {
 330             install(new numpunct_byname<char>(name));
 331             install(new numpunct_byname<wchar_t>(name));
 332         }
 333         if (c & locale::time)
 334         {
 335             install(new time_get_byname<char>(name));
 336             install(new time_get_byname<wchar_t>(name));
 337             install(new time_put_byname<char>(name));
 338             install(new time_put_byname<wchar_t>(name));
 339         }
 340         if (c & locale::messages)
 341         {
 342             install(new messages_byname<char>(name));
 343             install(new messages_byname<wchar_t>(name));
 344         }
 345 #ifndef _LIBCPP_NO_EXCEPTIONS
 346     }
 347     catch (...)
 348     {
 349         for (unsigned i = 0; i < facets_.size(); ++i)
 350             if (facets_[i])
 351                 facets_[i]->__release_shared();
 352         throw;
 353     }
 354 #endif  // _LIBCPP_NO_EXCEPTIONS
 355 }
 356
 357 template<class F>
 358 inline
 359 void
 360 locale::__imp::install_from(const locale::__imp& one)
 361 {
 362     long id = F::id.__get();
 363     install(const_cast<F*>(static_cast<const F*>(one.use_facet(id))), id);
 364 }
 365
 366 locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c)
 367     : facets_(N),
 368       name_("*")
 369 {
 370     facets_ = other.facets_;
 371     for (unsigned i = 0; i < facets_.size(); ++i)
 372         if (facets_[i])
 373             facets_[i]->__add_shared();
 374 #ifndef _LIBCPP_NO_EXCEPTIONS
 375     try
 376     {
 377 #endif  // _LIBCPP_NO_EXCEPTIONS
 378         if (c & locale::collate)
 379         {
 380             install_from<_VSTD::collate<char> >(one);
 381             install_from<_VSTD::collate<wchar_t> >(one);
 382         }
 383         if (c & locale::ctype)
 384         {
 385             install_from<_VSTD::ctype<char> >(one);
 386             install_from<_VSTD::ctype<wchar_t> >(one);
 387             install_from<_VSTD::codecvt<char, char, mbstate_t> >(one);
 388             install_from<_VSTD::codecvt<char16_t, char, mbstate_t> >(one);
 389             install_from<_VSTD::codecvt<char32_t, char, mbstate_t> >(one);
 390             install_from<_VSTD::codecvt<wchar_t, char, mbstate_t> >(one);
 391         }
 392         if (c & locale::monetary)
 393         {
 394             install_from<moneypunct<char, false> >(one);
 395             install_from<moneypunct<char, true> >(one);
 396             install_from<moneypunct<wchar_t, false> >(one);
 397             install_from<moneypunct<wchar_t, true> >(one);
 398             install_from<money_get<char> >(one);
 399             install_from<money_get<wchar_t> >(one);
 400             install_from<money_put<char> >(one);
 401             install_from<money_put<wchar_t> >(one);
 402         }
 403         if (c & locale::numeric)
 404         {
 405             install_from<numpunct<char> >(one);
 406             install_from<numpunct<wchar_t> >(one);
 407             install_from<num_get<char> >(one);
 408             install_from<num_get<wchar_t> >(one);
 409             install_from<num_put<char> >(one);
 410             install_from<num_put<wchar_t> >(one);
 411         }
 412         if (c & locale::time)
 413         {
 414             install_from<time_get<char> >(one);
 415             install_from<time_get<wchar_t> >(one);
 416             install_from<time_put<char> >(one);
 417             install_from<time_put<wchar_t> >(one);
 418         }
 419         if (c & locale::messages)
 420         {
 421             install_from<_VSTD::messages<char> >(one);
 422             install_from<_VSTD::messages<wchar_t> >(one);
 423         }
 424 #ifndef _LIBCPP_NO_EXCEPTIONS
 425     }
 426     catch (...)
 427     {
 428         for (unsigned i = 0; i < facets_.size(); ++i)
 429             if (facets_[i])
 430                 facets_[i]->__release_shared();
 431         throw;
 432     }
 433 #endif  // _LIBCPP_NO_EXCEPTIONS
 434 }
 435
 436 locale::__imp::__imp(const __imp& other, facet* f, long id)
 437     : facets_(max<size_t>(N, other.facets_.size()+1)),
 438       name_("*")
 439 {
 440     f->__add_shared();
 441     unique_ptr<facet, release> hold(f);
 442     facets_ = other.facets_;
 443     for (unsigned i = 0; i < other.facets_.size(); ++i)
 444         if (facets_[i])
 445             facets_[i]->__add_shared();
 446     install(hold.get(), id);
 447 }
 448
 449 locale::__imp::~__imp()
 450 {
 451     for (unsigned i = 0; i < facets_.size(); ++i)
 452         if (facets_[i])
 453             facets_[i]->__release_shared();
 454 }
 455
 456 void
 457 locale::__imp::install(facet* f, long id)
 458 {
 459     f->__add_shared();
 460     unique_ptr<facet, release> hold(f);
 461     if (static_cast<size_t>(id) >= facets_.size())
 462         facets_.resize(static_cast<size_t>(id+1));
 463     if (facets_[static_cast<size_t>(id)])
 464         facets_[static_cast<size_t>(id)]->__release_shared();
 465     facets_[static_cast<size_t>(id)] = hold.release();
 466 }
 467
 468 const locale::facet*
 469 locale::__imp::use_facet(long id) const
 470 {
 471 #ifndef _LIBCPP_NO_EXCEPTIONS
 472     if (!has_facet(id))
 473         throw bad_cast();
 474 #endif  // _LIBCPP_NO_EXCEPTIONS
 475     return facets_[static_cast<size_t>(id)];
 476 }
 477
 478 // locale
 479
 480 const locale&
 481 locale::__imp::make_classic()
 482 {
 483     // only one thread can get in here and it only gets in once
 484     static aligned_storage<sizeof(locale)>::type buf;
 485     locale* c = reinterpret_cast<locale*>(&buf);
 486     c->__locale_ = &make<__imp>(1u);
 487     return *c;
 488 }
 489
 490 const locale&
 491 locale::classic()
 492 {
 493     static const locale& c = __imp::make_classic();
 494     return c;
 495 }
 496
 497 locale&
 498 locale::__imp::make_global()
 499 {
 500     // only one thread can get in here and it only gets in once
 501     static aligned_storage<sizeof(locale)>::type buf;
 502     auto *obj = ::new (&buf) locale(locale::classic());
 503     return *obj;
 504 }
 505
 506 locale&
 507 locale::__global()
 508 {
 509     static locale& g = __imp::make_global();
 510     return g;
 511 }
 512
 513 locale::locale()  _NOEXCEPT
 514     : __locale_(__global().__locale_)
 515 {
 516     __locale_->__add_shared();
 517 }
 518
 519 locale::locale(const locale& l)  _NOEXCEPT
 520     : __locale_(l.__locale_)
 521 {
 522     __locale_->__add_shared();
 523 }
 524
 525 locale::~locale()
 526 {
 527     __locale_->__release_shared();
 528 }
 529
 530 const locale&
 531 locale::operator=(const locale& other)  _NOEXCEPT
 532 {
 533     other.__locale_->__add_shared();
 534     __locale_->__release_shared();
 535     __locale_ = other.__locale_;
 536     return *this;
 537 }
 538
 539 locale::locale(const char* name)
 540 #ifndef _LIBCPP_NO_EXCEPTIONS
 541     : __locale_(name ? new __imp(name)
 542                      : throw runtime_error("locale constructed with null"))
 543 #else  // _LIBCPP_NO_EXCEPTIONS
 544     : __locale_(new __imp(name))
 545 #endif
 546 {
 547     __locale_->__add_shared();
 548 }
 549
 550 locale::locale(const string& name)
 551     : __locale_(new __imp(name))
 552 {
 553     __locale_->__add_shared();
 554 }
 555
 556 locale::locale(const locale& other, const char* name, category c)
 557 #ifndef _LIBCPP_NO_EXCEPTIONS
 558     : __locale_(name ? new __imp(*other.__locale_, name, c)
 559                      : throw runtime_error("locale constructed with null"))
 560 #else  // _LIBCPP_NO_EXCEPTIONS
 561     : __locale_(new __imp(*other.__locale_, name, c))
 562 #endif
 563 {
 564     __locale_->__add_shared();
 565 }
 566
 567 locale::locale(const locale& other, const string& name, category c)
 568     : __locale_(new __imp(*other.__locale_, name, c))
 569 {
 570     __locale_->__add_shared();
 571 }
 572
 573 locale::locale(const locale& other, const locale& one, category c)
 574     : __locale_(new __imp(*other.__locale_, *one.__locale_, c))
 575 {
 576     __locale_->__add_shared();
 577 }
 578
 579 string
 580 locale::name() const
 581 {
 582     return __locale_->name();
 583 }
 584
 585 void
 586 locale::__install_ctor(const locale& other, facet* f, long id)
 587 {
 588     if (f)
 589         __locale_ = new __imp(*other.__locale_, f, id);
 590     else
 591         __locale_ = other.__locale_;
 592     __locale_->__add_shared();
 593 }
 594
 595 locale
 596 locale::global(const locale& loc)
 597 {
 598     locale& g = __global();
 599     locale r = g;
 600     g = loc;
 601     if (g.name() != "*")
 602         setlocale(LC_ALL, g.name().c_str());
 603     return r;
 604 }
 605
 606 bool
 607 locale::has_facet(id& x) const
 608 {
 609     return __locale_->has_facet(x.__get());
 610 }
 611
 612 const locale::facet*
 613 locale::use_facet(id& x) const
 614 {
 615     return __locale_->use_facet(x.__get());
 616 }
 617
 618 bool
 619 locale::operator==(const locale& y) const
 620 {
 621     return (__locale_ == y.__locale_)
 622         || (__locale_->name() != "*" && __locale_->name() == y.__locale_->name());
 623 }
 624
 625 // locale::facet
 626
 627 locale::facet::~facet()
 628 {
 629 }
 630
 631 void
 632 locale::facet::__on_zero_shared() _NOEXCEPT
 633 {
 634     delete this;
 635 }
 636
 637 // locale::id
 638
 639 int32_t locale::id::__next_id = 0;
 640
 641 namespace
 642 {
 643
 644 class __fake_bind
 645 {
 646     locale::id* id_;
 647     void (locale::id::* pmf_)();
 648 public:
 649     __fake_bind(void (locale::id::* pmf)(), locale::id* id)
 650         : id_(id), pmf_(pmf) {}
 651
 652     void operator()() const
 653     {
 654         (id_->*pmf_)();
 655     }
 656 };
 657
 658 }
 659
 660 long
 661 locale::id::__get()
 662 {
 663     call_once(__flag_, __fake_bind(&locale::id::__init, this));
 664     return __id_ - 1;
 665 }
 666
 667 void
 668 locale::id::__init()
 669 {
 670     __id_ = __sync_add_and_fetch(&__next_id, 1);
 671 }
 672
 673 // template <> class collate_byname<char>
 674
 675 collate_byname<char>::collate_byname(const char* n, size_t refs)
 676     : collate<char>(refs),
 677       __l(newlocale(LC_ALL_MASK, n, 0))
 678 {
 679     if (__l == 0)
 680         __throw_runtime_error("collate_byname<char>::collate_byname"
 681                             " failed to construct for " + string(n));
 682 }
 683
 684 collate_byname<char>::collate_byname(const string& name, size_t refs)
 685     : collate<char>(refs),
 686       __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
 687 {
 688     if (__l == 0)
 689         __throw_runtime_error("collate_byname<char>::collate_byname"
 690                             " failed to construct for " + name);
 691 }
 692
 693 collate_byname<char>::~collate_byname()
 694 {
 695     freelocale(__l);
 696 }
 697
 698 int
 699 collate_byname<char>::do_compare(const char_type* __lo1, const char_type* __hi1,
 700                                  const char_type* __lo2, const char_type* __hi2) const
 701 {
 702     string_type lhs(__lo1, __hi1);
 703     string_type rhs(__lo2, __hi2);
 704     int r = strcoll_l(lhs.c_str(), rhs.c_str(), __l);
 705     if (r < 0)
 706         return -1;
 707     if (r > 0)
 708         return 1;
 709     return r;
 710 }
 711
 712 collate_byname<char>::string_type
 713 collate_byname<char>::do_transform(const char_type* lo, const char_type* hi) const
 714 {
 715     const string_type in(lo, hi);
 716     string_type out(strxfrm_l(0, in.c_str(), 0, __l), char());
 717     strxfrm_l(const_cast<char*>(out.c_str()), in.c_str(), out.size()+1, __l);
 718     return out;
 719 }
 720
 721 // template <> class collate_byname<wchar_t>
 722
 723 collate_byname<wchar_t>::collate_byname(const char* n, size_t refs)
 724     : collate<wchar_t>(refs),
 725       __l(newlocale(LC_ALL_MASK, n, 0))
 726 {
 727     if (__l == 0)
 728         __throw_runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
 729                             " failed to construct for " + string(n));
 730 }
 731
 732 collate_byname<wchar_t>::collate_byname(const string& name, size_t refs)
 733     : collate<wchar_t>(refs),
 734       __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
 735 {
 736     if (__l == 0)
 737         __throw_runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
 738                             " failed to construct for " + name);
 739 }
 740
 741 collate_byname<wchar_t>::~collate_byname()
 742 {
 743     freelocale(__l);
 744 }
 745
 746 int
 747 collate_byname<wchar_t>::do_compare(const char_type* __lo1, const char_type* __hi1,
 748                                  const char_type* __lo2, const char_type* __hi2) const
 749 {
 750     string_type lhs(__lo1, __hi1);
 751     string_type rhs(__lo2, __hi2);
 752     int r = wcscoll_l(lhs.c_str(), rhs.c_str(), __l);
 753     if (r < 0)
 754         return -1;
 755     if (r > 0)
 756         return 1;
 757     return r;
 758 }
 759
 760 collate_byname<wchar_t>::string_type
 761 collate_byname<wchar_t>::do_transform(const char_type* lo, const char_type* hi) const
 762 {
 763     const string_type in(lo, hi);
 764     string_type out(wcsxfrm_l(0, in.c_str(), 0, __l), wchar_t());
 765     wcsxfrm_l(const_cast<wchar_t*>(out.c_str()), in.c_str(), out.size()+1, __l);
 766     return out;
 767 }
 768
 769 // template <> class ctype<wchar_t>;
 770
 771 const ctype_base::mask ctype_base::space;
 772 const ctype_base::mask ctype_base::print;
 773 const ctype_base::mask ctype_base::cntrl;
 774 const ctype_base::mask ctype_base::upper;
 775 const ctype_base::mask ctype_base::lower;
 776 const ctype_base::mask ctype_base::alpha;
 777 const ctype_base::mask ctype_base::digit;
 778 const ctype_base::mask ctype_base::punct;
 779 const ctype_base::mask ctype_base::xdigit;
 780 const ctype_base::mask ctype_base::blank;
 781 const ctype_base::mask ctype_base::alnum;
 782 const ctype_base::mask ctype_base::graph;
 783
 784 locale::id ctype<wchar_t>::id;
 785
 786 ctype<wchar_t>::~ctype()
 787 {
 788 }
 789
 790 bool
 791 ctype<wchar_t>::do_is(mask m, char_type c) const
 792 {
 793     return isascii(c) ? (ctype<char>::classic_table()[c] & m) != 0 : false;
 794 }
 795
 796 const wchar_t*
 797 ctype<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const
 798 {
 799     for (; low != high; ++low, ++vec)
 800         *vec = static_cast<mask>(isascii(*low) ?
 801                                    ctype<char>::classic_table()[*low] : 0);
 802     return low;
 803 }
 804
 805 const wchar_t*
 806 ctype<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const
 807 {
 808     for (; low != high; ++low)
 809         if (isascii(*low) && (ctype<char>::classic_table()[*low] & m))
 810             break;
 811     return low;
 812 }
 813
 814 const wchar_t*
 815 ctype<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const
 816 {
 817     for (; low != high; ++low)
 818         if (!(isascii(*low) && (ctype<char>::classic_table()[*low] & m)))
 819             break;
 820     return low;
 821 }
 822
 823 wchar_t
 824 ctype<wchar_t>::do_toupper(char_type c) const
 825 {
 826 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
 827     return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c;
 828 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
 829       defined(__NetBSD__)
 830     return isascii(c) ? ctype<char>::__classic_upper_table()[c] : c;
 831 #else
 832     return (isascii(c) && iswlower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'a'+L'A' : c;
 833 #endif
 834 }
 835
 836 const wchar_t*
 837 ctype<wchar_t>::do_toupper(char_type* low, const char_type* high) const
 838 {
 839     for (; low != high; ++low)
 840 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
 841         *low = isascii(*low) ? _DefaultRuneLocale.__mapupper[*low] : *low;
 842 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
 843       defined(__NetBSD__)
 844         *low = isascii(*low) ? ctype<char>::__classic_upper_table()[*low]
 845                              : *low;
 846 #else
 847         *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? (*low-L'a'+L'A') : *low;
 848 #endif
 849     return low;
 850 }
 851
 852 wchar_t
 853 ctype<wchar_t>::do_tolower(char_type c) const
 854 {
 855 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
 856     return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c;
 857 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
 858       defined(__NetBSD__)
 859     return isascii(c) ? ctype<char>::__classic_lower_table()[c] : c;
 860 #else
 861     return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'A'+'a' : c;
 862 #endif
 863 }
 864
 865 const wchar_t*
 866 ctype<wchar_t>::do_tolower(char_type* low, const char_type* high) const
 867 {
 868     for (; low != high; ++low)
 869 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
 870         *low = isascii(*low) ? _DefaultRuneLocale.__maplower[*low] : *low;
 871 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
 872       defined(__NetBSD__)
 873         *low = isascii(*low) ? ctype<char>::__classic_lower_table()[*low]
 874                              : *low;
 875 #else
 876         *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-L'A'+L'a' : *low;
 877 #endif
 878     return low;
 879 }
 880
 881 wchar_t
 882 ctype<wchar_t>::do_widen(char c) const
 883 {
 884     return c;
 885 }
 886
 887 const char*
 888 ctype<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const
 889 {
 890     for (; low != high; ++low, ++dest)
 891         *dest = *low;
 892     return low;
 893 }
 894
 895 char
 896 ctype<wchar_t>::do_narrow(char_type c, char dfault) const
 897 {
 898     if (isascii(c))
 899         return static_cast<char>(c);
 900     return dfault;
 901 }
 902
 903 const wchar_t*
 904 ctype<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
 905 {
 906     for (; low != high; ++low, ++dest)
 907         if (isascii(*low))
 908             *dest = static_cast<char>(*low);
 909         else
 910             *dest = dfault;
 911     return low;
 912 }
 913
 914 // template <> class ctype<char>;
 915
 916 locale::id ctype<char>::id;
 917
 918 ctype<char>::ctype(const mask* tab, bool del, size_t refs)
 919     : locale::facet(refs),
 920       __tab_(tab),
 921       __del_(del)
 922 {
 923   if (__tab_ == 0)
 924       __tab_ = classic_table();
 925 }
 926
 927 ctype<char>::~ctype()
 928 {
 929     if (__tab_ && __del_)
 930         delete [] __tab_;
 931 }
 932
 933 char
 934 ctype<char>::do_toupper(char_type c) const
 935 {
 936 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
 937     return isascii(c) ?
 938       static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(c)]) : c;
 939 #elif defined(__NetBSD__)
 940     return static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]);
 941 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
 942     return isascii(c) ?
 943       static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]) : c;
 944 #else
 945     return (isascii(c) && islower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'a'+'A' : c;
 946 #endif
 947 }
 948
 949 const char*
 950 ctype<char>::do_toupper(char_type* low, const char_type* high) const
 951 {
 952     for (; low != high; ++low)
 953 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
 954         *low = isascii(*low) ?
 955           static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(*low)]) : *low;
 956 #elif defined(__NetBSD__)
 957         *low = static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(*low)]);
 958 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
 959         *low = isascii(*low) ?
 960           static_cast<char>(__classic_upper_table()[static_cast<size_t>(*low)]) : *low;
 961 #else
 962         *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-'a'+'A' : *low;
 963 #endif
 964     return low;
 965 }
 966
 967 char
 968 ctype<char>::do_tolower(char_type c) const
 969 {
 970 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
 971     return isascii(c) ?
 972       static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(c)]) : c;
 973 #elif defined(__NetBSD__)
 974     return static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(c)]);
 975 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
 976     return isascii(c) ?
 977       static_cast<char>(__classic_lower_table()[static_cast<size_t>(c)]) : c;
 978 #else
 979     return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'A'+'a' : c;
 980 #endif
 981 }
 982
 983 const char*
 984 ctype<char>::do_tolower(char_type* low, const char_type* high) const
 985 {
 986     for (; low != high; ++low)
 987 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
 988         *low = isascii(*low) ? static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(*low)]) : *low;
 989 #elif defined(__NetBSD__)
 990         *low = static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(*low)]);
 991 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
 992         *low = isascii(*low) ? static_cast<char>(__classic_lower_table()[static_cast<size_t>(*low)]) : *low;
 993 #else
 994         *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-'A'+'a' : *low;
 995 #endif
 996     return low;
 997 }
 998
 999 char
1000 ctype<char>::do_widen(char c) const
1001 {
1002     return c;
1003 }
1004
1005 const char*
1006 ctype<char>::do_widen(const char* low, const char* high, char_type* dest) const
1007 {
1008     for (; low != high; ++low, ++dest)
1009         *dest = *low;
1010     return low;
1011 }
1012
1013 char
1014 ctype<char>::do_narrow(char_type c, char dfault) const
1015 {
1016     if (isascii(c))
1017         return static_cast<char>(c);
1018     return dfault;
1019 }
1020
1021 const char*
1022 ctype<char>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
1023 {
1024     for (; low != high; ++low, ++dest)
1025         if (isascii(*low))
1026             *dest = *low;
1027         else
1028             *dest = dfault;
1029     return low;
1030 }
1031
1032 #if defined(__EMSCRIPTEN__)
1033 extern "C" const unsigned short ** __ctype_b_loc();
1034 extern "C" const int ** __ctype_tolower_loc();
1035 extern "C" const int ** __ctype_toupper_loc();
1036 #endif
1037
1038 #ifdef _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
1039 const ctype<char>::mask*
1040 ctype<char>::classic_table()  _NOEXCEPT
1041 {
1042     static _LIBCPP_CONSTEXPR const ctype<char>::mask builtin_table[table_size] = {
1043         cntrl,                          cntrl,
1044         cntrl,                          cntrl,
1045         cntrl,                          cntrl,
1046         cntrl,                          cntrl,
1047         cntrl,                          cntrl | space | blank,
1048         cntrl | space,                  cntrl | space,
1049         cntrl | space,                  cntrl | space,
1050         cntrl,                          cntrl,
1051         cntrl,                          cntrl,
1052         cntrl,                          cntrl,
1053         cntrl,                          cntrl,
1054         cntrl,                          cntrl,
1055         cntrl,                          cntrl,
1056         cntrl,                          cntrl,
1057         cntrl,                          cntrl,
1058         cntrl,                          cntrl,
1059         space | blank | print,          punct | print,
1060         punct | print,                  punct | print,
1061         punct | print,                  punct | print,
1062         punct | print,                  punct | print,
1063         punct | print,                  punct | print,
1064         punct | print,                  punct | print,
1065         punct | print,                  punct | print,
1066         punct | print,                  punct | print,
1067         digit | print | xdigit,         digit | print | xdigit,
1068         digit | print | xdigit,         digit | print | xdigit,
1069         digit | print | xdigit,         digit | print | xdigit,
1070         digit | print | xdigit,         digit | print | xdigit,
1071         digit | print | xdigit,         digit | print | xdigit,
1072         punct | print,                  punct | print,
1073         punct | print,                  punct | print,
1074         punct | print,                  punct | print,
1075         punct | print,                  upper | xdigit | print | alpha,
1076         upper | xdigit | print | alpha, upper | xdigit | print | alpha,
1077         upper | xdigit | print | alpha, upper | xdigit | print | alpha,
1078         upper | xdigit | print | alpha, upper | print | alpha,
1079         upper | print | alpha,          upper | print | alpha,
1080         upper | print | alpha,          upper | print | alpha,
1081         upper | print | alpha,          upper | print | alpha,
1082         upper | print | alpha,          upper | print | alpha,
1083         upper | print | alpha,          upper | print | alpha,
1084         upper | print | alpha,          upper | print | alpha,
1085         upper | print | alpha,          upper | print | alpha,
1086         upper | print | alpha,          upper | print | alpha,
1087         upper | print | alpha,          upper | print | alpha,
1088         upper | print | alpha,          punct | print,
1089         punct | print,                  punct | print,
1090         punct | print,                  punct | print,
1091         punct | print,                  lower | xdigit | print | alpha,
1092         lower | xdigit | print | alpha, lower | xdigit | print | alpha,
1093         lower | xdigit | print | alpha, lower | xdigit | print | alpha,
1094         lower | xdigit | print | alpha, lower | print | alpha,
1095         lower | print | alpha,          lower | print | alpha,
1096         lower | print | alpha,          lower | print | alpha,
1097         lower | print | alpha,          lower | print | alpha,
1098         lower | print | alpha,          lower | print | alpha,
1099         lower | print | alpha,          lower | print | alpha,
1100         lower | print | alpha,          lower | print | alpha,
1101         lower | print | alpha,          lower | print | alpha,
1102         lower | print | alpha,          lower | print | alpha,
1103         lower | print | alpha,          lower | print | alpha,
1104         lower | print | alpha,          punct | print,
1105         punct | print,                  punct | print,
1106         punct | print,                  cntrl,
1107         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1108         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1109         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1110         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1111         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1112         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1113         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1114         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
1115     };
1116     return builtin_table;
1117 }
1118 #else
1119 const ctype<char>::mask*
1120 ctype<char>::classic_table()  _NOEXCEPT
1121 {
1122 #if defined(__APPLE__) || defined(__FreeBSD__)
1123     return _DefaultRuneLocale.__runetype;
1124 #elif defined(__NetBSD__)
1125     return _C_ctype_tab_ + 1;
1126 #elif defined(__GLIBC__)
1127     return _LIBCPP_GET_C_LOCALE->__ctype_b;
1128 #elif __sun__
1129     return __ctype_mask;
1130 #elif defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
1131     return __pctype_func();
1132 #elif defined(__EMSCRIPTEN__)
1133     return *__ctype_b_loc();
1134 #elif defined(_NEWLIB_VERSION)
1135     // Newlib has a 257-entry table in ctype_.c, where (char)0 starts at [1].
1136     return _ctype_ + 1;
1137 #elif defined(_AIX)
1138     return (const unsigned int *)__lc_ctype_ptr->obj->mask;
1139 #else
1140     // Platform not supported: abort so the person doing the port knows what to
1141     // fix
1142 # warning  ctype<char>::classic_table() is not implemented
1143     printf("ctype<char>::classic_table() is not implemented\n");
1144     abort();
1145     return NULL;
1146 #endif
1147 }
1148 #endif
1149
1150 #if defined(__GLIBC__)
1151 const int*
1152 ctype<char>::__classic_lower_table() _NOEXCEPT
1153 {
1154     return _LIBCPP_GET_C_LOCALE->__ctype_tolower;
1155 }
1156
1157 const int*
1158 ctype<char>::__classic_upper_table() _NOEXCEPT
1159 {
1160     return _LIBCPP_GET_C_LOCALE->__ctype_toupper;
1161 }
1162 #elif __NetBSD__
1163 const short*
1164 ctype<char>::__classic_lower_table() _NOEXCEPT
1165 {
1166     return _C_tolower_tab_ + 1;
1167 }
1168
1169 const short*
1170 ctype<char>::__classic_upper_table() _NOEXCEPT
1171 {
1172     return _C_toupper_tab_ + 1;
1173 }
1174
1175 #elif defined(__EMSCRIPTEN__)
1176 const int*
1177 ctype<char>::__classic_lower_table() _NOEXCEPT
1178 {
1179     return *__ctype_tolower_loc();
1180 }
1181
1182 const int*
1183 ctype<char>::__classic_upper_table() _NOEXCEPT
1184 {
1185     return *__ctype_toupper_loc();
1186 }
1187 #endif // __GLIBC__ || __NETBSD__ || __EMSCRIPTEN__
1188
1189 // template <> class ctype_byname<char>
1190
1191 ctype_byname<char>::ctype_byname(const char* name, size_t refs)
1192     : ctype<char>(0, false, refs),
1193       __l(newlocale(LC_ALL_MASK, name, 0))
1194 {
1195     if (__l == 0)
1196         __throw_runtime_error("ctype_byname<char>::ctype_byname"
1197                             " failed to construct for " + string(name));
1198 }
1199
1200 ctype_byname<char>::ctype_byname(const string& name, size_t refs)
1201     : ctype<char>(0, false, refs),
1202       __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
1203 {
1204     if (__l == 0)
1205         __throw_runtime_error("ctype_byname<char>::ctype_byname"
1206                             " failed to construct for " + name);
1207 }
1208
1209 ctype_byname<char>::~ctype_byname()
1210 {
1211     freelocale(__l);
1212 }
1213
1214 char
1215 ctype_byname<char>::do_toupper(char_type c) const
1216 {
1217     return static_cast<char>(toupper_l(static_cast<unsigned char>(c), __l));
1218 }
1219
1220 const char*
1221 ctype_byname<char>::do_toupper(char_type* low, const char_type* high) const
1222 {
1223     for (; low != high; ++low)
1224         *low = static_cast<char>(toupper_l(static_cast<unsigned char>(*low), __l));
1225     return low;
1226 }
1227
1228 char
1229 ctype_byname<char>::do_tolower(char_type c) const
1230 {
1231     return static_cast<char>(tolower_l(static_cast<unsigned char>(c), __l));
1232 }
1233
1234 const char*
1235 ctype_byname<char>::do_tolower(char_type* low, const char_type* high) const
1236 {
1237     for (; low != high; ++low)
1238         *low = static_cast<char>(tolower_l(static_cast<unsigned char>(*low), __l));
1239     return low;
1240 }
1241
1242 // template <> class ctype_byname<wchar_t>
1243
1244 ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
1245     : ctype<wchar_t>(refs),
1246       __l(newlocale(LC_ALL_MASK, name, 0))
1247 {
1248     if (__l == 0)
1249         __throw_runtime_error("ctype_byname<wchar_t>::ctype_byname"
1250                             " failed to construct for " + string(name));
1251 }
1252
1253 ctype_byname<wchar_t>::ctype_byname(const string& name, size_t refs)
1254     : ctype<wchar_t>(refs),
1255       __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
1256 {
1257     if (__l == 0)
1258         __throw_runtime_error("ctype_byname<wchar_t>::ctype_byname"
1259                             " failed to construct for " + name);
1260 }
1261
1262 ctype_byname<wchar_t>::~ctype_byname()
1263 {
1264     freelocale(__l);
1265 }
1266
1267 bool
1268 ctype_byname<wchar_t>::do_is(mask m, char_type c) const
1269 {
1270 #ifdef _LIBCPP_WCTYPE_IS_MASK
1271     return static_cast<bool>(iswctype_l(c, m, __l));
1272 #else
1273     bool result = false;
1274     wint_t ch = static_cast<wint_t>(c);
1275     if ((m & space) == space) result |= (iswspace_l(ch, __l) != 0);
1276     if ((m & print) == print) result |= (iswprint_l(ch, __l) != 0);
1277     if ((m & cntrl) == cntrl) result |= (iswcntrl_l(ch, __l) != 0);
1278     if ((m & upper) == upper) result |= (iswupper_l(ch, __l) != 0);
1279     if ((m & lower) == lower) result |= (iswlower_l(ch, __l) != 0);
1280     if ((m & alpha) == alpha) result |= (iswalpha_l(ch, __l) != 0);
1281     if ((m & digit) == digit) result |= (iswdigit_l(ch, __l) != 0);
1282     if ((m & punct) == punct) result |= (iswpunct_l(ch, __l) != 0);
1283     if ((m & xdigit) == xdigit) result |= (iswxdigit_l(ch, __l) != 0);
1284     if ((m & blank) == blank) result |= (iswblank_l(ch, __l) != 0);
1285     return result;
1286 #endif
1287 }
1288
1289 const wchar_t*
1290 ctype_byname<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const
1291 {
1292     for (; low != high; ++low, ++vec)
1293     {
1294         if (isascii(*low))
1295             *vec = static_cast<mask>(ctype<char>::classic_table()[*low]);
1296         else
1297         {
1298             *vec = 0;
1299             wint_t ch = static_cast<wint_t>(*low);
1300             if (iswspace_l(ch, __l))
1301                 *vec |= space;
1302 #ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
1303             if (iswprint_l(ch, __l))
1304                 *vec |= print;
1305 #endif
1306             if (iswcntrl_l(ch, __l))
1307                 *vec |= cntrl;
1308             if (iswupper_l(ch, __l))
1309                 *vec |= upper;
1310             if (iswlower_l(ch, __l))
1311                 *vec |= lower;
1312 #ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
1313             if (iswalpha_l(ch, __l))
1314                 *vec |= alpha;
1315 #endif
1316             if (iswdigit_l(ch, __l))
1317                 *vec |= digit;
1318             if (iswpunct_l(ch, __l))
1319                 *vec |= punct;
1320 #ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT
1321             if (iswxdigit_l(ch, __l))
1322                 *vec |= xdigit;
1323 #endif
1324 #if !defined(__sun__)
1325             if (iswblank_l(ch, __l))
1326                 *vec |= blank;
1327 #endif
1328         }
1329     }
1330     return low;
1331 }
1332
1333 const wchar_t*
1334 ctype_byname<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const
1335 {
1336     for (; low != high; ++low)
1337     {
1338 #ifdef _LIBCPP_WCTYPE_IS_MASK
1339         if (iswctype_l(*low, m, __l))
1340             break;
1341 #else
1342         wint_t ch = static_cast<wint_t>(*low);
1343         if ((m & space) == space && iswspace_l(ch, __l)) break;
1344         if ((m & print) == print && iswprint_l(ch, __l)) break;
1345         if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l)) break;
1346         if ((m & upper) == upper && iswupper_l(ch, __l)) break;
1347         if ((m & lower) == lower && iswlower_l(ch, __l)) break;
1348         if ((m & alpha) == alpha && iswalpha_l(ch, __l)) break;
1349         if ((m & digit) == digit && iswdigit_l(ch, __l)) break;
1350         if ((m & punct) == punct && iswpunct_l(ch, __l)) break;
1351         if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l)) break;
1352         if ((m & blank) == blank && iswblank_l(ch, __l)) break;
1353 #endif
1354     }
1355     return low;
1356 }
1357
1358 const wchar_t*
1359 ctype_byname<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const
1360 {
1361     for (; low != high; ++low)
1362     {
1363 #ifdef _LIBCPP_WCTYPE_IS_MASK
1364         if (!iswctype_l(*low, m, __l))
1365             break;
1366 #else
1367         wint_t ch = static_cast<wint_t>(*low);
1368         if ((m & space) == space && iswspace_l(ch, __l)) continue;
1369         if ((m & print) == print && iswprint_l(ch, __l)) continue;
1370         if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l)) continue;
1371         if ((m & upper) == upper && iswupper_l(ch, __l)) continue;
1372         if ((m & lower) == lower && iswlower_l(ch, __l)) continue;
1373         if ((m & alpha) == alpha && iswalpha_l(ch, __l)) continue;
1374         if ((m & digit) == digit && iswdigit_l(ch, __l)) continue;
1375         if ((m & punct) == punct && iswpunct_l(ch, __l)) continue;
1376         if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l)) continue;
1377         if ((m & blank) == blank && iswblank_l(ch, __l)) continue;
1378         break;
1379 #endif
1380     }
1381     return low;
1382 }
1383
1384 wchar_t
1385 ctype_byname<wchar_t>::do_toupper(char_type c) const
1386 {
1387     return towupper_l(c, __l);
1388 }
1389
1390 const wchar_t*
1391 ctype_byname<wchar_t>::do_toupper(char_type* low, const char_type* high) const
1392 {
1393     for (; low != high; ++low)
1394         *low = towupper_l(*low, __l);
1395     return low;
1396 }
1397
1398 wchar_t
1399 ctype_byname<wchar_t>::do_tolower(char_type c) const
1400 {
1401     return towlower_l(c, __l);
1402 }
1403
1404 const wchar_t*
1405 ctype_byname<wchar_t>::do_tolower(char_type* low, const char_type* high) const
1406 {
1407     for (; low != high; ++low)
1408         *low = towlower_l(*low, __l);
1409     return low;
1410 }
1411
1412 wchar_t
1413 ctype_byname<wchar_t>::do_widen(char c) const
1414 {
1415     return __libcpp_btowc_l(c, __l);
1416 }
1417
1418 const char*
1419 ctype_byname<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const
1420 {
1421     for (; low != high; ++low, ++dest)
1422         *dest = __libcpp_btowc_l(*low, __l);
1423     return low;
1424 }
1425
1426 char
1427 ctype_byname<wchar_t>::do_narrow(char_type c, char dfault) const
1428 {
1429     int r = __libcpp_wctob_l(c, __l);
1430     return r != static_cast<int>(WEOF) ? static_cast<char>(r) : dfault;
1431 }
1432
1433 const wchar_t*
1434 ctype_byname<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
1435 {
1436     for (; low != high; ++low, ++dest)
1437     {
1438         int r = __libcpp_wctob_l(*low, __l);
1439         *dest = r != static_cast<int>(WEOF) ? static_cast<char>(r) : dfault;
1440     }
1441     return low;
1442 }
1443
1444 // template <> class codecvt<char, char, mbstate_t>
1445
1446 locale::id codecvt<char, char, mbstate_t>::id;
1447
1448 codecvt<char, char, mbstate_t>::~codecvt()
1449 {
1450 }
1451
1452 codecvt<char, char, mbstate_t>::result
1453 codecvt<char, char, mbstate_t>::do_out(state_type&,
1454     const intern_type* frm, const intern_type*, const intern_type*& frm_nxt,
1455     extern_type* to, extern_type*, extern_type*& to_nxt) const
1456 {
1457     frm_nxt = frm;
1458     to_nxt = to;
1459     return noconv;
1460 }
1461
1462 codecvt<char, char, mbstate_t>::result
1463 codecvt<char, char, mbstate_t>::do_in(state_type&,
1464     const extern_type* frm, const extern_type*, const extern_type*& frm_nxt,
1465     intern_type* to, intern_type*, intern_type*& to_nxt) const
1466 {
1467     frm_nxt = frm;
1468     to_nxt = to;
1469     return noconv;
1470 }
1471
1472 codecvt<char, char, mbstate_t>::result
1473 codecvt<char, char, mbstate_t>::do_unshift(state_type&,
1474     extern_type* to, extern_type*, extern_type*& to_nxt) const
1475 {
1476     to_nxt = to;
1477     return noconv;
1478 }
1479
1480 int
1481 codecvt<char, char, mbstate_t>::do_encoding() const  _NOEXCEPT
1482 {
1483     return 1;
1484 }
1485
1486 bool
1487 codecvt<char, char, mbstate_t>::do_always_noconv() const  _NOEXCEPT
1488 {
1489     return true;
1490 }
1491
1492 int
1493 codecvt<char, char, mbstate_t>::do_length(state_type&,
1494     const extern_type* frm, const extern_type* end, size_t mx) const
1495 {
1496     return static_cast<int>(min<size_t>(mx, static_cast<size_t>(end-frm)));
1497 }
1498
1499 int
1500 codecvt<char, char, mbstate_t>::do_max_length() const  _NOEXCEPT
1501 {
1502     return 1;
1503 }
1504
1505 // template <> class codecvt<wchar_t, char, mbstate_t>
1506
1507 locale::id codecvt<wchar_t, char, mbstate_t>::id;
1508
1509 codecvt<wchar_t, char, mbstate_t>::codecvt(size_t refs)
1510     : locale::facet(refs),
1511       __l(_LIBCPP_GET_C_LOCALE)
1512 {
1513 }
1514
1515 codecvt<wchar_t, char, mbstate_t>::codecvt(const char* nm, size_t refs)
1516     : locale::facet(refs),
1517       __l(newlocale(LC_ALL_MASK, nm, 0))
1518 {
1519     if (__l == 0)
1520         __throw_runtime_error("codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname"
1521                             " failed to construct for " + string(nm));
1522 }
1523
1524 codecvt<wchar_t, char, mbstate_t>::~codecvt()
1525 {
1526     if (__l != _LIBCPP_GET_C_LOCALE)
1527         freelocale(__l);
1528 }
1529
1530 codecvt<wchar_t, char, mbstate_t>::result
1531 codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st,
1532     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
1533     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
1534 {
1535     // look for first internal null in frm
1536     const intern_type* fend = frm;
1537     for (; fend != frm_end; ++fend)
1538         if (*fend == 0)
1539             break;
1540     // loop over all null-terminated sequences in frm
1541     to_nxt = to;
1542     for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt)
1543     {
1544         // save state in case it is needed to recover to_nxt on error
1545         mbstate_t save_state = st;
1546         size_t n = __libcpp_wcsnrtombs_l(to, &frm_nxt, static_cast<size_t>(fend-frm),
1547                                      static_cast<size_t>(to_end-to), &st, __l);
1548         if (n == size_t(-1))
1549         {
1550             // need to recover to_nxt
1551             for (to_nxt = to; frm != frm_nxt; ++frm)
1552             {
1553                 n = __libcpp_wcrtomb_l(to_nxt, *frm, &save_state, __l);
1554                 if (n == size_t(-1))
1555                     break;
1556                 to_nxt += n;
1557             }
1558             frm_nxt = frm;
1559             return error;
1560         }
1561         if (n == 0)
1562             return partial;
1563         to_nxt += n;
1564         if (to_nxt == to_end)
1565             break;
1566         if (fend != frm_end)  // set up next null terminated sequence
1567         {
1568             // Try to write the terminating null
1569             extern_type tmp[MB_LEN_MAX];
1570             n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l);
1571             if (n == size_t(-1))  // on error
1572                 return error;
1573             if (n > static_cast<size_t>(to_end-to_nxt))  // is there room?
1574                 return partial;
1575             for (extern_type* p = tmp; n; --n)  // write it
1576                 *to_nxt++ = *p++;
1577             ++frm_nxt;
1578             // look for next null in frm
1579             for (fend = frm_nxt; fend != frm_end; ++fend)
1580                 if (*fend == 0)
1581                     break;
1582         }
1583     }
1584     return frm_nxt == frm_end ? ok : partial;
1585 }
1586
1587 codecvt<wchar_t, char, mbstate_t>::result
1588 codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st,
1589     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
1590     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
1591 {
1592     // look for first internal null in frm
1593     const extern_type* fend = frm;
1594     for (; fend != frm_end; ++fend)
1595         if (*fend == 0)
1596             break;
1597     // loop over all null-terminated sequences in frm
1598     to_nxt = to;
1599     for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt)
1600     {
1601         // save state in case it is needed to recover to_nxt on error
1602         mbstate_t save_state = st;
1603         size_t n = __libcpp_mbsnrtowcs_l(to, &frm_nxt, static_cast<size_t>(fend-frm),
1604                                      static_cast<size_t>(to_end-to), &st, __l);
1605         if (n == size_t(-1))
1606         {
1607             // need to recover to_nxt
1608             for (to_nxt = to; frm != frm_nxt; ++to_nxt)
1609             {
1610                 n = __libcpp_mbrtowc_l(to_nxt, frm, static_cast<size_t>(fend-frm),
1611                                    &save_state, __l);
1612                 switch (n)
1613                 {
1614                 case 0:
1615                     ++frm;
1616                     break;
1617                 case size_t(-1):
1618                     frm_nxt = frm;
1619                     return error;
1620                 case size_t(-2):
1621                     frm_nxt = frm;
1622                     return partial;
1623                 default:
1624                     frm += n;
1625                     break;
1626                 }
1627             }
1628             frm_nxt = frm;
1629             return frm_nxt == frm_end ? ok : partial;
1630         }
1631         if (n == size_t(-1))
1632             return error;
1633         to_nxt += n;
1634         if (to_nxt == to_end)
1635             break;
1636         if (fend != frm_end)  // set up next null terminated sequence
1637         {
1638             // Try to write the terminating null
1639             n = __libcpp_mbrtowc_l(to_nxt, frm_nxt, 1, &st, __l);
1640             if (n != 0)  // on error
1641                 return error;
1642             ++to_nxt;
1643             ++frm_nxt;
1644             // look for next null in frm
1645             for (fend = frm_nxt; fend != frm_end; ++fend)
1646                 if (*fend == 0)
1647                     break;
1648         }
1649     }
1650     return frm_nxt == frm_end ? ok : partial;
1651 }
1652
1653 codecvt<wchar_t, char, mbstate_t>::result
1654 codecvt<wchar_t, char, mbstate_t>::do_unshift(state_type& st,
1655     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
1656 {
1657     to_nxt = to;
1658     extern_type tmp[MB_LEN_MAX];
1659     size_t n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l);
1660     if (n == size_t(-1) || n == 0)  // on error
1661         return error;
1662     --n;
1663     if (n > static_cast<size_t>(to_end-to_nxt))  // is there room?
1664         return partial;
1665     for (extern_type* p = tmp; n; --n)  // write it
1666         *to_nxt++ = *p++;
1667     return ok;
1668 }
1669
1670 int
1671 codecvt<wchar_t, char, mbstate_t>::do_encoding() const  _NOEXCEPT
1672 {
1673     if (__libcpp_mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l) != 0)
1674         return -1;
1675
1676     // stateless encoding
1677     if (__l == 0 || __libcpp_mb_cur_max_l(__l) == 1)  // there are no known constant length encodings
1678         return 1;                // which take more than 1 char to form a wchar_t
1679     return 0;
1680 }
1681
1682 bool
1683 codecvt<wchar_t, char, mbstate_t>::do_always_noconv() const  _NOEXCEPT
1684 {
1685     return false;
1686 }
1687
1688 int
1689 codecvt<wchar_t, char, mbstate_t>::do_length(state_type& st,
1690     const extern_type* frm, const extern_type* frm_end, size_t mx) const
1691 {
1692     int nbytes = 0;
1693     for (size_t nwchar_t = 0; nwchar_t < mx && frm != frm_end; ++nwchar_t)
1694     {
1695         size_t n = __libcpp_mbrlen_l(frm, static_cast<size_t>(frm_end-frm), &st, __l);
1696         switch (n)
1697         {
1698         case 0:
1699             ++nbytes;
1700             ++frm;
1701             break;
1702         case size_t(-1):
1703         case size_t(-2):
1704             return nbytes;
1705         default:
1706             nbytes += n;
1707             frm += n;
1708             break;
1709         }
1710     }
1711     return nbytes;
1712 }
1713
1714 int
1715 codecvt<wchar_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
1716 {
1717     return __l == 0 ? 1 : static_cast<int>(__libcpp_mb_cur_max_l(__l));
1718 }
1719
1720 //                                     Valid UTF ranges
1721 //     UTF-32               UTF-16                          UTF-8               # of code points
1722 //                     first      second       first   second    third   fourth
1723 // 000000 - 00007F  0000 - 007F               00 - 7F                                 127
1724 // 000080 - 0007FF  0080 - 07FF               C2 - DF, 80 - BF                       1920
1725 // 000800 - 000FFF  0800 - 0FFF               E0 - E0, A0 - BF, 80 - BF              2048
1726 // 001000 - 00CFFF  1000 - CFFF               E1 - EC, 80 - BF, 80 - BF             49152
1727 // 00D000 - 00D7FF  D000 - D7FF               ED - ED, 80 - 9F, 80 - BF              2048
1728 // 00D800 - 00DFFF                invalid
1729 // 00E000 - 00FFFF  E000 - FFFF               EE - EF, 80 - BF, 80 - BF              8192
1730 // 010000 - 03FFFF  D800 - D8BF, DC00 - DFFF  F0 - F0, 90 - BF, 80 - BF, 80 - BF   196608
1731 // 040000 - 0FFFFF  D8C0 - DBBF, DC00 - DFFF  F1 - F3, 80 - BF, 80 - BF, 80 - BF   786432
1732 // 100000 - 10FFFF  DBC0 - DBFF, DC00 - DFFF  F4 - F4, 80 - 8F, 80 - BF, 80 - BF    65536
1733
1734 static
1735 codecvt_base::result
1736 utf16_to_utf8(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
1737               uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
1738               unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
1739 {
1740     frm_nxt = frm;
1741     to_nxt = to;
1742     if (mode & generate_header)
1743     {
1744         if (to_end-to_nxt < 3)
1745             return codecvt_base::partial;
1746         *to_nxt++ = static_cast<uint8_t>(0xEF);
1747         *to_nxt++ = static_cast<uint8_t>(0xBB);
1748         *to_nxt++ = static_cast<uint8_t>(0xBF);
1749     }
1750     for (; frm_nxt < frm_end; ++frm_nxt)
1751     {
1752         uint16_t wc1 = *frm_nxt;
1753         if (wc1 > Maxcode)
1754             return codecvt_base::error;
1755         if (wc1 < 0x0080)
1756         {
1757             if (to_end-to_nxt < 1)
1758                 return codecvt_base::partial;
1759             *to_nxt++ = static_cast<uint8_t>(wc1);
1760         }
1761         else if (wc1 < 0x0800)
1762         {
1763             if (to_end-to_nxt < 2)
1764                 return codecvt_base::partial;
1765             *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
1766             *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
1767         }
1768         else if (wc1 < 0xD800)
1769         {
1770             if (to_end-to_nxt < 3)
1771                 return codecvt_base::partial;
1772             *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
1773             *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
1774             *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
1775         }
1776         else if (wc1 < 0xDC00)
1777         {
1778             if (frm_end-frm_nxt < 2)
1779                 return codecvt_base::partial;
1780             uint16_t wc2 = frm_nxt[1];
1781             if ((wc2 & 0xFC00) != 0xDC00)
1782                 return codecvt_base::error;
1783             if (to_end-to_nxt < 4)
1784                 return codecvt_base::partial;
1785             if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) +
1786                 ((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
1787                 return codecvt_base::error;
1788             ++frm_nxt;
1789             uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
1790             *to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
1791             *to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4)     | ((wc1 & 0x003C) >> 2));
1792             *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
1793             *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc2 & 0x003F));
1794         }
1795         else if (wc1 < 0xE000)
1796         {
1797             return codecvt_base::error;
1798         }
1799         else
1800         {
1801             if (to_end-to_nxt < 3)
1802                 return codecvt_base::partial;
1803             *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
1804             *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
1805             *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
1806         }
1807     }
1808     return codecvt_base::ok;
1809 }
1810
1811 static
1812 codecvt_base::result
1813 utf16_to_utf8(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
1814               uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
1815               unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
1816 {
1817     frm_nxt = frm;
1818     to_nxt = to;
1819     if (mode & generate_header)
1820     {
1821         if (to_end-to_nxt < 3)
1822             return codecvt_base::partial;
1823         *to_nxt++ = static_cast<uint8_t>(0xEF);
1824         *to_nxt++ = static_cast<uint8_t>(0xBB);
1825         *to_nxt++ = static_cast<uint8_t>(0xBF);
1826     }
1827     for (; frm_nxt < frm_end; ++frm_nxt)
1828     {
1829         uint16_t wc1 = static_cast<uint16_t>(*frm_nxt);
1830         if (wc1 > Maxcode)
1831             return codecvt_base::error;
1832         if (wc1 < 0x0080)
1833         {
1834             if (to_end-to_nxt < 1)
1835                 return codecvt_base::partial;
1836             *to_nxt++ = static_cast<uint8_t>(wc1);
1837         }
1838         else if (wc1 < 0x0800)
1839         {
1840             if (to_end-to_nxt < 2)
1841                 return codecvt_base::partial;
1842             *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
1843             *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
1844         }
1845         else if (wc1 < 0xD800)
1846         {
1847             if (to_end-to_nxt < 3)
1848                 return codecvt_base::partial;
1849             *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
1850             *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
1851             *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
1852         }
1853         else if (wc1 < 0xDC00)
1854         {
1855             if (frm_end-frm_nxt < 2)
1856                 return codecvt_base::partial;
1857             uint16_t wc2 = static_cast<uint16_t>(frm_nxt[1]);
1858             if ((wc2 & 0xFC00) != 0xDC00)
1859                 return codecvt_base::error;
1860             if (to_end-to_nxt < 4)
1861                 return codecvt_base::partial;
1862             if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) +
1863                 ((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
1864                 return codecvt_base::error;
1865             ++frm_nxt;
1866             uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
1867             *to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
1868             *to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4)     | ((wc1 & 0x003C) >> 2));
1869             *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
1870             *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc2 & 0x003F));
1871         }
1872         else if (wc1 < 0xE000)
1873         {
1874             return codecvt_base::error;
1875         }
1876         else
1877         {
1878             if (to_end-to_nxt < 3)
1879                 return codecvt_base::partial;
1880             *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
1881             *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
1882             *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
1883         }
1884     }
1885     return codecvt_base::ok;
1886 }
1887
1888 static
1889 codecvt_base::result
1890 utf8_to_utf16(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
1891               uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
1892               unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
1893 {
1894     frm_nxt = frm;
1895     to_nxt = to;
1896     if (mode & consume_header)
1897     {
1898         if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
1899                                                           frm_nxt[2] == 0xBF)
1900             frm_nxt += 3;
1901     }
1902     for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
1903     {
1904         uint8_t c1 = *frm_nxt;
1905         if (c1 > Maxcode)
1906             return codecvt_base::error;
1907         if (c1 < 0x80)
1908         {
1909             *to_nxt = static_cast<uint16_t>(c1);
1910             ++frm_nxt;
1911         }
1912         else if (c1 < 0xC2)
1913         {
1914             return codecvt_base::error;
1915         }
1916         else if (c1 < 0xE0)
1917         {
1918             if (frm_end-frm_nxt < 2)
1919                 return codecvt_base::partial;
1920             uint8_t c2 = frm_nxt[1];
1921             if ((c2 & 0xC0) != 0x80)
1922                 return codecvt_base::error;
1923             uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
1924             if (t > Maxcode)
1925                 return codecvt_base::error;
1926             *to_nxt = t;
1927             frm_nxt += 2;
1928         }
1929         else if (c1 < 0xF0)
1930         {
1931             if (frm_end-frm_nxt < 3)
1932                 return codecvt_base::partial;
1933             uint8_t c2 = frm_nxt[1];
1934             uint8_t c3 = frm_nxt[2];
1935             switch (c1)
1936             {
1937             case 0xE0:
1938                 if ((c2 & 0xE0) != 0xA0)
1939                     return codecvt_base::error;
1940                  break;
1941             case 0xED:
1942                 if ((c2 & 0xE0) != 0x80)
1943                     return codecvt_base::error;
1944                  break;
1945             default:
1946                 if ((c2 & 0xC0) != 0x80)
1947                     return codecvt_base::error;
1948                  break;
1949             }
1950             if ((c3 & 0xC0) != 0x80)
1951                 return codecvt_base::error;
1952             uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
1953                                              | ((c2 & 0x3F) << 6)
1954                                              |  (c3 & 0x3F));
1955             if (t > Maxcode)
1956                 return codecvt_base::error;
1957             *to_nxt = t;
1958             frm_nxt += 3;
1959         }
1960         else if (c1 < 0xF5)
1961         {
1962             if (frm_end-frm_nxt < 4)
1963                 return codecvt_base::partial;
1964             uint8_t c2 = frm_nxt[1];
1965             uint8_t c3 = frm_nxt[2];
1966             uint8_t c4 = frm_nxt[3];
1967             switch (c1)
1968             {
1969             case 0xF0:
1970                 if (!(0x90 <= c2 && c2 <= 0xBF))
1971                     return codecvt_base::error;
1972                  break;
1973             case 0xF4:
1974                 if ((c2 & 0xF0) != 0x80)
1975                     return codecvt_base::error;
1976                  break;
1977             default:
1978                 if ((c2 & 0xC0) != 0x80)
1979                     return codecvt_base::error;
1980                  break;
1981             }
1982             if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
1983                 return codecvt_base::error;
1984             if (to_end-to_nxt < 2)
1985                 return codecvt_base::partial;
1986             if ((((c1 & 7UL) << 18) +
1987                 ((c2 & 0x3FUL) << 12) +
1988                 ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
1989                 return codecvt_base::error;
1990             *to_nxt = static_cast<uint16_t>(
1991                     0xD800
1992                   | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6)
1993                   | ((c2 & 0x0F) << 2)
1994                   | ((c3 & 0x30) >> 4));
1995             *++to_nxt = static_cast<uint16_t>(
1996                     0xDC00
1997                   | ((c3 & 0x0F) << 6)
1998                   |  (c4 & 0x3F));
1999             frm_nxt += 4;
2000         }
2001         else
2002         {
2003             return codecvt_base::error;
2004         }
2005     }
2006     return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2007 }
2008
2009 static
2010 codecvt_base::result
2011 utf8_to_utf16(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
2012               uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
2013               unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2014 {
2015     frm_nxt = frm;
2016     to_nxt = to;
2017     if (mode & consume_header)
2018     {
2019         if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
2020                                                           frm_nxt[2] == 0xBF)
2021             frm_nxt += 3;
2022     }
2023     for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
2024     {
2025         uint8_t c1 = *frm_nxt;
2026         if (c1 > Maxcode)
2027             return codecvt_base::error;
2028         if (c1 < 0x80)
2029         {
2030             *to_nxt = static_cast<uint32_t>(c1);
2031             ++frm_nxt;
2032         }
2033         else if (c1 < 0xC2)
2034         {
2035             return codecvt_base::error;
2036         }
2037         else if (c1 < 0xE0)
2038         {
2039             if (frm_end-frm_nxt < 2)
2040                 return codecvt_base::partial;
2041             uint8_t c2 = frm_nxt[1];
2042             if ((c2 & 0xC0) != 0x80)
2043                 return codecvt_base::error;
2044             uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
2045             if (t > Maxcode)
2046                 return codecvt_base::error;
2047             *to_nxt = static_cast<uint32_t>(t);
2048             frm_nxt += 2;
2049         }
2050         else if (c1 < 0xF0)
2051         {
2052             if (frm_end-frm_nxt < 3)
2053                 return codecvt_base::partial;
2054             uint8_t c2 = frm_nxt[1];
2055             uint8_t c3 = frm_nxt[2];
2056             switch (c1)
2057             {
2058             case 0xE0:
2059                 if ((c2 & 0xE0) != 0xA0)
2060                     return codecvt_base::error;
2061                  break;
2062             case 0xED:
2063                 if ((c2 & 0xE0) != 0x80)
2064                     return codecvt_base::error;
2065                  break;
2066             default:
2067                 if ((c2 & 0xC0) != 0x80)
2068                     return codecvt_base::error;
2069                  break;
2070             }
2071             if ((c3 & 0xC0) != 0x80)
2072                 return codecvt_base::error;
2073             uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
2074                                              | ((c2 & 0x3F) << 6)
2075                                              |  (c3 & 0x3F));
2076             if (t > Maxcode)
2077                 return codecvt_base::error;
2078             *to_nxt = static_cast<uint32_t>(t);
2079             frm_nxt += 3;
2080         }
2081         else if (c1 < 0xF5)
2082         {
2083             if (frm_end-frm_nxt < 4)
2084                 return codecvt_base::partial;
2085             uint8_t c2 = frm_nxt[1];
2086             uint8_t c3 = frm_nxt[2];
2087             uint8_t c4 = frm_nxt[3];
2088             switch (c1)
2089             {
2090             case 0xF0:
2091                 if (!(0x90 <= c2 && c2 <= 0xBF))
2092                     return codecvt_base::error;
2093                  break;
2094             case 0xF4:
2095                 if ((c2 & 0xF0) != 0x80)
2096                     return codecvt_base::error;
2097                  break;
2098             default:
2099                 if ((c2 & 0xC0) != 0x80)
2100                     return codecvt_base::error;
2101                  break;
2102             }
2103             if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
2104                 return codecvt_base::error;
2105             if (to_end-to_nxt < 2)
2106                 return codecvt_base::partial;
2107             if ((((c1 & 7UL) << 18) +
2108                 ((c2 & 0x3FUL) << 12) +
2109                 ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
2110                 return codecvt_base::error;
2111             *to_nxt = static_cast<uint32_t>(
2112                     0xD800
2113                   | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6)
2114                   | ((c2 & 0x0F) << 2)
2115                   | ((c3 & 0x30) >> 4));
2116             *++to_nxt = static_cast<uint32_t>(
2117                     0xDC00
2118                   | ((c3 & 0x0F) << 6)
2119                   |  (c4 & 0x3F));
2120             frm_nxt += 4;
2121         }
2122         else
2123         {
2124             return codecvt_base::error;
2125         }
2126     }
2127     return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2128 }
2129
2130 static
2131 int
2132 utf8_to_utf16_length(const uint8_t* frm, const uint8_t* frm_end,
2133                      size_t mx, unsigned long Maxcode = 0x10FFFF,
2134                      codecvt_mode mode = codecvt_mode(0))
2135 {
2136     const uint8_t* frm_nxt = frm;
2137     if (mode & consume_header)
2138     {
2139         if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
2140                                                           frm_nxt[2] == 0xBF)
2141             frm_nxt += 3;
2142     }
2143     for (size_t nchar16_t = 0; frm_nxt < frm_end && nchar16_t < mx; ++nchar16_t)
2144     {
2145         uint8_t c1 = *frm_nxt;
2146         if (c1 > Maxcode)
2147             break;
2148         if (c1 < 0x80)
2149         {
2150             ++frm_nxt;
2151         }
2152         else if (c1 < 0xC2)
2153         {
2154             break;
2155         }
2156         else if (c1 < 0xE0)
2157         {
2158             if ((frm_end-frm_nxt < 2) || (frm_nxt[1] & 0xC0) != 0x80)
2159                 break;
2160             uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (frm_nxt[1] & 0x3F));
2161             if (t > Maxcode)
2162                 break;
2163             frm_nxt += 2;
2164         }
2165         else if (c1 < 0xF0)
2166         {
2167             if (frm_end-frm_nxt < 3)
2168                 break;
2169             uint8_t c2 = frm_nxt[1];
2170             uint8_t c3 = frm_nxt[2];
2171             switch (c1)
2172             {
2173             case 0xE0:
2174                 if ((c2 & 0xE0) != 0xA0)
2175                     return static_cast<int>(frm_nxt - frm);
2176                 break;
2177             case 0xED:
2178                 if ((c2 & 0xE0) != 0x80)
2179                     return static_cast<int>(frm_nxt - frm);
2180                  break;
2181             default:
2182                 if ((c2 & 0xC0) != 0x80)
2183                     return static_cast<int>(frm_nxt - frm);
2184                  break;
2185             }
2186             if ((c3 & 0xC0) != 0x80)
2187                 break;
2188             if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
2189                 break;
2190             frm_nxt += 3;
2191         }
2192         else if (c1 < 0xF5)
2193         {
2194             if (frm_end-frm_nxt < 4 || mx-nchar16_t < 2)
2195                 break;
2196             uint8_t c2 = frm_nxt[1];
2197             uint8_t c3 = frm_nxt[2];
2198             uint8_t c4 = frm_nxt[3];
2199             switch (c1)
2200             {
2201             case 0xF0:
2202                 if (!(0x90 <= c2 && c2 <= 0xBF))
2203                     return static_cast<int>(frm_nxt - frm);
2204                  break;
2205             case 0xF4:
2206                 if ((c2 & 0xF0) != 0x80)
2207                     return static_cast<int>(frm_nxt - frm);
2208                  break;
2209             default:
2210                 if ((c2 & 0xC0) != 0x80)
2211                     return static_cast<int>(frm_nxt - frm);
2212                  break;
2213             }
2214             if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
2215                 break;
2216             if ((((c1 & 7UL) << 18) +
2217                 ((c2 & 0x3FUL) << 12) +
2218                 ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
2219                 break;
2220             ++nchar16_t;
2221             frm_nxt += 4;
2222         }
2223         else
2224         {
2225             break;
2226         }
2227     }
2228     return static_cast<int>(frm_nxt - frm);
2229 }
2230
2231 static
2232 codecvt_base::result
2233 ucs4_to_utf8(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
2234              uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
2235              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2236 {
2237     frm_nxt = frm;
2238     to_nxt = to;
2239     if (mode & generate_header)
2240     {
2241         if (to_end-to_nxt < 3)
2242             return codecvt_base::partial;
2243         *to_nxt++ = static_cast<uint8_t>(0xEF);
2244         *to_nxt++ = static_cast<uint8_t>(0xBB);
2245         *to_nxt++ = static_cast<uint8_t>(0xBF);
2246     }
2247     for (; frm_nxt < frm_end; ++frm_nxt)
2248     {
2249         uint32_t wc = *frm_nxt;
2250         if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
2251             return codecvt_base::error;
2252         if (wc < 0x000080)
2253         {
2254             if (to_end-to_nxt < 1)
2255                 return codecvt_base::partial;
2256             *to_nxt++ = static_cast<uint8_t>(wc);
2257         }
2258         else if (wc < 0x000800)
2259         {
2260             if (to_end-to_nxt < 2)
2261                 return codecvt_base::partial;
2262             *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
2263             *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
2264         }
2265         else if (wc < 0x010000)
2266         {
2267             if (to_end-to_nxt < 3)
2268                 return codecvt_base::partial;
2269             *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc >> 12));
2270             *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x0FC0) >> 6));
2271             *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc & 0x003F));
2272         }
2273         else // if (wc < 0x110000)
2274         {
2275             if (to_end-to_nxt < 4)
2276                 return codecvt_base::partial;
2277             *to_nxt++ = static_cast<uint8_t>(0xF0 |  (wc >> 18));
2278             *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x03F000) >> 12));
2279             *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x000FC0) >> 6));
2280             *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc & 0x00003F));
2281         }
2282     }
2283     return codecvt_base::ok;
2284 }
2285
2286 static
2287 codecvt_base::result
2288 utf8_to_ucs4(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
2289              uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
2290              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2291 {
2292     frm_nxt = frm;
2293     to_nxt = to;
2294     if (mode & consume_header)
2295     {
2296         if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
2297                                                           frm_nxt[2] == 0xBF)
2298             frm_nxt += 3;
2299     }
2300     for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
2301     {
2302         uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
2303         if (c1 < 0x80)
2304         {
2305             if (c1 > Maxcode)
2306                 return codecvt_base::error;
2307             *to_nxt = static_cast<uint32_t>(c1);
2308             ++frm_nxt;
2309         }
2310         else if (c1 < 0xC2)
2311         {
2312             return codecvt_base::error;
2313         }
2314         else if (c1 < 0xE0)
2315         {
2316             if (frm_end-frm_nxt < 2)
2317                 return codecvt_base::partial;
2318             uint8_t c2 = frm_nxt[1];
2319             if ((c2 & 0xC0) != 0x80)
2320                 return codecvt_base::error;
2321             uint32_t t = static_cast<uint32_t>(((c1 & 0x1F) << 6)
2322                                               | (c2 & 0x3F));
2323             if (t > Maxcode)
2324                 return codecvt_base::error;
2325             *to_nxt = t;
2326             frm_nxt += 2;
2327         }
2328         else if (c1 < 0xF0)
2329         {
2330             if (frm_end-frm_nxt < 3)
2331                 return codecvt_base::partial;
2332             uint8_t c2 = frm_nxt[1];
2333             uint8_t c3 = frm_nxt[2];
2334             switch (c1)
2335             {
2336             case 0xE0:
2337                 if ((c2 & 0xE0) != 0xA0)
2338                     return codecvt_base::error;
2339                  break;
2340             case 0xED:
2341                 if ((c2 & 0xE0) != 0x80)
2342                     return codecvt_base::error;
2343                  break;
2344             default:
2345                 if ((c2 & 0xC0) != 0x80)
2346                     return codecvt_base::error;
2347                  break;
2348             }
2349             if ((c3 & 0xC0) != 0x80)
2350                 return codecvt_base::error;
2351             uint32_t t = static_cast<uint32_t>(((c1 & 0x0F) << 12)
2352                                              | ((c2 & 0x3F) << 6)
2353                                              |  (c3 & 0x3F));
2354             if (t > Maxcode)
2355                 return codecvt_base::error;
2356             *to_nxt = t;
2357             frm_nxt += 3;
2358         }
2359         else if (c1 < 0xF5)
2360         {
2361             if (frm_end-frm_nxt < 4)
2362                 return codecvt_base::partial;
2363             uint8_t c2 = frm_nxt[1];
2364             uint8_t c3 = frm_nxt[2];
2365             uint8_t c4 = frm_nxt[3];
2366             switch (c1)
2367             {
2368             case 0xF0:
2369                 if (!(0x90 <= c2 && c2 <= 0xBF))
2370                     return codecvt_base::error;
2371                  break;
2372             case 0xF4:
2373                 if ((c2 & 0xF0) != 0x80)
2374                     return codecvt_base::error;
2375                  break;
2376             default:
2377                 if ((c2 & 0xC0) != 0x80)
2378                     return codecvt_base::error;
2379                  break;
2380             }
2381             if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
2382                 return codecvt_base::error;
2383             uint32_t t = static_cast<uint32_t>(((c1 & 0x07) << 18)
2384                                              | ((c2 & 0x3F) << 12)
2385                                              | ((c3 & 0x3F) << 6)
2386                                              |  (c4 & 0x3F));
2387             if (t > Maxcode)
2388                 return codecvt_base::error;
2389             *to_nxt = t;
2390             frm_nxt += 4;
2391         }
2392         else
2393         {
2394             return codecvt_base::error;
2395         }
2396     }
2397     return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2398 }
2399
2400 static
2401 int
2402 utf8_to_ucs4_length(const uint8_t* frm, const uint8_t* frm_end,
2403                     size_t mx, unsigned long Maxcode = 0x10FFFF,
2404                     codecvt_mode mode = codecvt_mode(0))
2405 {
2406     const uint8_t* frm_nxt = frm;
2407     if (mode & consume_header)
2408     {
2409         if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
2410                                                           frm_nxt[2] == 0xBF)
2411             frm_nxt += 3;
2412     }
2413     for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t)
2414     {
2415         uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
2416         if (c1 < 0x80)
2417         {
2418             if (c1 > Maxcode)
2419                 break;
2420             ++frm_nxt;
2421         }
2422         else if (c1 < 0xC2)
2423         {
2424             break;
2425         }
2426         else if (c1 < 0xE0)
2427         {
2428             if ((frm_end-frm_nxt < 2) || ((frm_nxt[1] & 0xC0) != 0x80))
2429                 break;
2430             if ((((c1 & 0x1Fu) << 6) | (frm_nxt[1] & 0x3Fu)) > Maxcode)
2431                 break;
2432             frm_nxt += 2;
2433         }
2434         else if (c1 < 0xF0)
2435         {
2436             if (frm_end-frm_nxt < 3)
2437                 break;
2438             uint8_t c2 = frm_nxt[1];
2439             uint8_t c3 = frm_nxt[2];
2440             switch (c1)
2441             {
2442             case 0xE0:
2443                 if ((c2 & 0xE0) != 0xA0)
2444                     return static_cast<int>(frm_nxt - frm);
2445                 break;
2446             case 0xED:
2447                 if ((c2 & 0xE0) != 0x80)
2448                     return static_cast<int>(frm_nxt - frm);
2449                  break;
2450             default:
2451                 if ((c2 & 0xC0) != 0x80)
2452                     return static_cast<int>(frm_nxt - frm);
2453                  break;
2454             }
2455             if ((c3 & 0xC0) != 0x80)
2456                 break;
2457             if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
2458                 break;
2459             frm_nxt += 3;
2460         }
2461         else if (c1 < 0xF5)
2462         {
2463             if (frm_end-frm_nxt < 4)
2464                 break;
2465             uint8_t c2 = frm_nxt[1];
2466             uint8_t c3 = frm_nxt[2];
2467             uint8_t c4 = frm_nxt[3];
2468             switch (c1)
2469             {
2470             case 0xF0:
2471                 if (!(0x90 <= c2 && c2 <= 0xBF))
2472                     return static_cast<int>(frm_nxt - frm);
2473                  break;
2474             case 0xF4:
2475                 if ((c2 & 0xF0) != 0x80)
2476                     return static_cast<int>(frm_nxt - frm);
2477                  break;
2478             default:
2479                 if ((c2 & 0xC0) != 0x80)
2480                     return static_cast<int>(frm_nxt - frm);
2481                  break;
2482             }
2483             if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
2484                 break;
2485             if ((((c1 & 0x07u) << 18) | ((c2 & 0x3Fu) << 12) |
2486                  ((c3 & 0x3Fu) << 6)  |  (c4 & 0x3Fu)) > Maxcode)
2487                 break;
2488             frm_nxt += 4;
2489         }
2490         else
2491         {
2492             break;
2493         }
2494     }
2495     return static_cast<int>(frm_nxt - frm);
2496 }
2497
2498 static
2499 codecvt_base::result
2500 ucs2_to_utf8(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
2501              uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
2502              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2503 {
2504     frm_nxt = frm;
2505     to_nxt = to;
2506     if (mode & generate_header)
2507     {
2508         if (to_end-to_nxt < 3)
2509             return codecvt_base::partial;
2510         *to_nxt++ = static_cast<uint8_t>(0xEF);
2511         *to_nxt++ = static_cast<uint8_t>(0xBB);
2512         *to_nxt++ = static_cast<uint8_t>(0xBF);
2513     }
2514     for (; frm_nxt < frm_end; ++frm_nxt)
2515     {
2516         uint16_t wc = *frm_nxt;
2517         if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
2518             return codecvt_base::error;
2519         if (wc < 0x0080)
2520         {
2521             if (to_end-to_nxt < 1)
2522                 return codecvt_base::partial;
2523             *to_nxt++ = static_cast<uint8_t>(wc);
2524         }
2525         else if (wc < 0x0800)
2526         {
2527             if (to_end-to_nxt < 2)
2528                 return codecvt_base::partial;
2529             *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
2530             *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
2531         }
2532         else // if (wc <= 0xFFFF)
2533         {
2534             if (to_end-to_nxt < 3)
2535                 return codecvt_base::partial;
2536             *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc >> 12));
2537             *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x0FC0) >> 6));
2538             *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc & 0x003F));
2539         }
2540     }
2541     return codecvt_base::ok;
2542 }
2543
2544 static
2545 codecvt_base::result
2546 utf8_to_ucs2(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
2547              uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
2548              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2549 {
2550     frm_nxt = frm;
2551     to_nxt = to;
2552     if (mode & consume_header)
2553     {
2554         if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
2555                                                           frm_nxt[2] == 0xBF)
2556             frm_nxt += 3;
2557     }
2558     for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
2559     {
2560         uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
2561         if (c1 < 0x80)
2562         {
2563             if (c1 > Maxcode)
2564                 return codecvt_base::error;
2565             *to_nxt = static_cast<uint16_t>(c1);
2566             ++frm_nxt;
2567         }
2568         else if (c1 < 0xC2)
2569         {
2570             return codecvt_base::error;
2571         }
2572         else if (c1 < 0xE0)
2573         {
2574             if (frm_end-frm_nxt < 2)
2575                 return codecvt_base::partial;
2576             uint8_t c2 = frm_nxt[1];
2577             if ((c2 & 0xC0) != 0x80)
2578                 return codecvt_base::error;
2579             uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6)
2580                                               | (c2 & 0x3F));
2581             if (t > Maxcode)
2582                 return codecvt_base::error;
2583             *to_nxt = t;
2584             frm_nxt += 2;
2585         }
2586         else if (c1 < 0xF0)
2587         {
2588             if (frm_end-frm_nxt < 3)
2589                 return codecvt_base::partial;
2590             uint8_t c2 = frm_nxt[1];
2591             uint8_t c3 = frm_nxt[2];
2592             switch (c1)
2593             {
2594             case 0xE0:
2595                 if ((c2 & 0xE0) != 0xA0)
2596                     return codecvt_base::error;
2597                  break;
2598             case 0xED:
2599                 if ((c2 & 0xE0) != 0x80)
2600                     return codecvt_base::error;
2601                  break;
2602             default:
2603                 if ((c2 & 0xC0) != 0x80)
2604                     return codecvt_base::error;
2605                  break;
2606             }
2607             if ((c3 & 0xC0) != 0x80)
2608                 return codecvt_base::error;
2609             uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
2610                                              | ((c2 & 0x3F) << 6)
2611                                              |  (c3 & 0x3F));
2612             if (t > Maxcode)
2613                 return codecvt_base::error;
2614             *to_nxt = t;
2615             frm_nxt += 3;
2616         }
2617         else
2618         {
2619             return codecvt_base::error;
2620         }
2621     }
2622     return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2623 }
2624
2625 static
2626 int
2627 utf8_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
2628                     size_t mx, unsigned long Maxcode = 0x10FFFF,
2629                     codecvt_mode mode = codecvt_mode(0))
2630 {
2631     const uint8_t* frm_nxt = frm;
2632     if (mode & consume_header)
2633     {
2634         if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
2635                                                           frm_nxt[2] == 0xBF)
2636             frm_nxt += 3;
2637     }
2638     for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t)
2639     {
2640         uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
2641         if (c1 < 0x80)
2642         {
2643             if (c1 > Maxcode)
2644                 break;
2645             ++frm_nxt;
2646         }
2647         else if (c1 < 0xC2)
2648         {
2649             break;
2650         }
2651         else if (c1 < 0xE0)
2652         {
2653             if ((frm_end-frm_nxt < 2) || ((frm_nxt[1] & 0xC0) != 0x80))
2654                 break;
2655             if ((((c1 & 0x1Fu) << 6) | (frm_nxt[1] & 0x3Fu)) > Maxcode)
2656                 break;
2657             frm_nxt += 2;
2658         }
2659         else if (c1 < 0xF0)
2660         {
2661             if (frm_end-frm_nxt < 3)
2662                 break;
2663             uint8_t c2 = frm_nxt[1];
2664             uint8_t c3 = frm_nxt[2];
2665             switch (c1)
2666             {
2667             case 0xE0:
2668                 if ((c2 & 0xE0) != 0xA0)
2669                     return static_cast<int>(frm_nxt - frm);
2670                 break;
2671             case 0xED:
2672                 if ((c2 & 0xE0) != 0x80)
2673                     return static_cast<int>(frm_nxt - frm);
2674                  break;
2675             default:
2676                 if ((c2 & 0xC0) != 0x80)
2677                     return static_cast<int>(frm_nxt - frm);
2678                  break;
2679             }
2680             if ((c3 & 0xC0) != 0x80)
2681                 break;
2682             if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
2683                 break;
2684             frm_nxt += 3;
2685         }
2686         else
2687         {
2688             break;
2689         }
2690     }
2691     return static_cast<int>(frm_nxt - frm);
2692 }
2693
2694 static
2695 codecvt_base::result
2696 ucs4_to_utf16be(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
2697                 uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
2698                 unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2699 {
2700     frm_nxt = frm;
2701     to_nxt = to;
2702     if (mode & generate_header)
2703     {
2704         if (to_end-to_nxt < 2)
2705             return codecvt_base::partial;
2706         *to_nxt++ = static_cast<uint8_t>(0xFE);
2707         *to_nxt++ = static_cast<uint8_t>(0xFF);
2708     }
2709     for (; frm_nxt < frm_end; ++frm_nxt)
2710     {
2711         uint32_t wc = *frm_nxt;
2712         if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
2713             return codecvt_base::error;
2714         if (wc < 0x010000)
2715         {
2716             if (to_end-to_nxt < 2)
2717                 return codecvt_base::partial;
2718             *to_nxt++ = static_cast<uint8_t>(wc >> 8);
2719             *to_nxt++ = static_cast<uint8_t>(wc);
2720         }
2721         else
2722         {
2723             if (to_end-to_nxt < 4)
2724                 return codecvt_base::partial;
2725             uint16_t t = static_cast<uint16_t>(
2726                     0xD800
2727                   | ((((wc & 0x1F0000) >> 16) - 1) << 6)
2728                   |   ((wc & 0x00FC00) >> 10));
2729             *to_nxt++ = static_cast<uint8_t>(t >> 8);
2730             *to_nxt++ = static_cast<uint8_t>(t);
2731             t = static_cast<uint16_t>(0xDC00 | (wc & 0x03FF));
2732             *to_nxt++ = static_cast<uint8_t>(t >> 8);
2733             *to_nxt++ = static_cast<uint8_t>(t);
2734         }
2735     }
2736     return codecvt_base::ok;
2737 }
2738
2739 static
2740 codecvt_base::result
2741 utf16be_to_ucs4(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
2742                 uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
2743                 unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2744 {
2745     frm_nxt = frm;
2746     to_nxt = to;
2747     if (mode & consume_header)
2748     {
2749         if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
2750             frm_nxt += 2;
2751     }
2752     for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
2753     {
2754         uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
2755         if ((c1 & 0xFC00) == 0xDC00)
2756             return codecvt_base::error;
2757         if ((c1 & 0xFC00) != 0xD800)
2758         {
2759             if (c1 > Maxcode)
2760                 return codecvt_base::error;
2761             *to_nxt = static_cast<uint32_t>(c1);
2762             frm_nxt += 2;
2763         }
2764         else
2765         {
2766             if (frm_end-frm_nxt < 4)
2767                 return codecvt_base::partial;
2768             uint16_t c2 = static_cast<uint16_t>(frm_nxt[2] << 8 | frm_nxt[3]);
2769             if ((c2 & 0xFC00) != 0xDC00)
2770                 return codecvt_base::error;
2771             uint32_t t = static_cast<uint32_t>(
2772                     ((((c1 & 0x03C0) >> 6) + 1) << 16)
2773                   |   ((c1 & 0x003F) << 10)
2774                   |    (c2 & 0x03FF));
2775             if (t > Maxcode)
2776                 return codecvt_base::error;
2777             *to_nxt = t;
2778             frm_nxt += 4;
2779         }
2780     }
2781     return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2782 }
2783
2784 static
2785 int
2786 utf16be_to_ucs4_length(const uint8_t* frm, const uint8_t* frm_end,
2787                        size_t mx, unsigned long Maxcode = 0x10FFFF,
2788                        codecvt_mode mode = codecvt_mode(0))
2789 {
2790     const uint8_t* frm_nxt = frm;
2791     if (mode & consume_header)
2792     {
2793         if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
2794             frm_nxt += 2;
2795     }
2796     for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t)
2797     {
2798         uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
2799         if ((c1 & 0xFC00) == 0xDC00)
2800             break;
2801         if ((c1 & 0xFC00) != 0xD800)
2802         {
2803             if (c1 > Maxcode)
2804                 break;
2805             frm_nxt += 2;
2806         }
2807         else
2808         {
2809             if (frm_end-frm_nxt < 4)
2810                 break;
2811             uint16_t c2 = static_cast<uint16_t>(frm_nxt[2] << 8 | frm_nxt[3]);
2812             if ((c2 & 0xFC00) != 0xDC00)
2813                 break;
2814             uint32_t t = static_cast<uint32_t>(
2815                     ((((c1 & 0x03C0) >> 6) + 1) << 16)
2816                   |   ((c1 & 0x003F) << 10)
2817                   |    (c2 & 0x03FF));
2818             if (t > Maxcode)
2819                 break;
2820             frm_nxt += 4;
2821         }
2822     }
2823     return static_cast<int>(frm_nxt - frm);
2824 }
2825
2826 static
2827 codecvt_base::result
2828 ucs4_to_utf16le(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
2829                 uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
2830                 unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2831 {
2832     frm_nxt = frm;
2833     to_nxt = to;
2834     if (mode & generate_header)
2835     {
2836         if (to_end - to_nxt < 2)
2837             return codecvt_base::partial;
2838         *to_nxt++ = static_cast<uint8_t>(0xFF);
2839         *to_nxt++ = static_cast<uint8_t>(0xFE);
2840     }
2841     for (; frm_nxt < frm_end; ++frm_nxt)
2842     {
2843         uint32_t wc = *frm_nxt;
2844         if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
2845             return codecvt_base::error;
2846         if (wc < 0x010000)
2847         {
2848             if (to_end-to_nxt < 2)
2849                 return codecvt_base::partial;
2850             *to_nxt++ = static_cast<uint8_t>(wc);
2851             *to_nxt++ = static_cast<uint8_t>(wc >> 8);
2852         }
2853         else
2854         {
2855             if (to_end-to_nxt < 4)
2856                 return codecvt_base::partial;
2857             uint16_t t = static_cast<uint16_t>(
2858                     0xD800
2859                   | ((((wc & 0x1F0000) >> 16) - 1) << 6)
2860                   |   ((wc & 0x00FC00) >> 10));
2861             *to_nxt++ = static_cast<uint8_t>(t);
2862             *to_nxt++ = static_cast<uint8_t>(t >> 8);
2863             t = static_cast<uint16_t>(0xDC00 | (wc & 0x03FF));
2864             *to_nxt++ = static_cast<uint8_t>(t);
2865             *to_nxt++ = static_cast<uint8_t>(t >> 8);
2866         }
2867     }
2868     return codecvt_base::ok;
2869 }
2870
2871 static
2872 codecvt_base::result
2873 utf16le_to_ucs4(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
2874                 uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
2875                 unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2876 {
2877     frm_nxt = frm;
2878     to_nxt = to;
2879     if (mode & consume_header)
2880     {
2881         if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
2882             frm_nxt += 2;
2883     }
2884     for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
2885     {
2886         uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
2887         if ((c1 & 0xFC00) == 0xDC00)
2888             return codecvt_base::error;
2889         if ((c1 & 0xFC00) != 0xD800)
2890         {
2891             if (c1 > Maxcode)
2892                 return codecvt_base::error;
2893             *to_nxt = static_cast<uint32_t>(c1);
2894             frm_nxt += 2;
2895         }
2896         else
2897         {
2898             if (frm_end-frm_nxt < 4)
2899                 return codecvt_base::partial;
2900             uint16_t c2 = static_cast<uint16_t>(frm_nxt[3] << 8 | frm_nxt[2]);
2901             if ((c2 & 0xFC00) != 0xDC00)
2902                 return codecvt_base::error;
2903             uint32_t t = static_cast<uint32_t>(
2904                     ((((c1 & 0x03C0) >> 6) + 1) << 16)
2905                   |   ((c1 & 0x003F) << 10)
2906                   |    (c2 & 0x03FF));
2907             if (t > Maxcode)
2908                 return codecvt_base::error;
2909             *to_nxt = t;
2910             frm_nxt += 4;
2911         }
2912     }
2913     return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2914 }
2915
2916 static
2917 int
2918 utf16le_to_ucs4_length(const uint8_t* frm, const uint8_t* frm_end,
2919                        size_t mx, unsigned long Maxcode = 0x10FFFF,
2920                        codecvt_mode mode = codecvt_mode(0))
2921 {
2922     const uint8_t* frm_nxt = frm;
2923     if (mode & consume_header)
2924     {
2925         if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
2926             frm_nxt += 2;
2927     }
2928     for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t)
2929     {
2930         uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
2931         if ((c1 & 0xFC00) == 0xDC00)
2932             break;
2933         if ((c1 & 0xFC00) != 0xD800)
2934         {
2935             if (c1 > Maxcode)
2936                 break;
2937             frm_nxt += 2;
2938         }
2939         else
2940         {
2941             if (frm_end-frm_nxt < 4)
2942                 break;
2943             uint16_t c2 = static_cast<uint16_t>(frm_nxt[3] << 8 | frm_nxt[2]);
2944             if ((c2 & 0xFC00) != 0xDC00)
2945                 break;
2946             uint32_t t = static_cast<uint32_t>(
2947                     ((((c1 & 0x03C0) >> 6) + 1) << 16)
2948                   |   ((c1 & 0x003F) << 10)
2949                   |    (c2 & 0x03FF));
2950             if (t > Maxcode)
2951                 break;
2952             frm_nxt += 4;
2953         }
2954     }
2955     return static_cast<int>(frm_nxt - frm);
2956 }
2957
2958 static
2959 codecvt_base::result
2960 ucs2_to_utf16be(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
2961                 uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
2962                 unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2963 {
2964     frm_nxt = frm;
2965     to_nxt = to;
2966     if (mode & generate_header)
2967     {
2968         if (to_end-to_nxt < 2)
2969             return codecvt_base::partial;
2970         *to_nxt++ = static_cast<uint8_t>(0xFE);
2971         *to_nxt++ = static_cast<uint8_t>(0xFF);
2972     }
2973     for (; frm_nxt < frm_end; ++frm_nxt)
2974     {
2975         uint16_t wc = *frm_nxt;
2976         if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
2977             return codecvt_base::error;
2978         if (to_end-to_nxt < 2)
2979             return codecvt_base::partial;
2980         *to_nxt++ = static_cast<uint8_t>(wc >> 8);
2981         *to_nxt++ = static_cast<uint8_t>(wc);
2982     }
2983     return codecvt_base::ok;
2984 }
2985
2986 static
2987 codecvt_base::result
2988 utf16be_to_ucs2(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
2989                 uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
2990                 unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2991 {
2992     frm_nxt = frm;
2993     to_nxt = to;
2994     if (mode & consume_header)
2995     {
2996         if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
2997             frm_nxt += 2;
2998     }
2999     for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
3000     {
3001         uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
3002         if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
3003             return codecvt_base::error;
3004         *to_nxt = c1;
3005         frm_nxt += 2;
3006     }
3007     return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
3008 }
3009
3010 static
3011 int
3012 utf16be_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
3013                        size_t mx, unsigned long Maxcode = 0x10FFFF,
3014                        codecvt_mode mode = codecvt_mode(0))
3015 {
3016     const uint8_t* frm_nxt = frm;
3017     if (mode & consume_header)
3018     {
3019         if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
3020             frm_nxt += 2;
3021     }
3022     for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t)
3023     {
3024         uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
3025         if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
3026             break;
3027         frm_nxt += 2;
3028     }
3029     return static_cast<int>(frm_nxt - frm);
3030 }
3031
3032 static
3033 codecvt_base::result
3034 ucs2_to_utf16le(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
3035                 uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
3036                 unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
3037 {
3038     frm_nxt = frm;
3039     to_nxt = to;
3040     if (mode & generate_header)
3041     {
3042         if (to_end-to_nxt < 2)
3043             return codecvt_base::partial;
3044         *to_nxt++ = static_cast<uint8_t>(0xFF);
3045         *to_nxt++ = static_cast<uint8_t>(0xFE);
3046     }
3047     for (; frm_nxt < frm_end; ++frm_nxt)
3048     {
3049         uint16_t wc = *frm_nxt;
3050         if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
3051             return codecvt_base::error;
3052         if (to_end-to_nxt < 2)
3053             return codecvt_base::partial;
3054         *to_nxt++ = static_cast<uint8_t>(wc);
3055         *to_nxt++ = static_cast<uint8_t>(wc >> 8);
3056     }
3057     return codecvt_base::ok;
3058 }
3059
3060 static
3061 codecvt_base::result
3062 utf16le_to_ucs2(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
3063                 uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
3064                 unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
3065 {
3066     frm_nxt = frm;
3067     to_nxt = to;
3068     if (mode & consume_header)
3069     {
3070         if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
3071             frm_nxt += 2;
3072     }
3073     for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
3074     {
3075         uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
3076         if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
3077             return codecvt_base::error;
3078         *to_nxt = c1;
3079         frm_nxt += 2;
3080     }
3081     return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
3082 }
3083
3084 static
3085 int
3086 utf16le_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
3087                        size_t mx, unsigned long Maxcode = 0x10FFFF,
3088                        codecvt_mode mode = codecvt_mode(0))
3089 {
3090     const uint8_t* frm_nxt = frm;
3091     frm_nxt = frm;
3092     if (mode & consume_header)
3093     {
3094         if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
3095             frm_nxt += 2;
3096     }
3097     for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t)
3098     {
3099         uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
3100         if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
3101             break;
3102         frm_nxt += 2;
3103     }
3104     return static_cast<int>(frm_nxt - frm);
3105 }
3106
3107 // template <> class codecvt<char16_t, char, mbstate_t>
3108
3109 locale::id codecvt<char16_t, char, mbstate_t>::id;
3110
3111 codecvt<char16_t, char, mbstate_t>::~codecvt()
3112 {
3113 }
3114
3115 codecvt<char16_t, char, mbstate_t>::result
3116 codecvt<char16_t, char, mbstate_t>::do_out(state_type&,
3117     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3118     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3119 {
3120     const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
3121     const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3122     const uint16_t* _frm_nxt = _frm;
3123     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3124     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3125     uint8_t* _to_nxt = _to;
3126     result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
3127     frm_nxt = frm + (_frm_nxt - _frm);
3128     to_nxt = to + (_to_nxt - _to);
3129     return r;
3130 }
3131
3132 codecvt<char16_t, char, mbstate_t>::result
3133 codecvt<char16_t, char, mbstate_t>::do_in(state_type&,
3134     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3135     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3136 {
3137     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3138     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3139     const uint8_t* _frm_nxt = _frm;
3140     uint16_t* _to = reinterpret_cast<uint16_t*>(to);
3141     uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3142     uint16_t* _to_nxt = _to;
3143     result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
3144     frm_nxt = frm + (_frm_nxt - _frm);
3145     to_nxt = to + (_to_nxt - _to);
3146     return r;
3147 }
3148
3149 codecvt<char16_t, char, mbstate_t>::result
3150 codecvt<char16_t, char, mbstate_t>::do_unshift(state_type&,
3151     extern_type* to, extern_type*, extern_type*& to_nxt) const
3152 {
3153     to_nxt = to;
3154     return noconv;
3155 }
3156
3157 int
3158 codecvt<char16_t, char, mbstate_t>::do_encoding() const  _NOEXCEPT
3159 {
3160     return 0;
3161 }
3162
3163 bool
3164 codecvt<char16_t, char, mbstate_t>::do_always_noconv() const  _NOEXCEPT
3165 {
3166     return false;
3167 }
3168
3169 int
3170 codecvt<char16_t, char, mbstate_t>::do_length(state_type&,
3171     const extern_type* frm, const extern_type* frm_end, size_t mx) const
3172 {
3173     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3174     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3175     return utf8_to_utf16_length(_frm, _frm_end, mx);
3176 }
3177
3178 int
3179 codecvt<char16_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
3180 {
3181     return 4;
3182 }
3183
3184 // template <> class codecvt<char32_t, char, mbstate_t>
3185
3186 locale::id codecvt<char32_t, char, mbstate_t>::id;
3187
3188 codecvt<char32_t, char, mbstate_t>::~codecvt()
3189 {
3190 }
3191
3192 codecvt<char32_t, char, mbstate_t>::result
3193 codecvt<char32_t, char, mbstate_t>::do_out(state_type&,
3194     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3195     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3196 {
3197     const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3198     const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3199     const uint32_t* _frm_nxt = _frm;
3200     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3201     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3202     uint8_t* _to_nxt = _to;
3203     result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
3204     frm_nxt = frm + (_frm_nxt - _frm);
3205     to_nxt = to + (_to_nxt - _to);
3206     return r;
3207 }
3208
3209 codecvt<char32_t, char, mbstate_t>::result
3210 codecvt<char32_t, char, mbstate_t>::do_in(state_type&,
3211     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3212     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3213 {
3214     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3215     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3216     const uint8_t* _frm_nxt = _frm;
3217     uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3218     uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3219     uint32_t* _to_nxt = _to;
3220     result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
3221     frm_nxt = frm + (_frm_nxt - _frm);
3222     to_nxt = to + (_to_nxt - _to);
3223     return r;
3224 }
3225
3226 codecvt<char32_t, char, mbstate_t>::result
3227 codecvt<char32_t, char, mbstate_t>::do_unshift(state_type&,
3228     extern_type* to, extern_type*, extern_type*& to_nxt) const
3229 {
3230     to_nxt = to;
3231     return noconv;
3232 }
3233
3234 int
3235 codecvt<char32_t, char, mbstate_t>::do_encoding() const  _NOEXCEPT
3236 {
3237     return 0;
3238 }
3239
3240 bool
3241 codecvt<char32_t, char, mbstate_t>::do_always_noconv() const  _NOEXCEPT
3242 {
3243     return false;
3244 }
3245
3246 int
3247 codecvt<char32_t, char, mbstate_t>::do_length(state_type&,
3248     const extern_type* frm, const extern_type* frm_end, size_t mx) const
3249 {
3250     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3251     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3252     return utf8_to_ucs4_length(_frm, _frm_end, mx);
3253 }
3254
3255 int
3256 codecvt<char32_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
3257 {
3258     return 4;
3259 }
3260
3261 // __codecvt_utf8<wchar_t>
3262
3263 __codecvt_utf8<wchar_t>::result
3264 __codecvt_utf8<wchar_t>::do_out(state_type&,
3265     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3266     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3267 {
3268 #if defined(_LIBCPP_SHORT_WCHAR)
3269     const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
3270     const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3271     const uint16_t* _frm_nxt = _frm;
3272 #else
3273     const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3274     const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3275     const uint32_t* _frm_nxt = _frm;
3276 #endif
3277     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3278     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3279     uint8_t* _to_nxt = _to;
3280 #if defined(_LIBCPP_SHORT_WCHAR)
3281     result r = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3282                             _Maxcode_, _Mode_);
3283 #else
3284     result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3285                             _Maxcode_, _Mode_);
3286 #endif
3287     frm_nxt = frm + (_frm_nxt - _frm);
3288     to_nxt = to + (_to_nxt - _to);
3289     return r;
3290 }
3291
3292 __codecvt_utf8<wchar_t>::result
3293 __codecvt_utf8<wchar_t>::do_in(state_type&,
3294     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3295     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3296 {
3297     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3298     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3299     const uint8_t* _frm_nxt = _frm;
3300 #if defined(_LIBCPP_SHORT_WCHAR)
3301     uint16_t* _to = reinterpret_cast<uint16_t*>(to);
3302     uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3303     uint16_t* _to_nxt = _to;
3304     result r = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3305                             _Maxcode_, _Mode_);
3306 #else
3307     uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3308     uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3309     uint32_t* _to_nxt = _to;
3310     result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3311                             _Maxcode_, _Mode_);
3312 #endif
3313     frm_nxt = frm + (_frm_nxt - _frm);
3314     to_nxt = to + (_to_nxt - _to);
3315     return r;
3316 }
3317
3318 __codecvt_utf8<wchar_t>::result
3319 __codecvt_utf8<wchar_t>::do_unshift(state_type&,
3320     extern_type* to, extern_type*, extern_type*& to_nxt) const
3321 {
3322     to_nxt = to;
3323     return noconv;
3324 }
3325
3326 int
3327 __codecvt_utf8<wchar_t>::do_encoding() const  _NOEXCEPT
3328 {
3329     return 0;
3330 }
3331
3332 bool
3333 __codecvt_utf8<wchar_t>::do_always_noconv() const  _NOEXCEPT
3334 {
3335     return false;
3336 }
3337
3338 int
3339 __codecvt_utf8<wchar_t>::do_length(state_type&,
3340     const extern_type* frm, const extern_type* frm_end, size_t mx) const
3341 {
3342     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3343     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3344     return utf8_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3345 }
3346
3347 int
3348 __codecvt_utf8<wchar_t>::do_max_length() const  _NOEXCEPT
3349 {
3350     if (_Mode_ & consume_header)
3351         return 7;
3352     return 4;
3353 }
3354
3355 // __codecvt_utf8<char16_t>
3356
3357 __codecvt_utf8<char16_t>::result
3358 __codecvt_utf8<char16_t>::do_out(state_type&,
3359     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3360     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3361 {
3362     const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
3363     const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3364     const uint16_t* _frm_nxt = _frm;
3365     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3366     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3367     uint8_t* _to_nxt = _to;
3368     result r = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3369                             _Maxcode_, _Mode_);
3370     frm_nxt = frm + (_frm_nxt - _frm);
3371     to_nxt = to + (_to_nxt - _to);
3372     return r;
3373 }
3374
3375 __codecvt_utf8<char16_t>::result
3376 __codecvt_utf8<char16_t>::do_in(state_type&,
3377     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3378     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3379 {
3380     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3381     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3382     const uint8_t* _frm_nxt = _frm;
3383     uint16_t* _to = reinterpret_cast<uint16_t*>(to);
3384     uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3385     uint16_t* _to_nxt = _to;
3386     result r = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3387                             _Maxcode_, _Mode_);
3388     frm_nxt = frm + (_frm_nxt - _frm);
3389     to_nxt = to + (_to_nxt - _to);
3390     return r;
3391 }
3392
3393 __codecvt_utf8<char16_t>::result
3394 __codecvt_utf8<char16_t>::do_unshift(state_type&,
3395     extern_type* to, extern_type*, extern_type*& to_nxt) const
3396 {
3397     to_nxt = to;
3398     return noconv;
3399 }
3400
3401 int
3402 __codecvt_utf8<char16_t>::do_encoding() const  _NOEXCEPT
3403 {
3404     return 0;
3405 }
3406
3407 bool
3408 __codecvt_utf8<char16_t>::do_always_noconv() const  _NOEXCEPT
3409 {
3410     return false;
3411 }
3412
3413 int
3414 __codecvt_utf8<char16_t>::do_length(state_type&,
3415     const extern_type* frm, const extern_type* frm_end, size_t mx) const
3416 {
3417     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3418     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3419     return utf8_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3420 }
3421
3422 int
3423 __codecvt_utf8<char16_t>::do_max_length() const  _NOEXCEPT
3424 {
3425     if (_Mode_ & consume_header)
3426         return 6;
3427     return 3;
3428 }
3429
3430 // __codecvt_utf8<char32_t>
3431
3432 __codecvt_utf8<char32_t>::result
3433 __codecvt_utf8<char32_t>::do_out(state_type&,
3434     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3435     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3436 {
3437     const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3438     const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3439     const uint32_t* _frm_nxt = _frm;
3440     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3441     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3442     uint8_t* _to_nxt = _to;
3443     result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3444                             _Maxcode_, _Mode_);
3445     frm_nxt = frm + (_frm_nxt - _frm);
3446     to_nxt = to + (_to_nxt - _to);
3447     return r;
3448 }
3449
3450 __codecvt_utf8<char32_t>::result
3451 __codecvt_utf8<char32_t>::do_in(state_type&,
3452     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3453     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3454 {
3455     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3456     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3457     const uint8_t* _frm_nxt = _frm;
3458     uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3459     uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3460     uint32_t* _to_nxt = _to;
3461     result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3462                             _Maxcode_, _Mode_);
3463     frm_nxt = frm + (_frm_nxt - _frm);
3464     to_nxt = to + (_to_nxt - _to);
3465     return r;
3466 }
3467
3468 __codecvt_utf8<char32_t>::result
3469 __codecvt_utf8<char32_t>::do_unshift(state_type&,
3470     extern_type* to, extern_type*, extern_type*& to_nxt) const
3471 {
3472     to_nxt = to;
3473     return noconv;
3474 }
3475
3476 int
3477 __codecvt_utf8<char32_t>::do_encoding() const  _NOEXCEPT
3478 {
3479     return 0;
3480 }
3481
3482 bool
3483 __codecvt_utf8<char32_t>::do_always_noconv() const  _NOEXCEPT
3484 {
3485     return false;
3486 }
3487
3488 int
3489 __codecvt_utf8<char32_t>::do_length(state_type&,
3490     const extern_type* frm, const extern_type* frm_end, size_t mx) const
3491 {
3492     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3493     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3494     return utf8_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3495 }
3496
3497 int
3498 __codecvt_utf8<char32_t>::do_max_length() const  _NOEXCEPT
3499 {
3500     if (_Mode_ & consume_header)
3501         return 7;
3502     return 4;
3503 }
3504
3505 // __codecvt_utf16<wchar_t, false>
3506
3507 __codecvt_utf16<wchar_t, false>::result
3508 __codecvt_utf16<wchar_t, false>::do_out(state_type&,
3509     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3510     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3511 {
3512     const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3513     const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3514     const uint32_t* _frm_nxt = _frm;
3515     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3516     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3517     uint8_t* _to_nxt = _to;
3518     result r = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3519                                _Maxcode_, _Mode_);
3520     frm_nxt = frm + (_frm_nxt - _frm);
3521     to_nxt = to + (_to_nxt - _to);
3522     return r;
3523 }
3524
3525 __codecvt_utf16<wchar_t, false>::result
3526 __codecvt_utf16<wchar_t, false>::do_in(state_type&,
3527     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3528     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3529 {
3530     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3531     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3532     const uint8_t* _frm_nxt = _frm;
3533     uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3534     uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3535     uint32_t* _to_nxt = _to;
3536     result r = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3537                                _Maxcode_, _Mode_);
3538     frm_nxt = frm + (_frm_nxt - _frm);
3539     to_nxt = to + (_to_nxt - _to);
3540     return r;
3541 }
3542
3543 __codecvt_utf16<wchar_t, false>::result
3544 __codecvt_utf16<wchar_t, false>::do_unshift(state_type&,
3545     extern_type* to, extern_type*, extern_type*& to_nxt) const
3546 {
3547     to_nxt = to;
3548     return noconv;
3549 }
3550
3551 int
3552 __codecvt_utf16<wchar_t, false>::do_encoding() const  _NOEXCEPT
3553 {
3554     return 0;
3555 }
3556
3557 bool
3558 __codecvt_utf16<wchar_t, false>::do_always_noconv() const  _NOEXCEPT
3559 {
3560     return false;
3561 }
3562
3563 int
3564 __codecvt_utf16<wchar_t, false>::do_length(state_type&,
3565     const extern_type* frm, const extern_type* frm_end, size_t mx) const
3566 {
3567     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3568     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3569     return utf16be_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3570 }
3571
3572 int
3573 __codecvt_utf16<wchar_t, false>::do_max_length() const  _NOEXCEPT
3574 {
3575     if (_Mode_ & consume_header)
3576         return 6;
3577     return 4;
3578 }
3579
3580 // __codecvt_utf16<wchar_t, true>
3581
3582 __codecvt_utf16<wchar_t, true>::result
3583 __codecvt_utf16<wchar_t, true>::do_out(state_type&,
3584     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3585     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3586 {
3587     const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3588     const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3589     const uint32_t* _frm_nxt = _frm;
3590     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3591     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3592     uint8_t* _to_nxt = _to;
3593     result r = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3594                                _Maxcode_, _Mode_);
3595     frm_nxt = frm + (_frm_nxt - _frm);
3596     to_nxt = to + (_to_nxt - _to);
3597     return r;
3598 }
3599
3600 __codecvt_utf16<wchar_t, true>::result
3601 __codecvt_utf16<wchar_t, true>::do_in(state_type&,
3602     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3603     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3604 {
3605     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3606     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3607     const uint8_t* _frm_nxt = _frm;
3608     uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3609     uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3610     uint32_t* _to_nxt = _to;
3611     result r = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3612                                _Maxcode_, _Mode_);
3613     frm_nxt = frm + (_frm_nxt - _frm);
3614     to_nxt = to + (_to_nxt - _to);
3615     return r;
3616 }
3617
3618 __codecvt_utf16<wchar_t, true>::result
3619 __codecvt_utf16<wchar_t, true>::do_unshift(state_type&,
3620     extern_type* to, extern_type*, extern_type*& to_nxt) const
3621 {
3622     to_nxt = to;
3623     return noconv;
3624 }
3625
3626 int
3627 __codecvt_utf16<wchar_t, true>::do_encoding() const  _NOEXCEPT
3628 {
3629     return 0;
3630 }
3631
3632 bool
3633 __codecvt_utf16<wchar_t, true>::do_always_noconv() const  _NOEXCEPT
3634 {
3635     return false;
3636 }
3637
3638 int
3639 __codecvt_utf16<wchar_t, true>::do_length(state_type&,
3640     const extern_type* frm, const extern_type* frm_end, size_t mx) const
3641 {
3642     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3643     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3644     return utf16le_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3645 }
3646
3647 int
3648 __codecvt_utf16<wchar_t, true>::do_max_length() const  _NOEXCEPT
3649 {
3650     if (_Mode_ & consume_header)
3651         return 6;
3652     return 4;
3653 }
3654
3655 // __codecvt_utf16<char16_t, false>
3656
3657 __codecvt_utf16<char16_t, false>::result
3658 __codecvt_utf16<char16_t, false>::do_out(state_type&,
3659     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3660     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3661 {
3662     const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
3663     const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3664     const uint16_t* _frm_nxt = _frm;
3665     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3666     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3667     uint8_t* _to_nxt = _to;
3668     result r = ucs2_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3669                                _Maxcode_, _Mode_);
3670     frm_nxt = frm + (_frm_nxt - _frm);
3671     to_nxt = to + (_to_nxt - _to);
3672     return r;
3673 }
3674
3675 __codecvt_utf16<char16_t, false>::result
3676 __codecvt_utf16<char16_t, false>::do_in(state_type&,
3677     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3678     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3679 {
3680     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3681     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3682     const uint8_t* _frm_nxt = _frm;
3683     uint16_t* _to = reinterpret_cast<uint16_t*>(to);
3684     uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3685     uint16_t* _to_nxt = _to;
3686     result r = utf16be_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3687                                _Maxcode_, _Mode_);
3688     frm_nxt = frm + (_frm_nxt - _frm);
3689     to_nxt = to + (_to_nxt - _to);
3690     return r;
3691 }
3692
3693 __codecvt_utf16<char16_t, false>::result
3694 __codecvt_utf16<char16_t, false>::do_unshift(state_type&,
3695     extern_type* to, extern_type*, extern_type*& to_nxt) const
3696 {
3697     to_nxt = to;
3698     return noconv;
3699 }
3700
3701 int
3702 __codecvt_utf16<char16_t, false>::do_encoding() const  _NOEXCEPT
3703 {
3704     return 0;
3705 }
3706
3707 bool
3708 __codecvt_utf16<char16_t, false>::do_always_noconv() const  _NOEXCEPT
3709 {
3710     return false;
3711 }
3712
3713 int
3714 __codecvt_utf16<char16_t, false>::do_length(state_type&,
3715     const extern_type* frm, const extern_type* frm_end, size_t mx) const
3716 {
3717     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3718     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3719     return utf16be_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3720 }
3721
3722 int
3723 __codecvt_utf16<char16_t, false>::do_max_length() const  _NOEXCEPT
3724 {
3725     if (_Mode_ & consume_header)
3726         return 4;
3727     return 2;
3728 }
3729
3730 // __codecvt_utf16<char16_t, true>
3731
3732 __codecvt_utf16<char16_t, true>::result
3733 __codecvt_utf16<char16_t, true>::do_out(state_type&,
3734     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3735     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3736 {
3737     const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
3738     const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3739     const uint16_t* _frm_nxt = _frm;
3740     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3741     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3742     uint8_t* _to_nxt = _to;
3743     result r = ucs2_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3744                                _Maxcode_, _Mode_);
3745     frm_nxt = frm + (_frm_nxt - _frm);
3746     to_nxt = to + (_to_nxt - _to);
3747     return r;
3748 }
3749
3750 __codecvt_utf16<char16_t, true>::result
3751 __codecvt_utf16<char16_t, true>::do_in(state_type&,
3752     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3753     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3754 {
3755     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3756     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3757     const uint8_t* _frm_nxt = _frm;
3758     uint16_t* _to = reinterpret_cast<uint16_t*>(to);
3759     uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3760     uint16_t* _to_nxt = _to;
3761     result r = utf16le_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3762                                _Maxcode_, _Mode_);
3763     frm_nxt = frm + (_frm_nxt - _frm);
3764     to_nxt = to + (_to_nxt - _to);
3765     return r;
3766 }
3767
3768 __codecvt_utf16<char16_t, true>::result
3769 __codecvt_utf16<char16_t, true>::do_unshift(state_type&,
3770     extern_type* to, extern_type*, extern_type*& to_nxt) const
3771 {
3772     to_nxt = to;
3773     return noconv;
3774 }
3775
3776 int
3777 __codecvt_utf16<char16_t, true>::do_encoding() const  _NOEXCEPT
3778 {
3779     return 0;
3780 }
3781
3782 bool
3783 __codecvt_utf16<char16_t, true>::do_always_noconv() const  _NOEXCEPT
3784 {
3785     return false;
3786 }
3787
3788 int
3789 __codecvt_utf16<char16_t, true>::do_length(state_type&,
3790     const extern_type* frm, const extern_type* frm_end, size_t mx) const
3791 {
3792     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3793     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3794     return utf16le_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3795 }
3796
3797 int
3798 __codecvt_utf16<char16_t, true>::do_max_length() const  _NOEXCEPT
3799 {
3800     if (_Mode_ & consume_header)
3801         return 4;
3802     return 2;
3803 }
3804
3805 // __codecvt_utf16<char32_t, false>
3806
3807 __codecvt_utf16<char32_t, false>::result
3808 __codecvt_utf16<char32_t, false>::do_out(state_type&,
3809     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3810     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3811 {
3812     const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3813     const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3814     const uint32_t* _frm_nxt = _frm;
3815     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3816     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3817     uint8_t* _to_nxt = _to;
3818     result r = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3819                                _Maxcode_, _Mode_);
3820     frm_nxt = frm + (_frm_nxt - _frm);
3821     to_nxt = to + (_to_nxt - _to);
3822     return r;
3823 }
3824
3825 __codecvt_utf16<char32_t, false>::result
3826 __codecvt_utf16<char32_t, false>::do_in(state_type&,
3827     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3828     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3829 {
3830     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3831     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3832     const uint8_t* _frm_nxt = _frm;
3833     uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3834     uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3835     uint32_t* _to_nxt = _to;
3836     result r = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3837                                _Maxcode_, _Mode_);
3838     frm_nxt = frm + (_frm_nxt - _frm);
3839     to_nxt = to + (_to_nxt - _to);
3840     return r;
3841 }
3842
3843 __codecvt_utf16<char32_t, false>::result
3844 __codecvt_utf16<char32_t, false>::do_unshift(state_type&,
3845     extern_type* to, extern_type*, extern_type*& to_nxt) const
3846 {
3847     to_nxt = to;
3848     return noconv;
3849 }
3850
3851 int
3852 __codecvt_utf16<char32_t, false>::do_encoding() const  _NOEXCEPT
3853 {
3854     return 0;
3855 }
3856
3857 bool
3858 __codecvt_utf16<char32_t, false>::do_always_noconv() const  _NOEXCEPT
3859 {
3860     return false;
3861 }
3862
3863 int
3864 __codecvt_utf16<char32_t, false>::do_length(state_type&,
3865     const extern_type* frm, const extern_type* frm_end, size_t mx) const
3866 {
3867     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3868     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3869     return utf16be_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3870 }
3871
3872 int
3873 __codecvt_utf16<char32_t, false>::do_max_length() const  _NOEXCEPT
3874 {
3875     if (_Mode_ & consume_header)
3876         return 6;
3877     return 4;
3878 }
3879
3880 // __codecvt_utf16<char32_t, true>
3881
3882 __codecvt_utf16<char32_t, true>::result
3883 __codecvt_utf16<char32_t, true>::do_out(state_type&,
3884     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3885     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3886 {
3887     const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3888     const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3889     const uint32_t* _frm_nxt = _frm;
3890     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3891     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3892     uint8_t* _to_nxt = _to;
3893     result r = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3894                                _Maxcode_, _Mode_);
3895     frm_nxt = frm + (_frm_nxt - _frm);
3896     to_nxt = to + (_to_nxt - _to);
3897     return r;
3898 }
3899
3900 __codecvt_utf16<char32_t, true>::result
3901 __codecvt_utf16<char32_t, true>::do_in(state_type&,
3902     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3903     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3904 {
3905     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3906     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3907     const uint8_t* _frm_nxt = _frm;
3908     uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3909     uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3910     uint32_t* _to_nxt = _to;
3911     result r = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3912                                _Maxcode_, _Mode_);
3913     frm_nxt = frm + (_frm_nxt - _frm);
3914     to_nxt = to + (_to_nxt - _to);
3915     return r;
3916 }
3917
3918 __codecvt_utf16<char32_t, true>::result
3919 __codecvt_utf16<char32_t, true>::do_unshift(state_type&,
3920     extern_type* to, extern_type*, extern_type*& to_nxt) const
3921 {
3922     to_nxt = to;
3923     return noconv;
3924 }
3925
3926 int
3927 __codecvt_utf16<char32_t, true>::do_encoding() const  _NOEXCEPT
3928 {
3929     return 0;
3930 }
3931
3932 bool
3933 __codecvt_utf16<char32_t, true>::do_always_noconv() const  _NOEXCEPT
3934 {
3935     return false;
3936 }
3937
3938 int
3939 __codecvt_utf16<char32_t, true>::do_length(state_type&,
3940     const extern_type* frm, const extern_type* frm_end, size_t mx) const
3941 {
3942     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3943     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3944     return utf16le_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3945 }
3946
3947 int
3948 __codecvt_utf16<char32_t, true>::do_max_length() const  _NOEXCEPT
3949 {
3950     if (_Mode_ & consume_header)
3951         return 6;
3952     return 4;
3953 }
3954
3955 // __codecvt_utf8_utf16<wchar_t>
3956
3957 __codecvt_utf8_utf16<wchar_t>::result
3958 __codecvt_utf8_utf16<wchar_t>::do_out(state_type&,
3959     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3960     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3961 {
3962     const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3963     const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3964     const uint32_t* _frm_nxt = _frm;
3965     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3966     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3967     uint8_t* _to_nxt = _to;
3968     result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3969                              _Maxcode_, _Mode_);
3970     frm_nxt = frm + (_frm_nxt - _frm);
3971     to_nxt = to + (_to_nxt - _to);
3972     return r;
3973 }
3974
3975 __codecvt_utf8_utf16<wchar_t>::result
3976 __codecvt_utf8_utf16<wchar_t>::do_in(state_type&,
3977     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3978     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3979 {
3980     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3981     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3982     const uint8_t* _frm_nxt = _frm;
3983     uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3984     uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3985     uint32_t* _to_nxt = _to;
3986     result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3987                              _Maxcode_, _Mode_);
3988     frm_nxt = frm + (_frm_nxt - _frm);
3989     to_nxt = to + (_to_nxt - _to);
3990     return r;
3991 }
3992
3993 __codecvt_utf8_utf16<wchar_t>::result
3994 __codecvt_utf8_utf16<wchar_t>::do_unshift(state_type&,
3995     extern_type* to, extern_type*, extern_type*& to_nxt) const
3996 {
3997     to_nxt = to;
3998     return noconv;
3999 }
4000
4001 int
4002 __codecvt_utf8_utf16<wchar_t>::do_encoding() const  _NOEXCEPT
4003 {
4004     return 0;
4005 }
4006
4007 bool
4008 __codecvt_utf8_utf16<wchar_t>::do_always_noconv() const  _NOEXCEPT
4009 {
4010     return false;
4011 }
4012
4013 int
4014 __codecvt_utf8_utf16<wchar_t>::do_length(state_type&,
4015     const extern_type* frm, const extern_type* frm_end, size_t mx) const
4016 {
4017     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
4018     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
4019     return utf8_to_utf16_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
4020 }
4021
4022 int
4023 __codecvt_utf8_utf16<wchar_t>::do_max_length() const  _NOEXCEPT
4024 {
4025     if (_Mode_ & consume_header)
4026         return 7;
4027     return 4;
4028 }
4029
4030 // __codecvt_utf8_utf16<char16_t>
4031
4032 __codecvt_utf8_utf16<char16_t>::result
4033 __codecvt_utf8_utf16<char16_t>::do_out(state_type&,
4034     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
4035     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
4036 {
4037     const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
4038     const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
4039     const uint16_t* _frm_nxt = _frm;
4040     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
4041     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
4042     uint8_t* _to_nxt = _to;
4043     result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
4044                              _Maxcode_, _Mode_);
4045     frm_nxt = frm + (_frm_nxt - _frm);
4046     to_nxt = to + (_to_nxt - _to);
4047     return r;
4048 }
4049
4050 __codecvt_utf8_utf16<char16_t>::result
4051 __codecvt_utf8_utf16<char16_t>::do_in(state_type&,
4052     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
4053     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
4054 {
4055     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
4056     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
4057     const uint8_t* _frm_nxt = _frm;
4058     uint16_t* _to = reinterpret_cast<uint16_t*>(to);
4059     uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
4060     uint16_t* _to_nxt = _to;
4061     result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
4062                              _Maxcode_, _Mode_);
4063     frm_nxt = frm + (_frm_nxt - _frm);
4064     to_nxt = to + (_to_nxt - _to);
4065     return r;
4066 }
4067
4068 __codecvt_utf8_utf16<char16_t>::result
4069 __codecvt_utf8_utf16<char16_t>::do_unshift(state_type&,
4070     extern_type* to, extern_type*, extern_type*& to_nxt) const
4071 {
4072     to_nxt = to;
4073     return noconv;
4074 }
4075
4076 int
4077 __codecvt_utf8_utf16<char16_t>::do_encoding() const  _NOEXCEPT
4078 {
4079     return 0;
4080 }
4081
4082 bool
4083 __codecvt_utf8_utf16<char16_t>::do_always_noconv() const  _NOEXCEPT
4084 {
4085     return false;
4086 }
4087
4088 int
4089 __codecvt_utf8_utf16<char16_t>::do_length(state_type&,
4090     const extern_type* frm, const extern_type* frm_end, size_t mx) const
4091 {
4092     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
4093     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
4094     return utf8_to_utf16_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
4095 }
4096
4097 int
4098 __codecvt_utf8_utf16<char16_t>::do_max_length() const  _NOEXCEPT
4099 {
4100     if (_Mode_ & consume_header)
4101         return 7;
4102     return 4;
4103 }
4104
4105 // __codecvt_utf8_utf16<char32_t>
4106
4107 __codecvt_utf8_utf16<char32_t>::result
4108 __codecvt_utf8_utf16<char32_t>::do_out(state_type&,
4109     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
4110     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
4111 {
4112     const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
4113     const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
4114     const uint32_t* _frm_nxt = _frm;
4115     uint8_t* _to = reinterpret_cast<uint8_t*>(to);
4116     uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
4117     uint8_t* _to_nxt = _to;
4118     result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
4119                              _Maxcode_, _Mode_);
4120     frm_nxt = frm + (_frm_nxt - _frm);
4121     to_nxt = to + (_to_nxt - _to);
4122     return r;
4123 }
4124
4125 __codecvt_utf8_utf16<char32_t>::result
4126 __codecvt_utf8_utf16<char32_t>::do_in(state_type&,
4127     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
4128     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
4129 {
4130     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
4131     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
4132     const uint8_t* _frm_nxt = _frm;
4133     uint32_t* _to = reinterpret_cast<uint32_t*>(to);
4134     uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
4135     uint32_t* _to_nxt = _to;
4136     result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
4137                              _Maxcode_, _Mode_);
4138     frm_nxt = frm + (_frm_nxt - _frm);
4139     to_nxt = to + (_to_nxt - _to);
4140     return r;
4141 }
4142
4143 __codecvt_utf8_utf16<char32_t>::result
4144 __codecvt_utf8_utf16<char32_t>::do_unshift(state_type&,
4145     extern_type* to, extern_type*, extern_type*& to_nxt) const
4146 {
4147     to_nxt = to;
4148     return noconv;
4149 }
4150
4151 int
4152 __codecvt_utf8_utf16<char32_t>::do_encoding() const  _NOEXCEPT
4153 {
4154     return 0;
4155 }
4156
4157 bool
4158 __codecvt_utf8_utf16<char32_t>::do_always_noconv() const  _NOEXCEPT
4159 {
4160     return false;
4161 }
4162
4163 int
4164 __codecvt_utf8_utf16<char32_t>::do_length(state_type&,
4165     const extern_type* frm, const extern_type* frm_end, size_t mx) const
4166 {
4167     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
4168     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
4169     return utf8_to_utf16_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
4170 }
4171
4172 int
4173 __codecvt_utf8_utf16<char32_t>::do_max_length() const  _NOEXCEPT
4174 {
4175     if (_Mode_ & consume_header)
4176         return 7;
4177     return 4;
4178 }
4179
4180 // __narrow_to_utf8<16>
4181
4182 __narrow_to_utf8<16>::~__narrow_to_utf8()
4183 {
4184 }
4185
4186 // __narrow_to_utf8<32>
4187
4188 __narrow_to_utf8<32>::~__narrow_to_utf8()
4189 {
4190 }
4191
4192 // __widen_from_utf8<16>
4193
4194 __widen_from_utf8<16>::~__widen_from_utf8()
4195 {
4196 }
4197
4198 // __widen_from_utf8<32>
4199
4200 __widen_from_utf8<32>::~__widen_from_utf8()
4201 {
4202 }
4203
4204
4205 static bool checked_string_to_wchar_convert(wchar_t& dest,
4206                                             const char* ptr,
4207                                             locale_t loc) {
4208   if (*ptr == '\0')
4209     return false;
4210   mbstate_t mb = {};
4211   wchar_t out;
4212   size_t ret = __libcpp_mbrtowc_l(&out, ptr, strlen(ptr), &mb, loc);
4213   if (ret == static_cast<size_t>(-1) || ret == static_cast<size_t>(-2)) {
4214     return false;
4215   }
4216   dest = out;
4217   return true;
4218 }
4219
4220 static bool checked_string_to_char_convert(char& dest,
4221                                            const char* ptr,
4222                                            locale_t __loc) {
4223   if (*ptr == '\0')
4224     return false;
4225   if (!ptr[1]) {
4226     dest = *ptr;
4227     return true;
4228   }
4229   // First convert the MBS into a wide char then attempt to narrow it using
4230   // wctob_l.
4231   wchar_t wout;
4232   if (!checked_string_to_wchar_convert(wout, ptr, __loc))
4233     return false;
4234   int res;
4235   if ((res = __libcpp_wctob_l(wout, __loc)) != char_traits<char>::eof()) {
4236     dest = res;
4237     return true;
4238   }
4239   // FIXME: Work around specific multibyte sequences that we can reasonable
4240   // translate into a different single byte.
4241   switch (wout) {
4242   case L'\u00A0': // non-breaking space
4243     dest = ' ';
4244     return true;
4245   default:
4246     return false;
4247   }
4248   _LIBCPP_UNREACHABLE();
4249 }
4250
4251
4252 // numpunct<char> && numpunct<wchar_t>
4253
4254 locale::id numpunct< char  >::id;
4255 locale::id numpunct<wchar_t>::id;
4256
4257 numpunct<char>::numpunct(size_t refs)
4258     : locale::facet(refs),
4259       __decimal_point_('.'),
4260       __thousands_sep_(',')
4261 {
4262 }
4263
4264 numpunct<wchar_t>::numpunct(size_t refs)
4265     : locale::facet(refs),
4266       __decimal_point_(L'.'),
4267       __thousands_sep_(L',')
4268 {
4269 }
4270
4271 numpunct<char>::~numpunct()
4272 {
4273 }
4274
4275 numpunct<wchar_t>::~numpunct()
4276 {
4277 }
4278
4279  char   numpunct< char  >::do_decimal_point() const {return __decimal_point_;}
4280 wchar_t numpunct<wchar_t>::do_decimal_point() const {return __decimal_point_;}
4281
4282  char   numpunct< char  >::do_thousands_sep() const {return __thousands_sep_;}
4283 wchar_t numpunct<wchar_t>::do_thousands_sep() const {return __thousands_sep_;}
4284
4285 string numpunct< char  >::do_grouping() const {return __grouping_;}
4286 string numpunct<wchar_t>::do_grouping() const {return __grouping_;}
4287
4288  string numpunct< char  >::do_truename() const {return "true";}
4289 wstring numpunct<wchar_t>::do_truename() const {return L"true";}
4290
4291  string numpunct< char  >::do_falsename() const {return "false";}
4292 wstring numpunct<wchar_t>::do_falsename() const {return L"false";}
4293
4294 // numpunct_byname<char>
4295
4296 numpunct_byname<char>::numpunct_byname(const char* nm, size_t refs)
4297     : numpunct<char>(refs)
4298 {
4299     __init(nm);
4300 }
4301
4302 numpunct_byname<char>::numpunct_byname(const string& nm, size_t refs)
4303     : numpunct<char>(refs)
4304 {
4305     __init(nm.c_str());
4306 }
4307
4308 numpunct_byname<char>::~numpunct_byname()
4309 {
4310 }
4311
4312 void
4313 numpunct_byname<char>::__init(const char* nm)
4314 {
4315     if (strcmp(nm, "C") != 0)
4316     {
4317         __libcpp_unique_locale loc(nm);
4318         if (!loc)
4319             __throw_runtime_error("numpunct_byname<char>::numpunct_byname"
4320                                 " failed to construct for " + string(nm));
4321
4322         lconv* lc = __libcpp_localeconv_l(loc.get());
4323         checked_string_to_char_convert(__decimal_point_, lc->decimal_point,
4324                                        loc.get());
4325         checked_string_to_char_convert(__thousands_sep_, lc->thousands_sep,
4326                                        loc.get());
4327         __grouping_ = lc->grouping;
4328         // localization for truename and falsename is not available
4329     }
4330 }
4331
4332 // numpunct_byname<wchar_t>
4333
4334 numpunct_byname<wchar_t>::numpunct_byname(const char* nm, size_t refs)
4335     : numpunct<wchar_t>(refs)
4336 {
4337     __init(nm);
4338 }
4339
4340 numpunct_byname<wchar_t>::numpunct_byname(const string& nm, size_t refs)
4341     : numpunct<wchar_t>(refs)
4342 {
4343     __init(nm.c_str());
4344 }
4345
4346 numpunct_byname<wchar_t>::~numpunct_byname()
4347 {
4348 }
4349
4350 void
4351 numpunct_byname<wchar_t>::__init(const char* nm)
4352 {
4353     if (strcmp(nm, "C") != 0)
4354     {
4355         __libcpp_unique_locale loc(nm);
4356         if (!loc)
4357             __throw_runtime_error("numpunct_byname<wchar_t>::numpunct_byname"
4358                                 " failed to construct for " + string(nm));
4359
4360         lconv* lc = __libcpp_localeconv_l(loc.get());
4361         checked_string_to_wchar_convert(__decimal_point_, lc->decimal_point,
4362                                         loc.get());
4363         checked_string_to_wchar_convert(__thousands_sep_, lc->thousands_sep,
4364                                         loc.get());
4365         __grouping_ = lc->grouping;
4366         // localization for truename and falsename is not available
4367     }
4368 }
4369
4370 // num_get helpers
4371
4372 int
4373 __num_get_base::__get_base(ios_base& iob)
4374 {
4375     ios_base::fmtflags __basefield = iob.flags() & ios_base::basefield;
4376     if (__basefield == ios_base::oct)
4377         return 8;
4378     else if (__basefield == ios_base::hex)
4379         return 16;
4380     else if (__basefield == 0)
4381         return 0;
4382     return 10;
4383 }
4384
4385 const char __num_get_base::__src[33] = "0123456789abcdefABCDEFxX+-pPiInN";
4386
4387 void
4388 __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end,
4389                  ios_base::iostate& __err)
4390 {
4391     if (__grouping.size() != 0)
4392     {
4393         reverse(__g, __g_end);
4394         const char* __ig = __grouping.data();
4395         const char* __eg = __ig + __grouping.size();
4396         for (unsigned* __r = __g; __r < __g_end-1; ++__r)
4397         {
4398             if (0 < *__ig && *__ig < numeric_limits<char>::max())
4399             {
4400                 if (static_cast<unsigned>(*__ig) != *__r)
4401                 {
4402                     __err = ios_base::failbit;
4403                     return;
4404                 }
4405             }
4406             if (__eg - __ig > 1)
4407                 ++__ig;
4408         }
4409         if (0 < *__ig && *__ig < numeric_limits<char>::max())
4410         {
4411             if (static_cast<unsigned>(*__ig) < __g_end[-1] || __g_end[-1] == 0)
4412                 __err = ios_base::failbit;
4413         }
4414     }
4415 }
4416
4417 void
4418 __num_put_base::__format_int(char* __fmtp, const char* __len, bool __signd,
4419                              ios_base::fmtflags __flags)
4420 {
4421     if (__flags & ios_base::showpos)
4422         *__fmtp++ = '+';
4423     if (__flags & ios_base::showbase)
4424         *__fmtp++ = '#';
4425     while(*__len)
4426         *__fmtp++ = *__len++;
4427     if ((__flags & ios_base::basefield) == ios_base::oct)
4428         *__fmtp = 'o';
4429     else if ((__flags & ios_base::basefield) == ios_base::hex)
4430     {
4431         if (__flags & ios_base::uppercase)
4432             *__fmtp = 'X';
4433         else
4434             *__fmtp = 'x';
4435     }
4436     else if (__signd)
4437         *__fmtp = 'd';
4438     else
4439         *__fmtp = 'u';
4440 }
4441
4442 bool
4443 __num_put_base::__format_float(char* __fmtp, const char* __len,
4444                                ios_base::fmtflags __flags)
4445 {
4446     bool specify_precision = true;
4447     if (__flags & ios_base::showpos)
4448         *__fmtp++ = '+';
4449     if (__flags & ios_base::showpoint)
4450         *__fmtp++ = '#';
4451     ios_base::fmtflags floatfield = __flags & ios_base::floatfield;
4452     bool uppercase = (__flags & ios_base::uppercase) != 0;
4453     if (floatfield == (ios_base::fixed | ios_base::scientific))
4454         specify_precision = false;
4455     else
4456     {
4457         *__fmtp++ = '.';
4458         *__fmtp++ = '*';
4459     }
4460     while(*__len)
4461         *__fmtp++ = *__len++;
4462     if (floatfield == ios_base::fixed)
4463     {
4464         if (uppercase)
4465             *__fmtp = 'F';
4466         else
4467             *__fmtp = 'f';
4468     }
4469     else if (floatfield == ios_base::scientific)
4470     {
4471         if (uppercase)
4472             *__fmtp = 'E';
4473         else
4474             *__fmtp = 'e';
4475     }
4476     else if (floatfield == (ios_base::fixed | ios_base::scientific))
4477     {
4478         if (uppercase)
4479             *__fmtp = 'A';
4480         else
4481             *__fmtp = 'a';
4482     }
4483     else
4484     {
4485         if (uppercase)
4486             *__fmtp = 'G';
4487         else
4488             *__fmtp = 'g';
4489     }
4490     return specify_precision;
4491 }
4492
4493 char*
4494 __num_put_base::__identify_padding(char* __nb, char* __ne,
4495                                    const ios_base& __iob)
4496 {
4497     switch (__iob.flags() & ios_base::adjustfield)
4498     {
4499     case ios_base::internal:
4500         if (__nb[0] == '-' || __nb[0] == '+')
4501             return __nb+1;
4502         if (__ne - __nb >= 2 && __nb[0] == '0'
4503                             && (__nb[1] == 'x' || __nb[1] == 'X'))
4504             return __nb+2;
4505         break;
4506     case ios_base::left:
4507         return __ne;
4508     case ios_base::right:
4509     default:
4510         break;
4511     }
4512     return __nb;
4513 }
4514
4515 // time_get
4516
4517 static
4518 string*
4519 init_weeks()
4520 {
4521     static string weeks[14];
4522     weeks[0]  = "Sunday";
4523     weeks[1]  = "Monday";
4524     weeks[2]  = "Tuesday";
4525     weeks[3]  = "Wednesday";
4526     weeks[4]  = "Thursday";
4527     weeks[5]  = "Friday";
4528     weeks[6]  = "Saturday";
4529     weeks[7]  = "Sun";
4530     weeks[8]  = "Mon";
4531     weeks[9]  = "Tue";
4532     weeks[10] = "Wed";
4533     weeks[11] = "Thu";
4534     weeks[12] = "Fri";
4535     weeks[13] = "Sat";
4536     return weeks;
4537 }
4538
4539 static
4540 wstring*
4541 init_wweeks()
4542 {
4543     static wstring weeks[14];
4544     weeks[0]  = L"Sunday";
4545     weeks[1]  = L"Monday";
4546     weeks[2]  = L"Tuesday";
4547     weeks[3]  = L"Wednesday";
4548     weeks[4]  = L"Thursday";
4549     weeks[5]  = L"Friday";
4550     weeks[6]  = L"Saturday";
4551     weeks[7]  = L"Sun";
4552     weeks[8]  = L"Mon";
4553     weeks[9]  = L"Tue";
4554     weeks[10] = L"Wed";
4555     weeks[11] = L"Thu";
4556     weeks[12] = L"Fri";
4557     weeks[13] = L"Sat";
4558     return weeks;
4559 }
4560
4561 template <>
4562 const string*
4563 __time_get_c_storage<char>::__weeks() const
4564 {
4565     static const string* weeks = init_weeks();
4566     return weeks;
4567 }
4568
4569 template <>
4570 const wstring*
4571 __time_get_c_storage<wchar_t>::__weeks() const
4572 {
4573     static const wstring* weeks = init_wweeks();
4574     return weeks;
4575 }
4576
4577 static
4578 string*
4579 init_months()
4580 {
4581     static string months[24];
4582     months[0]  = "January";
4583     months[1]  = "February";
4584     months[2]  = "March";
4585     months[3]  = "April";
4586     months[4]  = "May";
4587     months[5]  = "June";
4588     months[6]  = "July";
4589     months[7]  = "August";
4590     months[8]  = "September";
4591     months[9]  = "October";
4592     months[10] = "November";
4593     months[11] = "December";
4594     months[12] = "Jan";
4595     months[13] = "Feb";
4596     months[14] = "Mar";
4597     months[15] = "Apr";
4598     months[16] = "May";
4599     months[17] = "Jun";
4600     months[18] = "Jul";
4601     months[19] = "Aug";
4602     months[20] = "Sep";
4603     months[21] = "Oct";
4604     months[22] = "Nov";
4605     months[23] = "Dec";
4606     return months;
4607 }
4608
4609 static
4610 wstring*
4611 init_wmonths()
4612 {
4613     static wstring months[24];
4614     months[0]  = L"January";
4615     months[1]  = L"February";
4616     months[2]  = L"March";
4617     months[3]  = L"April";
4618     months[4]  = L"May";
4619     months[5]  = L"June";
4620     months[6]  = L"July";
4621     months[7]  = L"August";
4622     months[8]  = L"September";
4623     months[9]  = L"October";
4624     months[10] = L"November";
4625     months[11] = L"December";
4626     months[12] = L"Jan";
4627     months[13] = L"Feb";
4628     months[14] = L"Mar";
4629     months[15] = L"Apr";
4630     months[16] = L"May";
4631     months[17] = L"Jun";
4632     months[18] = L"Jul";
4633     months[19] = L"Aug";
4634     months[20] = L"Sep";
4635     months[21] = L"Oct";
4636     months[22] = L"Nov";
4637     months[23] = L"Dec";
4638     return months;
4639 }
4640
4641 template <>
4642 const string*
4643 __time_get_c_storage<char>::__months() const
4644 {
4645     static const string* months = init_months();
4646     return months;
4647 }
4648
4649 template <>
4650 const wstring*
4651 __time_get_c_storage<wchar_t>::__months() const
4652 {
4653     static const wstring* months = init_wmonths();
4654     return months;
4655 }
4656
4657 static
4658 string*
4659 init_am_pm()
4660 {
4661     static string am_pm[24];
4662     am_pm[0]  = "AM";
4663     am_pm[1]  = "PM";
4664     return am_pm;
4665 }
4666
4667 static
4668 wstring*
4669 init_wam_pm()
4670 {
4671     static wstring am_pm[24];
4672     am_pm[0]  = L"AM";
4673     am_pm[1]  = L"PM";
4674     return am_pm;
4675 }
4676
4677 template <>
4678 const string*
4679 __time_get_c_storage<char>::__am_pm() const
4680 {
4681     static const string* am_pm = init_am_pm();
4682     return am_pm;
4683 }
4684
4685 template <>
4686 const wstring*
4687 __time_get_c_storage<wchar_t>::__am_pm() const
4688 {
4689     static const wstring* am_pm = init_wam_pm();
4690     return am_pm;
4691 }
4692
4693 template <>
4694 const string&
4695 __time_get_c_storage<char>::__x() const
4696 {
4697     static string s("%m/%d/%y");
4698     return s;
4699 }
4700
4701 template <>
4702 const wstring&
4703 __time_get_c_storage<wchar_t>::__x() const
4704 {
4705     static wstring s(L"%m/%d/%y");
4706     return s;
4707 }
4708
4709 template <>
4710 const string&
4711 __time_get_c_storage<char>::__X() const
4712 {
4713     static string s("%H:%M:%S");
4714     return s;
4715 }
4716
4717 template <>
4718 const wstring&
4719 __time_get_c_storage<wchar_t>::__X() const
4720 {
4721     static wstring s(L"%H:%M:%S");
4722     return s;
4723 }
4724
4725 template <>
4726 const string&
4727 __time_get_c_storage<char>::__c() const
4728 {
4729     static string s("%a %b %d %H:%M:%S %Y");
4730     return s;
4731 }
4732
4733 template <>
4734 const wstring&
4735 __time_get_c_storage<wchar_t>::__c() const
4736 {
4737     static wstring s(L"%a %b %d %H:%M:%S %Y");
4738     return s;
4739 }
4740
4741 template <>
4742 const string&
4743 __time_get_c_storage<char>::__r() const
4744 {
4745     static string s("%I:%M:%S %p");
4746     return s;
4747 }
4748
4749 template <>
4750 const wstring&
4751 __time_get_c_storage<wchar_t>::__r() const
4752 {
4753     static wstring s(L"%I:%M:%S %p");
4754     return s;
4755 }
4756
4757 // time_get_byname
4758
4759 __time_get::__time_get(const char* nm)
4760     : __loc_(newlocale(LC_ALL_MASK, nm, 0))
4761 {
4762     if (__loc_ == 0)
4763         __throw_runtime_error("time_get_byname"
4764                             " failed to construct for " + string(nm));
4765 }
4766
4767 __time_get::__time_get(const string& nm)
4768     : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
4769 {
4770     if (__loc_ == 0)
4771         __throw_runtime_error("time_get_byname"
4772                             " failed to construct for " + nm);
4773 }
4774
4775 __time_get::~__time_get()
4776 {
4777     freelocale(__loc_);
4778 }
4779 #if defined(__clang__)
4780 #pragma clang diagnostic ignored "-Wmissing-field-initializers"
4781 #endif
4782 #if defined(__GNUG__)
4783 #pragma GCC   diagnostic ignored "-Wmissing-field-initializers"
4784 #endif
4785
4786 template <>
4787 string
4788 __time_get_storage<char>::__analyze(char fmt, const ctype<char>& ct)
4789 {
4790     tm t = {0};
4791     t.tm_sec = 59;
4792     t.tm_min = 55;
4793     t.tm_hour = 23;
4794     t.tm_mday = 31;
4795     t.tm_mon = 11;
4796     t.tm_year = 161;
4797     t.tm_wday = 6;
4798     t.tm_yday = 364;
4799     t.tm_isdst = -1;
4800     char buf[100];
4801     char f[3] = {0};
4802     f[0] = '%';
4803     f[1] = fmt;
4804     size_t n = strftime_l(buf, countof(buf), f, &t, __loc_);
4805     char* bb = buf;
4806     char* be = buf + n;
4807     string result;
4808     while (bb != be)
4809     {
4810         if (ct.is(ctype_base::space, *bb))
4811         {
4812             result.push_back(' ');
4813             for (++bb; bb != be && ct.is(ctype_base::space, *bb); ++bb)
4814                 ;
4815             continue;
4816         }
4817         char* w = bb;
4818         ios_base::iostate err = ios_base::goodbit;
4819         ptrdiff_t i = __scan_keyword(w, be, this->__weeks_, this->__weeks_+14,
4820                                ct, err, false)
4821                                - this->__weeks_;
4822         if (i < 14)
4823         {
4824             result.push_back('%');
4825             if (i < 7)
4826                 result.push_back('A');
4827             else
4828                 result.push_back('a');
4829             bb = w;
4830             continue;
4831         }
4832         w = bb;
4833         i = __scan_keyword(w, be, this->__months_, this->__months_+24,
4834                            ct, err, false)
4835                            - this->__months_;
4836         if (i < 24)
4837         {
4838             result.push_back('%');
4839             if (i < 12)
4840                 result.push_back('B');
4841             else
4842                 result.push_back('b');
4843             if (fmt == 'x' && ct.is(ctype_base::digit, this->__months_[i][0]))
4844                 result.back() = 'm';
4845             bb = w;
4846             continue;
4847         }
4848         if (this->__am_pm_[0].size() + this->__am_pm_[1].size() > 0)
4849         {
4850             w = bb;
4851             i = __scan_keyword(w, be, this->__am_pm_, this->__am_pm_+2,
4852                                ct, err, false) - this->__am_pm_;
4853             if (i < 2)
4854             {
4855                 result.push_back('%');
4856                 result.push_back('p');
4857                 bb = w;
4858                 continue;
4859             }
4860         }
4861         w = bb;
4862         if (ct.is(ctype_base::digit, *bb))
4863         {
4864             switch(__get_up_to_n_digits(bb, be, err, ct, 4))
4865             {
4866             case 6:
4867                 result.push_back('%');
4868                 result.push_back('w');
4869                 break;
4870             case 7:
4871                 result.push_back('%');
4872                 result.push_back('u');
4873                 break;
4874             case 11:
4875                 result.push_back('%');
4876                 result.push_back('I');
4877                 break;
4878             case 12:
4879                 result.push_back('%');
4880                 result.push_back('m');
4881                 break;
4882             case 23:
4883                 result.push_back('%');
4884                 result.push_back('H');
4885                 break;
4886             case 31:
4887                 result.push_back('%');
4888                 result.push_back('d');
4889                 break;
4890             case 55:
4891                 result.push_back('%');
4892                 result.push_back('M');
4893                 break;
4894             case 59:
4895                 result.push_back('%');
4896                 result.push_back('S');
4897                 break;
4898             case 61:
4899                 result.push_back('%');
4900                 result.push_back('y');
4901                 break;
4902             case 364:
4903                 result.push_back('%');
4904                 result.push_back('j');
4905                 break;
4906             case 2061:
4907                 result.push_back('%');
4908                 result.push_back('Y');
4909                 break;
4910             default:
4911                 for (; w != bb; ++w)
4912                     result.push_back(*w);
4913                 break;
4914             }
4915             continue;
4916         }
4917         if (*bb == '%')
4918         {
4919             result.push_back('%');
4920             result.push_back('%');
4921             ++bb;
4922             continue;
4923         }
4924         result.push_back(*bb);
4925         ++bb;
4926     }
4927     return result;
4928 }
4929
4930 #if defined(__clang__)
4931 #pragma clang diagnostic ignored "-Wmissing-braces"
4932 #endif
4933
4934 template <>
4935 wstring
4936 __time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& ct)
4937 {
4938     tm t = {0};
4939     t.tm_sec = 59;
4940     t.tm_min = 55;
4941     t.tm_hour = 23;
4942     t.tm_mday = 31;
4943     t.tm_mon = 11;
4944     t.tm_year = 161;
4945     t.tm_wday = 6;
4946     t.tm_yday = 364;
4947     t.tm_isdst = -1;
4948     char buf[100];
4949     char f[3] = {0};
4950     f[0] = '%';
4951     f[1] = fmt;
4952     strftime_l(buf, countof(buf), f, &t, __loc_);
4953     wchar_t wbuf[100];
4954     wchar_t* wbb = wbuf;
4955     mbstate_t mb = {0};
4956     const char* bb = buf;
4957     size_t j = __libcpp_mbsrtowcs_l( wbb, &bb, countof(wbuf), &mb, __loc_);
4958     if (j == size_t(-1))
4959         __throw_runtime_error("locale not supported");
4960     wchar_t* wbe = wbb + j;
4961     wstring result;
4962     while (wbb != wbe)
4963     {
4964         if (ct.is(ctype_base::space, *wbb))
4965         {
4966             result.push_back(L' ');
4967             for (++wbb; wbb != wbe && ct.is(ctype_base::space, *wbb); ++wbb)
4968                 ;
4969             continue;
4970         }
4971         wchar_t* w = wbb;
4972         ios_base::iostate err = ios_base::goodbit;
4973         ptrdiff_t i = __scan_keyword(w, wbe, this->__weeks_, this->__weeks_+14,
4974                                ct, err, false)
4975                                - this->__weeks_;
4976         if (i < 14)
4977         {
4978             result.push_back(L'%');
4979             if (i < 7)
4980                 result.push_back(L'A');
4981             else
4982                 result.push_back(L'a');
4983             wbb = w;
4984             continue;
4985         }
4986         w = wbb;
4987         i = __scan_keyword(w, wbe, this->__months_, this->__months_+24,
4988                            ct, err, false)
4989                            - this->__months_;
4990         if (i < 24)
4991         {
4992             result.push_back(L'%');
4993             if (i < 12)
4994                 result.push_back(L'B');
4995             else
4996                 result.push_back(L'b');
4997             if (fmt == 'x' && ct.is(ctype_base::digit, this->__months_[i][0]))
4998                 result.back() = L'm';
4999             wbb = w;
5000             continue;
5001         }
5002         if (this->__am_pm_[0].size() + this->__am_pm_[1].size() > 0)
5003         {
5004             w = wbb;
5005             i = __scan_keyword(w, wbe, this->__am_pm_, this->__am_pm_+2,
5006                                ct, err, false) - this->__am_pm_;
5007             if (i < 2)
5008             {
5009                 result.push_back(L'%');
5010                 result.push_back(L'p');
5011                 wbb = w;
5012                 continue;
5013             }
5014         }
5015         w = wbb;
5016         if (ct.is(ctype_base::digit, *wbb))
5017         {
5018             switch(__get_up_to_n_digits(wbb, wbe, err, ct, 4))
5019             {
5020             case 6:
5021                 result.push_back(L'%');
5022                 result.push_back(L'w');
5023                 break;
5024             case 7:
5025                 result.push_back(L'%');
5026                 result.push_back(L'u');
5027                 break;
5028             case 11:
5029                 result.push_back(L'%');
5030                 result.push_back(L'I');
5031                 break;
5032             case 12:
5033                 result.push_back(L'%');
5034                 result.push_back(L'm');
5035                 break;
5036             case 23:
5037                 result.push_back(L'%');
5038                 result.push_back(L'H');
5039                 break;
5040             case 31:
5041                 result.push_back(L'%');
5042                 result.push_back(L'd');
5043                 break;
5044             case 55:
5045                 result.push_back(L'%');
5046                 result.push_back(L'M');
5047                 break;
5048             case 59:
5049                 result.push_back(L'%');
5050                 result.push_back(L'S');
5051                 break;
5052             case 61:
5053                 result.push_back(L'%');
5054                 result.push_back(L'y');
5055                 break;
5056             case 364:
5057                 result.push_back(L'%');
5058                 result.push_back(L'j');
5059                 break;
5060             case 2061:
5061                 result.push_back(L'%');
5062                 result.push_back(L'Y');
5063                 break;
5064             default:
5065                 for (; w != wbb; ++w)
5066                     result.push_back(*w);
5067                 break;
5068             }
5069             continue;
5070         }
5071         if (ct.narrow(*wbb, 0) == '%')
5072         {
5073             result.push_back(L'%');
5074             result.push_back(L'%');
5075             ++wbb;
5076             continue;
5077         }
5078         result.push_back(*wbb);
5079         ++wbb;
5080     }
5081     return result;
5082 }
5083
5084 template <>
5085 void
5086 __time_get_storage<char>::init(const ctype<char>& ct)
5087 {
5088     tm t = {0};
5089     char buf[100];
5090     // __weeks_
5091     for (int i = 0; i < 7; ++i)
5092     {
5093         t.tm_wday = i;
5094         strftime_l(buf, countof(buf), "%A", &t, __loc_);
5095         __weeks_[i] = buf;
5096         strftime_l(buf, countof(buf), "%a", &t, __loc_);
5097         __weeks_[i+7] = buf;
5098     }
5099     // __months_
5100     for (int i = 0; i < 12; ++i)
5101     {
5102         t.tm_mon = i;
5103         strftime_l(buf, countof(buf), "%B", &t, __loc_);
5104         __months_[i] = buf;
5105         strftime_l(buf, countof(buf), "%b", &t, __loc_);
5106         __months_[i+12] = buf;
5107     }
5108     // __am_pm_
5109     t.tm_hour = 1;
5110     strftime_l(buf, countof(buf), "%p", &t, __loc_);
5111     __am_pm_[0] = buf;
5112     t.tm_hour = 13;
5113     strftime_l(buf, countof(buf), "%p", &t, __loc_);
5114     __am_pm_[1] = buf;
5115     __c_ = __analyze('c', ct);
5116     __r_ = __analyze('r', ct);
5117     __x_ = __analyze('x', ct);
5118     __X_ = __analyze('X', ct);
5119 }
5120
5121 template <>
5122 void
5123 __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
5124 {
5125     tm t = {0};
5126     char buf[100];
5127     wchar_t wbuf[100];
5128     wchar_t* wbe;
5129     mbstate_t mb = {0};
5130     // __weeks_
5131     for (int i = 0; i < 7; ++i)
5132     {
5133         t.tm_wday = i;
5134         strftime_l(buf, countof(buf), "%A", &t, __loc_);
5135         mb = mbstate_t();
5136         const char* bb = buf;
5137         size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
5138         if (j == size_t(-1))
5139             __throw_runtime_error("locale not supported");
5140         wbe = wbuf + j;
5141         __weeks_[i].assign(wbuf, wbe);
5142         strftime_l(buf, countof(buf), "%a", &t, __loc_);
5143         mb = mbstate_t();
5144         bb = buf;
5145         j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
5146         if (j == size_t(-1))
5147             __throw_runtime_error("locale not supported");
5148         wbe = wbuf + j;
5149         __weeks_[i+7].assign(wbuf, wbe);
5150     }
5151     // __months_
5152     for (int i = 0; i < 12; ++i)
5153     {
5154         t.tm_mon = i;
5155         strftime_l(buf, countof(buf), "%B", &t, __loc_);
5156         mb = mbstate_t();
5157         const char* bb = buf;
5158         size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
5159         if (j == size_t(-1))
5160             __throw_runtime_error("locale not supported");
5161         wbe = wbuf + j;
5162         __months_[i].assign(wbuf, wbe);
5163         strftime_l(buf, countof(buf), "%b", &t, __loc_);
5164         mb = mbstate_t();
5165         bb = buf;
5166         j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
5167         if (j == size_t(-1))
5168             __throw_runtime_error("locale not supported");
5169         wbe = wbuf + j;
5170         __months_[i+12].assign(wbuf, wbe);
5171     }
5172     // __am_pm_
5173     t.tm_hour = 1;
5174     strftime_l(buf, countof(buf), "%p", &t, __loc_);
5175     mb = mbstate_t();
5176     const char* bb = buf;
5177     size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
5178     if (j == size_t(-1))
5179         __throw_runtime_error("locale not supported");
5180     wbe = wbuf + j;
5181     __am_pm_[0].assign(wbuf, wbe);
5182     t.tm_hour = 13;
5183     strftime_l(buf, countof(buf), "%p", &t, __loc_);
5184     mb = mbstate_t();
5185     bb = buf;
5186     j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
5187     if (j == size_t(-1))
5188         __throw_runtime_error("locale not supported");
5189     wbe = wbuf + j;
5190     __am_pm_[1].assign(wbuf, wbe);
5191     __c_ = __analyze('c', ct);
5192     __r_ = __analyze('r', ct);
5193     __x_ = __analyze('x', ct);
5194     __X_ = __analyze('X', ct);
5195 }
5196
5197 template <class CharT>
5198 struct _LIBCPP_HIDDEN __time_get_temp
5199     : public ctype_byname<CharT>
5200 {
5201     explicit __time_get_temp(const char* nm)
5202         : ctype_byname<CharT>(nm, 1) {}
5203     explicit __time_get_temp(const string& nm)
5204         : ctype_byname<CharT>(nm, 1) {}
5205 };
5206
5207 template <>
5208 __time_get_storage<char>::__time_get_storage(const char* __nm)
5209     : __time_get(__nm)
5210 {
5211     const __time_get_temp<char> ct(__nm);
5212     init(ct);
5213 }
5214
5215 template <>
5216 __time_get_storage<char>::__time_get_storage(const string& __nm)
5217     : __time_get(__nm)
5218 {
5219     const __time_get_temp<char> ct(__nm);
5220     init(ct);
5221 }
5222
5223 template <>
5224 __time_get_storage<wchar_t>::__time_get_storage(const char* __nm)
5225     : __time_get(__nm)
5226 {
5227     const __time_get_temp<wchar_t> ct(__nm);
5228     init(ct);
5229 }
5230
5231 template <>
5232 __time_get_storage<wchar_t>::__time_get_storage(const string& __nm)
5233     : __time_get(__nm)
5234 {
5235     const __time_get_temp<wchar_t> ct(__nm);
5236     init(ct);
5237 }
5238
5239 template <>
5240 time_base::dateorder
5241 __time_get_storage<char>::__do_date_order() const
5242 {
5243     unsigned i;
5244     for (i = 0; i < __x_.size(); ++i)
5245         if (__x_[i] == '%')
5246             break;
5247     ++i;
5248     switch (__x_[i])
5249     {
5250     case 'y':
5251     case 'Y':
5252         for (++i; i < __x_.size(); ++i)
5253             if (__x_[i] == '%')
5254                 break;
5255         if (i == __x_.size())
5256             break;
5257         ++i;
5258         switch (__x_[i])
5259         {
5260         case 'm':
5261             for (++i; i < __x_.size(); ++i)
5262                 if (__x_[i] == '%')
5263                     break;
5264             if (i == __x_.size())
5265                 break;
5266             ++i;
5267             if (__x_[i] == 'd')
5268                 return time_base::ymd;
5269             break;
5270         case 'd':
5271             for (++i; i < __x_.size(); ++i)
5272                 if (__x_[i] == '%')
5273                     break;
5274             if (i == __x_.size())
5275                 break;
5276             ++i;
5277             if (__x_[i] == 'm')
5278                 return time_base::ydm;
5279             break;
5280         }
5281         break;
5282     case 'm':
5283         for (++i; i < __x_.size(); ++i)
5284             if (__x_[i] == '%')
5285                 break;
5286         if (i == __x_.size())
5287             break;
5288         ++i;
5289         if (__x_[i] == 'd')
5290         {
5291             for (++i; i < __x_.size(); ++i)
5292                 if (__x_[i] == '%')
5293                     break;
5294             if (i == __x_.size())
5295                 break;
5296             ++i;
5297             if (__x_[i] == 'y' || __x_[i] == 'Y')
5298                 return time_base::mdy;
5299             break;
5300         }
5301         break;
5302     case 'd':
5303         for (++i; i < __x_.size(); ++i)
5304             if (__x_[i] == '%')
5305                 break;
5306         if (i == __x_.size())
5307             break;
5308         ++i;
5309         if (__x_[i] == 'm')
5310         {
5311             for (++i; i < __x_.size(); ++i)
5312                 if (__x_[i] == '%')
5313                     break;
5314             if (i == __x_.size())
5315                 break;
5316             ++i;
5317             if (__x_[i] == 'y' || __x_[i] == 'Y')
5318                 return time_base::dmy;
5319             break;
5320         }
5321         break;
5322     }
5323     return time_base::no_order;
5324 }
5325
5326 template <>
5327 time_base::dateorder
5328 __time_get_storage<wchar_t>::__do_date_order() const
5329 {
5330     unsigned i;
5331     for (i = 0; i < __x_.size(); ++i)
5332         if (__x_[i] == L'%')
5333             break;
5334     ++i;
5335     switch (__x_[i])
5336     {
5337     case L'y':
5338     case L'Y':
5339         for (++i; i < __x_.size(); ++i)
5340             if (__x_[i] == L'%')
5341                 break;
5342         if (i == __x_.size())
5343             break;
5344         ++i;
5345         switch (__x_[i])
5346         {
5347         case L'm':
5348             for (++i; i < __x_.size(); ++i)
5349                 if (__x_[i] == L'%')
5350                     break;
5351             if (i == __x_.size())
5352                 break;
5353             ++i;
5354             if (__x_[i] == L'd')
5355                 return time_base::ymd;
5356             break;
5357         case L'd':
5358             for (++i; i < __x_.size(); ++i)
5359                 if (__x_[i] == L'%')
5360                     break;
5361             if (i == __x_.size())
5362                 break;
5363             ++i;
5364             if (__x_[i] == L'm')
5365                 return time_base::ydm;
5366             break;
5367         }
5368         break;
5369     case L'm':
5370         for (++i; i < __x_.size(); ++i)
5371             if (__x_[i] == L'%')
5372                 break;
5373         if (i == __x_.size())
5374             break;
5375         ++i;
5376         if (__x_[i] == L'd')
5377         {
5378             for (++i; i < __x_.size(); ++i)
5379                 if (__x_[i] == L'%')
5380                     break;
5381             if (i == __x_.size())
5382                 break;
5383             ++i;
5384             if (__x_[i] == L'y' || __x_[i] == L'Y')
5385                 return time_base::mdy;
5386             break;
5387         }
5388         break;
5389     case L'd':
5390         for (++i; i < __x_.size(); ++i)
5391             if (__x_[i] == L'%')
5392                 break;
5393         if (i == __x_.size())
5394             break;
5395         ++i;
5396         if (__x_[i] == L'm')
5397         {
5398             for (++i; i < __x_.size(); ++i)
5399                 if (__x_[i] == L'%')
5400                     break;
5401             if (i == __x_.size())
5402                 break;
5403             ++i;
5404             if (__x_[i] == L'y' || __x_[i] == L'Y')
5405                 return time_base::dmy;
5406             break;
5407         }
5408         break;
5409     }
5410     return time_base::no_order;
5411 }
5412
5413 // time_put
5414
5415 __time_put::__time_put(const char* nm)
5416     : __loc_(newlocale(LC_ALL_MASK, nm, 0))
5417 {
5418     if (__loc_ == 0)
5419         __throw_runtime_error("time_put_byname"
5420                             " failed to construct for " + string(nm));
5421 }
5422
5423 __time_put::__time_put(const string& nm)
5424     : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
5425 {
5426     if (__loc_ == 0)
5427         __throw_runtime_error("time_put_byname"
5428                             " failed to construct for " + nm);
5429 }
5430
5431 __time_put::~__time_put()
5432 {
5433     if (__loc_ != _LIBCPP_GET_C_LOCALE)
5434         freelocale(__loc_);
5435 }
5436
5437 void
5438 __time_put::__do_put(char* __nb, char*& __ne, const tm* __tm,
5439                      char __fmt, char __mod) const
5440 {
5441     char fmt[] = {'%', __fmt, __mod, 0};
5442     if (__mod != 0)
5443         swap(fmt[1], fmt[2]);
5444     size_t n = strftime_l(__nb, countof(__nb, __ne), fmt, __tm, __loc_);
5445     __ne = __nb + n;
5446 }
5447
5448 void
5449 __time_put::__do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm,
5450                      char __fmt, char __mod) const
5451 {
5452     char __nar[100];
5453     char* __ne = __nar + 100;
5454     __do_put(__nar, __ne, __tm, __fmt, __mod);
5455     mbstate_t mb = {0};
5456     const char* __nb = __nar;
5457     size_t j = __libcpp_mbsrtowcs_l(__wb, &__nb, countof(__wb, __we), &mb, __loc_);
5458     if (j == size_t(-1))
5459         __throw_runtime_error("locale not supported");
5460     __we = __wb + j;
5461 }
5462
5463 // moneypunct_byname
5464
5465 template <class charT>
5466 static
5467 void
5468 __init_pat(money_base::pattern& pat, basic_string<charT>& __curr_symbol_,
5469            bool intl, char cs_precedes, char sep_by_space, char sign_posn,
5470            charT space_char)
5471 {
5472     const char sign = static_cast<char>(money_base::sign);
5473     const char space = static_cast<char>(money_base::space);
5474     const char none = static_cast<char>(money_base::none);
5475     const char symbol = static_cast<char>(money_base::symbol);
5476     const char value = static_cast<char>(money_base::value);
5477     const bool symbol_contains_sep = intl && __curr_symbol_.size() == 4;
5478
5479     // Comments on case branches reflect 'C11 7.11.2.1 The localeconv
5480     // function'. "Space between sign and symbol or value" means that
5481     // if the sign is adjacent to the symbol, there's a space between
5482     // them, and otherwise there's a space between the sign and value.
5483     //
5484     // C11's localeconv specifies that the fourth character of an
5485     // international curr_symbol is used to separate the sign and
5486     // value when sep_by_space says to do so. C++ can't represent
5487     // that, so we just use a space.  When sep_by_space says to
5488     // separate the symbol and value-or-sign with a space, we rearrange the
5489     // curr_symbol to put its spacing character on the correct side of
5490     // the symbol.
5491     //
5492     // We also need to avoid adding an extra space between the sign
5493     // and value when the currency symbol is suppressed (by not
5494     // setting showbase).  We match glibc's strfmon by interpreting
5495     // sep_by_space==1 as "omit the space when the currency symbol is
5496     // absent".
5497     //
5498     // Users who want to get this right should use ICU instead.
5499
5500     switch (cs_precedes)
5501     {
5502     case 0:  // value before curr_symbol
5503         if (symbol_contains_sep) {
5504             // Move the separator to before the symbol, to place it
5505             // between the value and symbol.
5506             rotate(__curr_symbol_.begin(), __curr_symbol_.begin() + 3,
5507                    __curr_symbol_.end());
5508         }
5509         switch (sign_posn)
5510         {
5511         case 0:  // Parentheses surround the quantity and currency symbol.
5512             pat.field[0] = sign;
5513             pat.field[1] = value;
5514             pat.field[2] = none;  // Any space appears in the symbol.
5515             pat.field[3] = symbol;
5516             switch (sep_by_space)
5517             {
5518             case 0:  // No space separates the currency symbol and value.
5519                 // This case may have changed between C99 and C11;
5520                 // assume the currency symbol matches the intention.
5521             case 2:  // Space between sign and currency or value.
5522                 // The "sign" is two parentheses, so no space here either.
5523                 return;
5524             case 1:  // Space between currency-and-sign or currency and value.
5525                 if (!symbol_contains_sep) {
5526                     // We insert the space into the symbol instead of
5527                     // setting pat.field[2]=space so that when
5528                     // showbase is not set, the space goes away too.
5529                     __curr_symbol_.insert(0, 1, space_char);
5530                 }
5531                 return;
5532             default:
5533                 break;
5534             }
5535             break;
5536         case 1:  // The sign string precedes the quantity and currency symbol.
5537             pat.field[0] = sign;
5538             pat.field[3] = symbol;
5539             switch (sep_by_space)
5540             {
5541             case 0:  // No space separates the currency symbol and value.
5542                 pat.field[1] = value;
5543                 pat.field[2] = none;
5544                 return;
5545             case 1:  // Space between currency-and-sign or currency and value.
5546                 pat.field[1] = value;
5547                 pat.field[2] = none;
5548                 if (!symbol_contains_sep) {
5549                     // We insert the space into the symbol instead of
5550                     // setting pat.field[2]=space so that when
5551                     // showbase is not set, the space goes away too.
5552                     __curr_symbol_.insert(0, 1, space_char);
5553                 }
5554                 return;
5555             case 2:  // Space between sign and currency or value.
5556                 pat.field[1] = space;
5557                 pat.field[2] = value;
5558                 if (symbol_contains_sep) {
5559                     // Remove the separator from the symbol, since it
5560                     // has already appeared after the sign.
5561                     __curr_symbol_.erase(__curr_symbol_.begin());
5562                 }
5563                 return;
5564             default:
5565                 break;
5566             }
5567             break;
5568         case 2:  // The sign string succeeds the quantity and currency symbol.
5569             pat.field[0] = value;
5570             pat.field[3] = sign;
5571             switch (sep_by_space)
5572             {
5573             case 0:  // No space separates the currency symbol and value.
5574                 pat.field[1] = none;
5575                 pat.field[2] = symbol;
5576                 return;
5577             case 1:  // Space between currency-and-sign or currency and value.
5578                 if (!symbol_contains_sep) {
5579                     // We insert the space into the symbol instead of
5580                     // setting pat.field[1]=space so that when
5581                     // showbase is not set, the space goes away too.
5582                     __curr_symbol_.insert(0, 1, space_char);
5583                 }
5584                 pat.field[1] = none;
5585                 pat.field[2] = symbol;
5586                 return;
5587             case 2:  // Space between sign and currency or value.
5588                 pat.field[1] = symbol;
5589                 pat.field[2] = space;
5590                 if (symbol_contains_sep) {
5591                     // Remove the separator from the symbol, since it
5592                     // should not be removed if showbase is absent.
5593                     __curr_symbol_.erase(__curr_symbol_.begin());
5594                 }
5595                 return;
5596             default:
5597                 break;
5598             }
5599             break;
5600         case 3:  // The sign string immediately precedes the currency symbol.
5601             pat.field[0] = value;
5602             pat.field[3] = symbol;
5603             switch (sep_by_space)
5604             {
5605             case 0:  // No space separates the currency symbol and value.
5606                 pat.field[1] = none;
5607                 pat.field[2] = sign;
5608                 return;
5609             case 1:  // Space between currency-and-sign or currency and value.
5610                 pat.field[1] = space;
5611                 pat.field[2] = sign;
5612                 if (symbol_contains_sep) {
5613                     // Remove the separator from the symbol, since it
5614                     // has already appeared before the sign.
5615                     __curr_symbol_.erase(__curr_symbol_.begin());
5616                 }
5617                 return;
5618             case 2:  // Space between sign and currency or value.
5619                 pat.field[1] = sign;
5620                 pat.field[2] = none;
5621                 if (!symbol_contains_sep) {
5622                     // We insert the space into the symbol instead of
5623                     // setting pat.field[2]=space so that when
5624                     // showbase is not set, the space goes away too.
5625                     __curr_symbol_.insert(0, 1, space_char);
5626                 }
5627                 return;
5628             default:
5629                 break;
5630             }
5631             break;
5632         case 4:  // The sign string immediately succeeds the currency symbol.
5633             pat.field[0] = value;
5634             pat.field[3] = sign;
5635             switch (sep_by_space)
5636             {
5637             case 0:  // No space separates the currency symbol and value.
5638                 pat.field[1] = none;
5639                 pat.field[2] = symbol;
5640                 return;
5641             case 1:  // Space between currency-and-sign or currency and value.
5642                 pat.field[1] = none;
5643                 pat.field[2] = symbol;
5644                 if (!symbol_contains_sep) {
5645                     // We insert the space into the symbol instead of
5646                     // setting pat.field[1]=space so that when
5647                     // showbase is not set, the space goes away too.
5648                     __curr_symbol_.insert(0, 1, space_char);
5649                 }
5650                 return;
5651             case 2:  // Space between sign and currency or value.
5652                 pat.field[1] = symbol;
5653                 pat.field[2] = space;
5654                 if (symbol_contains_sep) {
5655                     // Remove the separator from the symbol, since it
5656                     // should not disappear when showbase is absent.
5657                     __curr_symbol_.erase(__curr_symbol_.begin());
5658                 }
5659                 return;
5660             default:
5661                 break;
5662             }
5663             break;
5664         default:
5665             break;
5666         }
5667         break;
5668     case 1:  // curr_symbol before value
5669         switch (sign_posn)
5670         {
5671         case 0:  // Parentheses surround the quantity and currency symbol.
5672             pat.field[0] = sign;
5673             pat.field[1] = symbol;
5674             pat.field[2] = none;  // Any space appears in the symbol.
5675             pat.field[3] = value;
5676             switch (sep_by_space)
5677             {
5678             case 0:  // No space separates the currency symbol and value.
5679                 // This case may have changed between C99 and C11;
5680                 // assume the currency symbol matches the intention.
5681             case 2:  // Space between sign and currency or value.
5682                 // The "sign" is two parentheses, so no space here either.
5683                 return;
5684             case 1:  // Space between currency-and-sign or currency and value.
5685                 if (!symbol_contains_sep) {
5686                     // We insert the space into the symbol instead of
5687                     // setting pat.field[2]=space so that when
5688                     // showbase is not set, the space goes away too.
5689                     __curr_symbol_.insert(0, 1, space_char);
5690                 }
5691                 return;
5692             default:
5693                 break;
5694             }
5695             break;
5696         case 1:  // The sign string precedes the quantity and currency symbol.
5697             pat.field[0] = sign;
5698             pat.field[3] = value;
5699             switch (sep_by_space)
5700             {
5701             case 0:  // No space separates the currency symbol and value.
5702                 pat.field[1] = symbol;
5703                 pat.field[2] = none;
5704                 return;
5705             case 1:  // Space between currency-and-sign or currency and value.
5706                 pat.field[1] = symbol;
5707                 pat.field[2] = none;
5708                 if (!symbol_contains_sep) {
5709                     // We insert the space into the symbol instead of
5710                     // setting pat.field[2]=space so that when
5711                     // showbase is not set, the space goes away too.
5712                     __curr_symbol_.push_back(space_char);
5713                 }
5714                 return;
5715             case 2:  // Space between sign and currency or value.
5716                 pat.field[1] = space;
5717                 pat.field[2] = symbol;
5718                 if (symbol_contains_sep) {
5719                     // Remove the separator from the symbol, since it
5720                     // has already appeared after the sign.
5721                     __curr_symbol_.pop_back();
5722                 }
5723                 return;
5724             default:
5725                 break;
5726             }
5727             break;
5728         case 2:  // The sign string succeeds the quantity and currency symbol.
5729             pat.field[0] = symbol;
5730             pat.field[3] = sign;
5731             switch (sep_by_space)
5732             {
5733             case 0:  // No space separates the currency symbol and value.
5734                 pat.field[1] = none;
5735                 pat.field[2] = value;
5736                 return;
5737             case 1:  // Space between currency-and-sign or currency and value.
5738                 pat.field[1] = none;
5739                 pat.field[2] = value;
5740                 if (!symbol_contains_sep) {
5741                     // We insert the space into the symbol instead of
5742                     // setting pat.field[1]=space so that when
5743                     // showbase is not set, the space goes away too.
5744                     __curr_symbol_.push_back(space_char);
5745                 }
5746                 return;
5747             case 2:  // Space between sign and currency or value.
5748                 pat.field[1] = value;
5749                 pat.field[2] = space;
5750                 if (symbol_contains_sep) {
5751                     // Remove the separator from the symbol, since it
5752                     // will appear before the sign.
5753                     __curr_symbol_.pop_back();
5754                 }
5755                 return;
5756             default:
5757                 break;
5758             }
5759             break;
5760         case 3:  // The sign string immediately precedes the currency symbol.
5761             pat.field[0] = sign;
5762             pat.field[3] = value;
5763             switch (sep_by_space)
5764             {
5765             case 0:  // No space separates the currency symbol and value.
5766                 pat.field[1] = symbol;
5767                 pat.field[2] = none;
5768                 return;
5769             case 1:  // Space between currency-and-sign or currency and value.
5770                 pat.field[1] = symbol;
5771                 pat.field[2] = none;
5772                 if (!symbol_contains_sep) {
5773                     // We insert the space into the symbol instead of
5774                     // setting pat.field[2]=space so that when
5775                     // showbase is not set, the space goes away too.
5776                     __curr_symbol_.push_back(space_char);
5777                 }
5778                 return;
5779             case 2:  // Space between sign and currency or value.
5780                 pat.field[1] = space;
5781                 pat.field[2] = symbol;
5782                 if (symbol_contains_sep) {
5783                     // Remove the separator from the symbol, since it
5784                     // has already appeared after the sign.
5785                     __curr_symbol_.pop_back();
5786                 }
5787                 return;
5788             default:
5789                 break;
5790             }
5791             break;
5792         case 4:  // The sign string immediately succeeds the currency symbol.
5793             pat.field[0] = symbol;
5794             pat.field[3] = value;
5795             switch (sep_by_space)
5796             {
5797             case 0:  // No space separates the currency symbol and value.
5798                 pat.field[1] = sign;
5799                 pat.field[2] = none;
5800                 return;
5801             case 1:  // Space between currency-and-sign or currency and value.
5802                 pat.field[1] = sign;
5803                 pat.field[2] = space;
5804                 if (symbol_contains_sep) {
5805                     // Remove the separator from the symbol, since it
5806                     // should not disappear when showbase is absent.
5807                     __curr_symbol_.pop_back();
5808                 }
5809                 return;
5810             case 2:  // Space between sign and currency or value.
5811                 pat.field[1] = none;
5812                 pat.field[2] = sign;
5813                 if (!symbol_contains_sep) {
5814                     // We insert the space into the symbol instead of
5815                     // setting pat.field[1]=space so that when
5816                     // showbase is not set, the space goes away too.
5817                     __curr_symbol_.push_back(space_char);
5818                 }
5819                 return;
5820            default:
5821                 break;
5822             }
5823             break;
5824         default:
5825             break;
5826         }
5827         break;
5828     default:
5829         break;
5830     }
5831     pat.field[0] = symbol;
5832     pat.field[1] = sign;
5833     pat.field[2] = none;
5834     pat.field[3] = value;
5835 }
5836
5837 template<>
5838 void
5839 moneypunct_byname<char, false>::init(const char* nm)
5840 {
5841     typedef moneypunct<char, false> base;
5842     __libcpp_unique_locale loc(nm);
5843     if (!loc)
5844         __throw_runtime_error("moneypunct_byname"
5845                             " failed to construct for " + string(nm));
5846
5847     lconv* lc = __libcpp_localeconv_l(loc.get());
5848     if (!checked_string_to_char_convert(__decimal_point_,
5849                                         lc->mon_decimal_point,
5850                                         loc.get()))
5851       __decimal_point_ = base::do_decimal_point();
5852     if (!checked_string_to_char_convert(__thousands_sep_,
5853                                         lc->mon_thousands_sep,
5854                                         loc.get()))
5855       __thousands_sep_ = base::do_thousands_sep();
5856
5857     __grouping_ = lc->mon_grouping;
5858     __curr_symbol_ = lc->currency_symbol;
5859     if (lc->frac_digits != CHAR_MAX)
5860         __frac_digits_ = lc->frac_digits;
5861     else
5862         __frac_digits_ = base::do_frac_digits();
5863     if (lc->p_sign_posn == 0)
5864         __positive_sign_ = "()";
5865     else
5866         __positive_sign_ = lc->positive_sign;
5867     if (lc->n_sign_posn == 0)
5868         __negative_sign_ = "()";
5869     else
5870         __negative_sign_ = lc->negative_sign;
5871     // Assume the positive and negative formats will want spaces in
5872     // the same places in curr_symbol since there's no way to
5873     // represent anything else.
5874     string_type __dummy_curr_symbol = __curr_symbol_;
5875     __init_pat(__pos_format_, __dummy_curr_symbol, false,
5876                lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
5877     __init_pat(__neg_format_, __curr_symbol_, false,
5878                lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
5879 }
5880
5881 template<>
5882 void
5883 moneypunct_byname<char, true>::init(const char* nm)
5884 {
5885     typedef moneypunct<char, true> base;
5886     __libcpp_unique_locale loc(nm);
5887     if (!loc)
5888         __throw_runtime_error("moneypunct_byname"
5889                             " failed to construct for " + string(nm));
5890
5891     lconv* lc = __libcpp_localeconv_l(loc.get());
5892     if (!checked_string_to_char_convert(__decimal_point_,
5893                                         lc->mon_decimal_point,
5894                                         loc.get()))
5895       __decimal_point_ = base::do_decimal_point();
5896     if (!checked_string_to_char_convert(__thousands_sep_,
5897                                         lc->mon_thousands_sep,
5898                                         loc.get()))
5899       __thousands_sep_ = base::do_thousands_sep();
5900     __grouping_ = lc->mon_grouping;
5901     __curr_symbol_ = lc->int_curr_symbol;
5902     if (lc->int_frac_digits != CHAR_MAX)
5903         __frac_digits_ = lc->int_frac_digits;
5904     else
5905         __frac_digits_ = base::do_frac_digits();
5906 #if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
5907     if (lc->p_sign_posn == 0)
5908 #else // _LIBCPP_MSVCRT
5909     if (lc->int_p_sign_posn == 0)
5910 #endif // !_LIBCPP_MSVCRT
5911         __positive_sign_ = "()";
5912     else
5913         __positive_sign_ = lc->positive_sign;
5914 #if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
5915     if(lc->n_sign_posn == 0)
5916 #else // _LIBCPP_MSVCRT
5917     if (lc->int_n_sign_posn == 0)
5918 #endif // !_LIBCPP_MSVCRT
5919         __negative_sign_ = "()";
5920     else
5921         __negative_sign_ = lc->negative_sign;
5922     // Assume the positive and negative formats will want spaces in
5923     // the same places in curr_symbol since there's no way to
5924     // represent anything else.
5925     string_type __dummy_curr_symbol = __curr_symbol_;
5926 #if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
5927     __init_pat(__pos_format_, __dummy_curr_symbol, true,
5928                lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
5929     __init_pat(__neg_format_, __curr_symbol_, true,
5930                lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
5931 #else // _LIBCPP_MSVCRT
5932     __init_pat(__pos_format_, __dummy_curr_symbol, true,
5933                lc->int_p_cs_precedes, lc->int_p_sep_by_space,
5934                lc->int_p_sign_posn, ' ');
5935     __init_pat(__neg_format_, __curr_symbol_, true,
5936                lc->int_n_cs_precedes, lc->int_n_sep_by_space,
5937                lc->int_n_sign_posn, ' ');
5938 #endif // !_LIBCPP_MSVCRT
5939 }
5940
5941 template<>
5942 void
5943 moneypunct_byname<wchar_t, false>::init(const char* nm)
5944 {
5945     typedef moneypunct<wchar_t, false> base;
5946     __libcpp_unique_locale loc(nm);
5947     if (!loc)
5948         __throw_runtime_error("moneypunct_byname"
5949                             " failed to construct for " + string(nm));
5950     lconv* lc = __libcpp_localeconv_l(loc.get());
5951     if (!checked_string_to_wchar_convert(__decimal_point_,
5952                                          lc->mon_decimal_point,
5953                                          loc.get()))
5954       __decimal_point_ = base::do_decimal_point();
5955     if (!checked_string_to_wchar_convert(__thousands_sep_,
5956                                          lc->mon_thousands_sep,
5957                                          loc.get()))
5958       __thousands_sep_ = base::do_thousands_sep();
5959     __grouping_ = lc->mon_grouping;
5960     wchar_t wbuf[100];
5961     mbstate_t mb = {0};
5962     const char* bb = lc->currency_symbol;
5963     size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
5964     if (j == size_t(-1))
5965         __throw_runtime_error("locale not supported");
5966     wchar_t* wbe = wbuf + j;
5967     __curr_symbol_.assign(wbuf, wbe);
5968     if (lc->frac_digits != CHAR_MAX)
5969         __frac_digits_ = lc->frac_digits;
5970     else
5971         __frac_digits_ = base::do_frac_digits();
5972     if (lc->p_sign_posn == 0)
5973         __positive_sign_ = L"()";
5974     else
5975     {
5976         mb = mbstate_t();
5977         bb = lc->positive_sign;
5978         j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
5979         if (j == size_t(-1))
5980             __throw_runtime_error("locale not supported");
5981         wbe = wbuf + j;
5982         __positive_sign_.assign(wbuf, wbe);
5983     }
5984     if (lc->n_sign_posn == 0)
5985         __negative_sign_ = L"()";
5986     else
5987     {
5988         mb = mbstate_t();
5989         bb = lc->negative_sign;
5990         j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
5991         if (j == size_t(-1))
5992             __throw_runtime_error("locale not supported");
5993         wbe = wbuf + j;
5994         __negative_sign_.assign(wbuf, wbe);
5995     }
5996     // Assume the positive and negative formats will want spaces in
5997     // the same places in curr_symbol since there's no way to
5998     // represent anything else.
5999     string_type __dummy_curr_symbol = __curr_symbol_;
6000     __init_pat(__pos_format_, __dummy_curr_symbol, false,
6001                lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
6002     __init_pat(__neg_format_, __curr_symbol_, false,
6003                lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
6004 }
6005
6006 template<>
6007 void
6008 moneypunct_byname<wchar_t, true>::init(const char* nm)
6009 {
6010     typedef moneypunct<wchar_t, true> base;
6011     __libcpp_unique_locale loc(nm);
6012     if (!loc)
6013         __throw_runtime_error("moneypunct_byname"
6014                             " failed to construct for " + string(nm));
6015
6016     lconv* lc = __libcpp_localeconv_l(loc.get());
6017     if (!checked_string_to_wchar_convert(__decimal_point_,
6018                                          lc->mon_decimal_point,
6019                                          loc.get()))
6020       __decimal_point_ = base::do_decimal_point();
6021     if (!checked_string_to_wchar_convert(__thousands_sep_,
6022                                          lc->mon_thousands_sep,
6023                                          loc.get()))
6024       __thousands_sep_ = base::do_thousands_sep();
6025     __grouping_ = lc->mon_grouping;
6026     wchar_t wbuf[100];
6027     mbstate_t mb = {0};
6028     const char* bb = lc->int_curr_symbol;
6029     size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
6030     if (j == size_t(-1))
6031         __throw_runtime_error("locale not supported");
6032     wchar_t* wbe = wbuf + j;
6033     __curr_symbol_.assign(wbuf, wbe);
6034     if (lc->int_frac_digits != CHAR_MAX)
6035         __frac_digits_ = lc->int_frac_digits;
6036     else
6037         __frac_digits_ = base::do_frac_digits();
6038 #if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
6039     if (lc->p_sign_posn == 0)
6040 #else // _LIBCPP_MSVCRT
6041     if (lc->int_p_sign_posn == 0)
6042 #endif // !_LIBCPP_MSVCRT
6043         __positive_sign_ = L"()";
6044     else
6045     {
6046         mb = mbstate_t();
6047         bb = lc->positive_sign;
6048         j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
6049         if (j == size_t(-1))
6050             __throw_runtime_error("locale not supported");
6051         wbe = wbuf + j;
6052         __positive_sign_.assign(wbuf, wbe);
6053     }
6054 #if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
6055     if (lc->n_sign_posn == 0)
6056 #else // _LIBCPP_MSVCRT
6057     if (lc->int_n_sign_posn == 0)
6058 #endif // !_LIBCPP_MSVCRT
6059         __negative_sign_ = L"()";
6060     else
6061     {
6062         mb = mbstate_t();
6063         bb = lc->negative_sign;
6064         j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
6065         if (j == size_t(-1))
6066             __throw_runtime_error("locale not supported");
6067         wbe = wbuf + j;
6068         __negative_sign_.assign(wbuf, wbe);
6069     }
6070     // Assume the positive and negative formats will want spaces in
6071     // the same places in curr_symbol since there's no way to
6072     // represent anything else.
6073     string_type __dummy_curr_symbol = __curr_symbol_;
6074 #if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
6075     __init_pat(__pos_format_, __dummy_curr_symbol, true,
6076                lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
6077     __init_pat(__neg_format_, __curr_symbol_, true,
6078                lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
6079 #else // _LIBCPP_MSVCRT
6080     __init_pat(__pos_format_, __dummy_curr_symbol, true,
6081                lc->int_p_cs_precedes, lc->int_p_sep_by_space,
6082                lc->int_p_sign_posn, L' ');
6083     __init_pat(__neg_format_, __curr_symbol_, true,
6084                lc->int_n_cs_precedes, lc->int_n_sep_by_space,
6085                lc->int_n_sign_posn, L' ');
6086 #endif // !_LIBCPP_MSVCRT
6087 }
6088
6089 void __do_nothing(void*) {}
6090
6091 void __throw_runtime_error(const char* msg)
6092 {
6093 #ifndef _LIBCPP_NO_EXCEPTIONS
6094     throw runtime_error(msg);
6095 #else
6096     (void)msg;
6097     _VSTD::abort();
6098 #endif
6099 }
6100
6101 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>;
6102 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<wchar_t>;
6103
6104 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<char>;
6105 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<wchar_t>;
6106
6107 template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<char>;
6108 template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<wchar_t>;
6109
6110 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<char>;
6111 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<wchar_t>;
6112
6113 template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<char>;
6114 template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<wchar_t>;
6115
6116 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<char>;
6117 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<wchar_t>;
6118
6119 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<char>;
6120 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<wchar_t>;
6121
6122 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<char>;
6123 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<wchar_t>;
6124
6125 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<char>;
6126 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<wchar_t>;
6127
6128 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, false>;
6129 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, true>;
6130 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, false>;
6131 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, true>;
6132
6133 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, false>;
6134 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, true>;
6135 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, false>;
6136 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, true>;
6137
6138 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<char>;
6139 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<wchar_t>;
6140
6141 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<char>;
6142 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<wchar_t>;
6143
6144 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<char>;
6145 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<wchar_t>;
6146
6147 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<char>;
6148 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<wchar_t>;
6149
6150 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<char>;
6151 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<wchar_t>;
6152
6153 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<char>;
6154 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<wchar_t>;
6155
6156 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char, char, mbstate_t>;
6157 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<wchar_t, char, mbstate_t>;
6158 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char, mbstate_t>;
6159 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char, mbstate_t>;
6160
6161 _LIBCPP_END_NAMESPACE_STD