libcxx/include/locale

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef _LIBCPP_LOCALE
  11 #define _LIBCPP_LOCALE
  12
  13 /*
  14     locale synopsis
  15
  16 namespace std
  17 {
  18
  19 class locale
  20 {
  21 public:
  22     // types:
  23     class facet;
  24     class id;
  25
  26     typedef int category;
  27     static const category // values assigned here are for exposition only
  28         none     = 0x000,
  29         collate  = 0x010,
  30         ctype    = 0x020,
  31         monetary = 0x040,
  32         numeric  = 0x080,
  33         time     = 0x100,
  34         messages = 0x200,
  35         all = collate | ctype | monetary | numeric | time | messages;
  36
  37     // construct/copy/destroy:
  38     locale() noexcept;
  39     locale(const locale& other) noexcept;
  40     explicit locale(const char* std_name);
  41     explicit locale(const string& std_name);
  42     locale(const locale& other, const char* std_name, category);
  43     locale(const locale& other, const string& std_name, category);
  44     template <class Facet> locale(const locale& other, Facet* f);
  45     locale(const locale& other, const locale& one, category);
  46
  47     ~locale(); // not virtual
  48
  49     const locale& operator=(const locale& other) noexcept;
  50
  51     template <class Facet> locale combine(const locale& other) const;
  52
  53     // locale operations:
  54     basic_string<char> name() const;
  55     bool operator==(const locale& other) const;
  56     bool operator!=(const locale& other) const;                              // removed C++20
  57     template <class charT, class Traits, class Allocator>
  58       bool operator()(const basic_string<charT,Traits,Allocator>& s1,
  59                       const basic_string<charT,Traits,Allocator>& s2) const;
  60
  61     // global locale objects:
  62     static locale global(const locale&);
  63     static const locale& classic();
  64 };
  65
  66 template <class Facet> const Facet& use_facet(const locale&);
  67 template <class Facet> bool has_facet(const locale&) noexcept;
  68
  69 // 22.3.3, convenience interfaces:
  70 template <class charT> bool isspace (charT c, const locale& loc);
  71 template <class charT> bool isprint (charT c, const locale& loc);
  72 template <class charT> bool iscntrl (charT c, const locale& loc);
  73 template <class charT> bool isupper (charT c, const locale& loc);
  74 template <class charT> bool islower (charT c, const locale& loc);
  75 template <class charT> bool isalpha (charT c, const locale& loc);
  76 template <class charT> bool isdigit (charT c, const locale& loc);
  77 template <class charT> bool ispunct (charT c, const locale& loc);
  78 template <class charT> bool isxdigit(charT c, const locale& loc);
  79 template <class charT> bool isalnum (charT c, const locale& loc);
  80 template <class charT> bool isgraph (charT c, const locale& loc);
  81 template <class charT> charT toupper(charT c, const locale& loc);
  82 template <class charT> charT tolower(charT c, const locale& loc);
  83
  84 template<class Codecvt, class Elem = wchar_t,
  85          class Wide_alloc = allocator<Elem>,
  86          class Byte_alloc = allocator<char>>
  87 class wstring_convert                                      // Removed in C++26
  88 {
  89 public:
  90     typedef basic_string<char, char_traits<char>, Byte_alloc> byte_string;
  91     typedef basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
  92     typedef typename Codecvt::state_type                      state_type;
  93     typedef typename wide_string::traits_type::int_type       int_type;
  94
  95     wstring_convert(Codecvt* pcvt = new Codecvt);          // before C++14
  96     explicit wstring_convert(Codecvt* pcvt = new Codecvt); // before C++20
  97     wstring_convert() : wstring_convert(new Codecvt) {}    // C++20
  98     explicit wstring_convert(Codecvt* pcvt);               // C++20
  99
 100     wstring_convert(Codecvt* pcvt, state_type state);
 101     explicit wstring_convert(const byte_string& byte_err,           // explicit in C++14
 102                     const wide_string& wide_err = wide_string());
 103     wstring_convert(const wstring_convert&) = delete;               // C++14
 104     wstring_convert & operator=(const wstring_convert &) = delete;  // C++14
 105     ~wstring_convert();
 106
 107     wide_string from_bytes(char byte);
 108     wide_string from_bytes(const char* ptr);
 109     wide_string from_bytes(const byte_string& str);
 110     wide_string from_bytes(const char* first, const char* last);
 111
 112     byte_string to_bytes(Elem wchar);
 113     byte_string to_bytes(const Elem* wptr);
 114     byte_string to_bytes(const wide_string& wstr);
 115     byte_string to_bytes(const Elem* first, const Elem* last);
 116
 117     size_t converted() const; // noexcept in C++14
 118     state_type state() const;
 119 };
 120
 121 template <class Codecvt, class Elem = wchar_t, class Tr = char_traits<Elem>>
 122 class wbuffer_convert                                               // Removed in C++26
 123     : public basic_streambuf<Elem, Tr>
 124 {
 125 public:
 126     typedef typename Tr::state_type state_type;
 127
 128     wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt,
 129                     state_type state = state_type());          // before C++14
 130     explicit wbuffer_convert(streambuf* bytebuf = nullptr, Codecvt* pcvt = new Codecvt,
 131                             state_type state = state_type()); // before C++20
 132     wbuffer_convert() : wbuffer_convert(nullptr) {} // C++20
 133     explicit wbuffer_convert(streambuf* bytebuf, Codecvt* pcvt = new Codecvt,
 134                             state_type state = state_type()); // C++20
 135
 136     wbuffer_convert(const wbuffer_convert&) = delete;               // C++14
 137     wbuffer_convert & operator=(const wbuffer_convert &) = delete;  // C++14
 138     ~wbuffer_convert();                                             // C++14
 139
 140     streambuf* rdbuf() const;
 141     streambuf* rdbuf(streambuf* bytebuf);
 142
 143     state_type state() const;
 144 };
 145
 146 // 22.4.1 and 22.4.1.3, ctype:
 147 class ctype_base;
 148 template <class charT> class ctype;
 149 template <> class ctype<char>; // specialization
 150 template <class charT> class ctype_byname;
 151 template <> class ctype_byname<char>; // specialization
 152
 153 class codecvt_base;
 154 template <class internT, class externT, class stateT> class codecvt;
 155 template <class internT, class externT, class stateT> class codecvt_byname;
 156
 157 // 22.4.2 and 22.4.3, numeric:
 158 template <class charT, class InputIterator> class num_get;
 159 template <class charT, class OutputIterator> class num_put;
 160 template <class charT> class numpunct;
 161 template <class charT> class numpunct_byname;
 162
 163 // 22.4.4, col lation:
 164 template <class charT> class collate;
 165 template <class charT> class collate_byname;
 166
 167 // 22.4.5, date and time:
 168 class time_base;
 169 template <class charT, class InputIterator> class time_get;
 170 template <class charT, class InputIterator> class time_get_byname;
 171 template <class charT, class OutputIterator> class time_put;
 172 template <class charT, class OutputIterator> class time_put_byname;
 173
 174 // 22.4.6, money:
 175 class money_base;
 176 template <class charT, class InputIterator> class money_get;
 177 template <class charT, class OutputIterator> class money_put;
 178 template <class charT, bool Intl> class moneypunct;
 179 template <class charT, bool Intl> class moneypunct_byname;
 180
 181 // 22.4.7, message retrieval:
 182 class messages_base;
 183 template <class charT> class messages;
 184 template <class charT> class messages_byname;
 185
 186 }  // std
 187
 188 */
 189
 190 #include <__config>
 191
 192 #if _LIBCPP_HAS_LOCALIZATION
 193
 194 #  include <__algorithm/copy.h>
 195 #  include <__algorithm/equal.h>
 196 #  include <__algorithm/find.h>
 197 #  include <__algorithm/max.h>
 198 #  include <__algorithm/reverse.h>
 199 #  include <__algorithm/unwrap_iter.h>
 200 #  include <__assert>
 201 #  include <__iterator/access.h>
 202 #  include <__iterator/back_insert_iterator.h>
 203 #  include <__iterator/istreambuf_iterator.h>
 204 #  include <__iterator/ostreambuf_iterator.h>
 205 #  include <__locale>
 206 #  include <__locale_dir/pad_and_output.h>
 207 #  include <__memory/unique_ptr.h>
 208 #  include <__type_traits/make_unsigned.h>
 209 #  include <cerrno>
 210 #  include <cstdio>
 211 #  include <cstdlib>
 212 #  include <ctime>
 213 #  include <ios>
 214 #  include <limits>
 215 #  include <new>
 216 #  include <streambuf>
 217 #  include <version>
 218
 219 // TODO: Properly qualify calls now that __bsd_locale_defaults.h defines functions instead of macros
 220 // NOLINTBEGIN(libcpp-robust-against-adl)
 221
 222 #  if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 223 // Most unix variants have catopen.  These are the specific ones that don't.
 224 #    if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION) && !defined(__EMSCRIPTEN__)
 225 #      define _LIBCPP_HAS_CATOPEN 1
 226 #      include <nl_types.h>
 227 #    else
 228 #      define _LIBCPP_HAS_CATOPEN 0
 229 #    endif
 230 #  else
 231 #    define _LIBCPP_HAS_CATOPEN 0
 232 #  endif
 233
 234 #  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 235 #    pragma GCC system_header
 236 #  endif
 237
 238 _LIBCPP_PUSH_MACROS
 239 #  include <__undef_macros>
 240
 241 _LIBCPP_BEGIN_NAMESPACE_STD
 242
 243 #  if defined(__APPLE__) || defined(__FreeBSD__)
 244 #    define _LIBCPP_GET_C_LOCALE 0
 245 #  elif defined(__NetBSD__)
 246 #    define _LIBCPP_GET_C_LOCALE LC_C_LOCALE
 247 #  else
 248 #    define _LIBCPP_GET_C_LOCALE __cloc()
 249 // Get the C locale object
 250 _LIBCPP_EXPORTED_FROM_ABI __locale::__locale_t __cloc();
 251 #    define __cloc_defined
 252 #  endif
 253
 254 // __scan_keyword
 255 // Scans [__b, __e) until a match is found in the basic_strings range
 256 //  [__kb, __ke) or until it can be shown that there is no match in [__kb, __ke).
 257 //  __b will be incremented (visibly), consuming CharT until a match is found
 258 //  or proved to not exist.  A keyword may be "", in which will match anything.
 259 //  If one keyword is a prefix of another, and the next CharT in the input
 260 //  might match another keyword, the algorithm will attempt to find the longest
 261 //  matching keyword.  If the longer matching keyword ends up not matching, then
 262 //  no keyword match is found.  If no keyword match is found, __ke is returned
 263 //  and failbit is set in __err.
 264 //  Else an iterator pointing to the matching keyword is found.  If more than
 265 //  one keyword matches, an iterator to the first matching keyword is returned.
 266 //  If on exit __b == __e, eofbit is set in __err.  If __case_sensitive is false,
 267 //  __ct is used to force to lower case before comparing characters.
 268 //  Examples:
 269 //  Keywords:  "a", "abb"
 270 //  If the input is "a", the first keyword matches and eofbit is set.
 271 //  If the input is "abc", no match is found and "ab" are consumed.
 272 template <class _InputIterator, class _ForwardIterator, class _Ctype>
 273 _LIBCPP_HIDE_FROM_ABI _ForwardIterator __scan_keyword(
 274     _InputIterator& __b,
 275     _InputIterator __e,
 276     _ForwardIterator __kb,
 277     _ForwardIterator __ke,
 278     const _Ctype& __ct,
 279     ios_base::iostate& __err,
 280     bool __case_sensitive = true) {
 281   typedef typename iterator_traits<_InputIterator>::value_type _CharT;
 282   size_t __nkw                       = static_cast<size_t>(std::distance(__kb, __ke));
 283   const unsigned char __doesnt_match = '\0';
 284   const unsigned char __might_match  = '\1';
 285   const unsigned char __does_match   = '\2';
 286   unsigned char __statbuf[100];
 287   unsigned char* __status = __statbuf;
 288   unique_ptr<unsigned char, void (*)(void*)> __stat_hold(nullptr, free);
 289   if (__nkw > sizeof(__statbuf)) {
 290     __status = (unsigned char*)malloc(__nkw);
 291     if (__status == nullptr)
 292       __throw_bad_alloc();
 293     __stat_hold.reset(__status);
 294   }
 295   size_t __n_might_match = __nkw; // At this point, any keyword might match
 296   size_t __n_does_match  = 0;     // but none of them definitely do
 297   // Initialize all statuses to __might_match, except for "" keywords are __does_match
 298   unsigned char* __st = __status;
 299   for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void)++__st) {
 300     if (!__ky->empty())
 301       *__st = __might_match;
 302     else {
 303       *__st = __does_match;
 304       --__n_might_match;
 305       ++__n_does_match;
 306     }
 307   }
 308   // While there might be a match, test keywords against the next CharT
 309   for (size_t __indx = 0; __b != __e && __n_might_match > 0; ++__indx) {
 310     // Peek at the next CharT but don't consume it
 311     _CharT __c = *__b;
 312     if (!__case_sensitive)
 313       __c = __ct.toupper(__c);
 314     bool __consume = false;
 315     // For each keyword which might match, see if the __indx character is __c
 316     // If a match if found, consume __c
 317     // If a match is found, and that is the last character in the keyword,
 318     //    then that keyword matches.
 319     // If the keyword doesn't match this character, then change the keyword
 320     //    to doesn't match
 321     __st = __status;
 322     for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void)++__st) {
 323       if (*__st == __might_match) {
 324         _CharT __kc = (*__ky)[__indx];
 325         if (!__case_sensitive)
 326           __kc = __ct.toupper(__kc);
 327         if (__c == __kc) {
 328           __consume = true;
 329           if (__ky->size() == __indx + 1) {
 330             *__st = __does_match;
 331             --__n_might_match;
 332             ++__n_does_match;
 333           }
 334         } else {
 335           *__st = __doesnt_match;
 336           --__n_might_match;
 337         }
 338       }
 339     }
 340     // consume if we matched a character
 341     if (__consume) {
 342       ++__b;
 343       // If we consumed a character and there might be a matched keyword that
 344       //   was marked matched on a previous iteration, then such keywords
 345       //   which are now marked as not matching.
 346       if (__n_might_match + __n_does_match > 1) {
 347         __st = __status;
 348         for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void)++__st) {
 349           if (*__st == __does_match && __ky->size() != __indx + 1) {
 350             *__st = __doesnt_match;
 351             --__n_does_match;
 352           }
 353         }
 354       }
 355     }
 356   }
 357   // We've exited the loop because we hit eof and/or we have no more "might matches".
 358   if (__b == __e)
 359     __err |= ios_base::eofbit;
 360   // Return the first matching result
 361   for (__st = __status; __kb != __ke; ++__kb, (void)++__st)
 362     if (*__st == __does_match)
 363       break;
 364   if (__kb == __ke)
 365     __err |= ios_base::failbit;
 366   return __kb;
 367 }
 368
 369 struct _LIBCPP_EXPORTED_FROM_ABI __num_get_base {
 370   static const int __num_get_buf_sz = 40;
 371
 372   static int __get_base(ios_base&);
 373   static const char __src[33]; // "0123456789abcdefABCDEFxX+-pPiInN"
 374   // count of leading characters in __src used for parsing integers ("012..X+-")
 375   static const size_t __int_chr_cnt = 26;
 376   // count of leading characters in __src used for parsing floating-point values ("012..-pP")
 377   static const size_t __fp_chr_cnt = 28;
 378 };
 379
 380 _LIBCPP_EXPORTED_FROM_ABI void
 381 __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end, ios_base::iostate& __err);
 382
 383 template <class _CharT>
 384 struct __num_get : protected __num_get_base {
 385   static string __stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point, _CharT& __thousands_sep);
 386
 387   static int __stage2_float_loop(
 388       _CharT __ct,
 389       bool& __in_units,
 390       char& __exp,
 391       char* __a,
 392       char*& __a_end,
 393       _CharT __decimal_point,
 394       _CharT __thousands_sep,
 395       const string& __grouping,
 396       unsigned* __g,
 397       unsigned*& __g_end,
 398       unsigned& __dc,
 399       _CharT* __atoms);
 400 #  ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
 401   static string __stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep);
 402   static int __stage2_int_loop(
 403       _CharT __ct,
 404       int __base,
 405       char* __a,
 406       char*& __a_end,
 407       unsigned& __dc,
 408       _CharT __thousands_sep,
 409       const string& __grouping,
 410       unsigned* __g,
 411       unsigned*& __g_end,
 412       _CharT* __atoms);
 413
 414 #  else
 415   static string __stage2_int_prep(ios_base& __iob, _CharT& __thousands_sep) {
 416     locale __loc                 = __iob.getloc();
 417     const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
 418     __thousands_sep              = __np.thousands_sep();
 419     return __np.grouping();
 420   }
 421
 422   const _CharT* __do_widen(ios_base& __iob, _CharT* __atoms) const { return __do_widen_p(__iob, __atoms); }
 423
 424   static int __stage2_int_loop(
 425       _CharT __ct,
 426       int __base,
 427       char* __a,
 428       char*& __a_end,
 429       unsigned& __dc,
 430       _CharT __thousands_sep,
 431       const string& __grouping,
 432       unsigned* __g,
 433       unsigned*& __g_end,
 434       const _CharT* __atoms);
 435
 436 private:
 437   template <typename _Tp>
 438   const _Tp* __do_widen_p(ios_base& __iob, _Tp* __atoms) const {
 439     locale __loc = __iob.getloc();
 440     use_facet<ctype<_Tp> >(__loc).widen(__src, __src + __int_chr_cnt, __atoms);
 441     return __atoms;
 442   }
 443
 444   const char* __do_widen_p(ios_base& __iob, char* __atoms) const {
 445     (void)__iob;
 446     (void)__atoms;
 447     return __src;
 448   }
 449 #  endif
 450 };
 451
 452 #  ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
 453 template <class _CharT>
 454 string __num_get<_CharT>::__stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep) {
 455   locale __loc = __iob.getloc();
 456   std::use_facet<ctype<_CharT> >(__loc).widen(__src, __src + __int_chr_cnt, __atoms);
 457   const numpunct<_CharT>& __np = std::use_facet<numpunct<_CharT> >(__loc);
 458   __thousands_sep              = __np.thousands_sep();
 459   return __np.grouping();
 460 }
 461 #  endif
 462
 463 template <class _CharT>
 464 string __num_get<_CharT>::__stage2_float_prep(
 465     ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point, _CharT& __thousands_sep) {
 466   locale __loc = __iob.getloc();
 467   std::use_facet<ctype<_CharT> >(__loc).widen(__src, __src + __fp_chr_cnt, __atoms);
 468   const numpunct<_CharT>& __np = std::use_facet<numpunct<_CharT> >(__loc);
 469   __decimal_point              = __np.decimal_point();
 470   __thousands_sep              = __np.thousands_sep();
 471   return __np.grouping();
 472 }
 473
 474 template <class _CharT>
 475 int
 476 #  ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
 477 __num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
 478                   unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
 479                   unsigned* __g, unsigned*& __g_end, _CharT* __atoms)
 480 #  else
 481 __num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
 482                   unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
 483                   unsigned* __g, unsigned*& __g_end, const _CharT* __atoms)
 484
 485 #  endif
 486 {
 487   if (__a_end == __a && (__ct == __atoms[24] || __ct == __atoms[25])) {
 488     *__a_end++ = __ct == __atoms[24] ? '+' : '-';
 489     __dc       = 0;
 490     return 0;
 491   }
 492   if (__grouping.size() != 0 && __ct == __thousands_sep) {
 493     if (__g_end - __g < __num_get_buf_sz) {
 494       *__g_end++ = __dc;
 495       __dc       = 0;
 496     }
 497     return 0;
 498   }
 499   ptrdiff_t __f = std::find(__atoms, __atoms + __int_chr_cnt, __ct) - __atoms;
 500   if (__f >= 24)
 501     return -1;
 502   switch (__base) {
 503   case 8:
 504   case 10:
 505     if (__f >= __base)
 506       return -1;
 507     break;
 508   case 16:
 509     if (__f < 22)
 510       break;
 511     if (__a_end != __a && __a_end - __a <= 2 && __a_end[-1] == '0') {
 512       __dc       = 0;
 513       *__a_end++ = __src[__f];
 514       return 0;
 515     }
 516     return -1;
 517   }
 518   *__a_end++ = __src[__f];
 519   ++__dc;
 520   return 0;
 521 }
 522
 523 template <class _CharT>
 524 int __num_get<_CharT>::__stage2_float_loop(
 525     _CharT __ct,
 526     bool& __in_units,
 527     char& __exp,
 528     char* __a,
 529     char*& __a_end,
 530     _CharT __decimal_point,
 531     _CharT __thousands_sep,
 532     const string& __grouping,
 533     unsigned* __g,
 534     unsigned*& __g_end,
 535     unsigned& __dc,
 536     _CharT* __atoms) {
 537   if (__ct == __decimal_point) {
 538     if (!__in_units)
 539       return -1;
 540     __in_units = false;
 541     *__a_end++ = '.';
 542     if (__grouping.size() != 0 && __g_end - __g < __num_get_buf_sz)
 543       *__g_end++ = __dc;
 544     return 0;
 545   }
 546   if (__ct == __thousands_sep && __grouping.size() != 0) {
 547     if (!__in_units)
 548       return -1;
 549     if (__g_end - __g < __num_get_buf_sz) {
 550       *__g_end++ = __dc;
 551       __dc       = 0;
 552     }
 553     return 0;
 554   }
 555   ptrdiff_t __f = std::find(__atoms, __atoms + __num_get_base::__fp_chr_cnt, __ct) - __atoms;
 556   if (__f >= static_cast<ptrdiff_t>(__num_get_base::__fp_chr_cnt))
 557     return -1;
 558   char __x = __src[__f];
 559   if (__x == '-' || __x == '+') {
 560     if (__a_end == __a || (std::toupper(__a_end[-1]) == std::toupper(__exp))) {
 561       *__a_end++ = __x;
 562       return 0;
 563     }
 564     return -1;
 565   }
 566   if (__x == 'x' || __x == 'X')
 567     __exp = 'P';
 568   else if (std::toupper(__x) == __exp) {
 569     __exp = std::tolower(__exp);
 570     if (__in_units) {
 571       __in_units = false;
 572       if (__grouping.size() != 0 && __g_end - __g < __num_get_buf_sz)
 573         *__g_end++ = __dc;
 574     }
 575   }
 576   *__a_end++ = __x;
 577   if (__f >= 22)
 578     return 0;
 579   ++__dc;
 580   return 0;
 581 }
 582
 583 extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<char>;
 584 #  if _LIBCPP_HAS_WIDE_CHARACTERS
 585 extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<wchar_t>;
 586 #  endif
 587
 588 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
 589 class _LIBCPP_TEMPLATE_VIS num_get : public locale::facet, private __num_get<_CharT> {
 590 public:
 591   typedef _CharT char_type;
 592   typedef _InputIterator iter_type;
 593
 594   _LIBCPP_HIDE_FROM_ABI explicit num_get(size_t __refs = 0) : locale::facet(__refs) {}
 595
 596   _LIBCPP_HIDE_FROM_ABI iter_type
 597   get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, bool& __v) const {
 598     return do_get(__b, __e, __iob, __err, __v);
 599   }
 600
 601   _LIBCPP_HIDE_FROM_ABI iter_type
 602   get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long& __v) const {
 603     return do_get(__b, __e, __iob, __err, __v);
 604   }
 605
 606   _LIBCPP_HIDE_FROM_ABI iter_type
 607   get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long long& __v) const {
 608     return do_get(__b, __e, __iob, __err, __v);
 609   }
 610
 611   _LIBCPP_HIDE_FROM_ABI iter_type
 612   get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned short& __v) const {
 613     return do_get(__b, __e, __iob, __err, __v);
 614   }
 615
 616   _LIBCPP_HIDE_FROM_ABI iter_type
 617   get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned int& __v) const {
 618     return do_get(__b, __e, __iob, __err, __v);
 619   }
 620
 621   _LIBCPP_HIDE_FROM_ABI iter_type
 622   get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned long& __v) const {
 623     return do_get(__b, __e, __iob, __err, __v);
 624   }
 625
 626   _LIBCPP_HIDE_FROM_ABI iter_type
 627   get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned long long& __v) const {
 628     return do_get(__b, __e, __iob, __err, __v);
 629   }
 630
 631   _LIBCPP_HIDE_FROM_ABI iter_type
 632   get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, float& __v) const {
 633     return do_get(__b, __e, __iob, __err, __v);
 634   }
 635
 636   _LIBCPP_HIDE_FROM_ABI iter_type
 637   get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, double& __v) const {
 638     return do_get(__b, __e, __iob, __err, __v);
 639   }
 640
 641   _LIBCPP_HIDE_FROM_ABI iter_type
 642   get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long double& __v) const {
 643     return do_get(__b, __e, __iob, __err, __v);
 644   }
 645
 646   _LIBCPP_HIDE_FROM_ABI iter_type
 647   get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, void*& __v) const {
 648     return do_get(__b, __e, __iob, __err, __v);
 649   }
 650
 651   static locale::id id;
 652
 653 protected:
 654   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~num_get() override {}
 655
 656   template <class _Fp>
 657   _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS iter_type
 658   __do_get_floating_point(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Fp& __v) const;
 659
 660   template <class _Signed>
 661   _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS iter_type
 662   __do_get_signed(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Signed& __v) const;
 663
 664   template <class _Unsigned>
 665   _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS iter_type
 666   __do_get_unsigned(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Unsigned& __v) const;
 667
 668   virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, bool& __v) const;
 669
 670   virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long& __v) const {
 671     return this->__do_get_signed(__b, __e, __iob, __err, __v);
 672   }
 673
 674   virtual iter_type
 675   do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long long& __v) const {
 676     return this->__do_get_signed(__b, __e, __iob, __err, __v);
 677   }
 678
 679   virtual iter_type
 680   do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned short& __v) const {
 681     return this->__do_get_unsigned(__b, __e, __iob, __err, __v);
 682   }
 683
 684   virtual iter_type
 685   do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned int& __v) const {
 686     return this->__do_get_unsigned(__b, __e, __iob, __err, __v);
 687   }
 688
 689   virtual iter_type
 690   do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned long& __v) const {
 691     return this->__do_get_unsigned(__b, __e, __iob, __err, __v);
 692   }
 693
 694   virtual iter_type
 695   do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned long long& __v) const {
 696     return this->__do_get_unsigned(__b, __e, __iob, __err, __v);
 697   }
 698
 699   virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, float& __v) const {
 700     return this->__do_get_floating_point(__b, __e, __iob, __err, __v);
 701   }
 702
 703   virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, double& __v) const {
 704     return this->__do_get_floating_point(__b, __e, __iob, __err, __v);
 705   }
 706
 707   virtual iter_type
 708   do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long double& __v) const {
 709     return this->__do_get_floating_point(__b, __e, __iob, __err, __v);
 710   }
 711
 712   virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, void*& __v) const;
 713 };
 714
 715 template <class _CharT, class _InputIterator>
 716 locale::id num_get<_CharT, _InputIterator>::id;
 717
 718 template <class _Tp>
 719 _LIBCPP_HIDE_FROM_ABI _Tp
 720 __num_get_signed_integral(const char* __a, const char* __a_end, ios_base::iostate& __err, int __base) {
 721   if (__a != __a_end) {
 722     __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
 723     errno                                                     = 0;
 724     char* __p2;
 725     long long __ll                                               = strtoll_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
 726     __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
 727     if (__current_errno == 0)
 728       errno = __save_errno;
 729     if (__p2 != __a_end) {
 730       __err = ios_base::failbit;
 731       return 0;
 732     } else if (__current_errno == ERANGE || __ll < numeric_limits<_Tp>::min() || numeric_limits<_Tp>::max() < __ll) {
 733       __err = ios_base::failbit;
 734       if (__ll > 0)
 735         return numeric_limits<_Tp>::max();
 736       else
 737         return numeric_limits<_Tp>::min();
 738     }
 739     return static_cast<_Tp>(__ll);
 740   }
 741   __err = ios_base::failbit;
 742   return 0;
 743 }
 744
 745 template <class _Tp>
 746 _LIBCPP_HIDE_FROM_ABI _Tp
 747 __num_get_unsigned_integral(const char* __a, const char* __a_end, ios_base::iostate& __err, int __base) {
 748   if (__a != __a_end) {
 749     const bool __negate = *__a == '-';
 750     if (__negate && ++__a == __a_end) {
 751       __err = ios_base::failbit;
 752       return 0;
 753     }
 754     __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
 755     errno                                                     = 0;
 756     char* __p2;
 757     unsigned long long __ll                                      = strtoull_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
 758     __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
 759     if (__current_errno == 0)
 760       errno = __save_errno;
 761     if (__p2 != __a_end) {
 762       __err = ios_base::failbit;
 763       return 0;
 764     } else if (__current_errno == ERANGE || numeric_limits<_Tp>::max() < __ll) {
 765       __err = ios_base::failbit;
 766       return numeric_limits<_Tp>::max();
 767     }
 768     _Tp __res = static_cast<_Tp>(__ll);
 769     if (__negate)
 770       __res = -__res;
 771     return __res;
 772   }
 773   __err = ios_base::failbit;
 774   return 0;
 775 }
 776
 777 template <class _Tp>
 778 _LIBCPP_HIDE_FROM_ABI _Tp __do_strtod(const char* __a, char** __p2);
 779
 780 template <>
 781 inline _LIBCPP_HIDE_FROM_ABI float __do_strtod<float>(const char* __a, char** __p2) {
 782   return strtof_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
 783 }
 784
 785 template <>
 786 inline _LIBCPP_HIDE_FROM_ABI double __do_strtod<double>(const char* __a, char** __p2) {
 787   return strtod_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
 788 }
 789
 790 template <>
 791 inline _LIBCPP_HIDE_FROM_ABI long double __do_strtod<long double>(const char* __a, char** __p2) {
 792   return strtold_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
 793 }
 794
 795 template <class _Tp>
 796 _LIBCPP_HIDE_FROM_ABI _Tp __num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err) {
 797   if (__a != __a_end) {
 798     __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
 799     errno                                                     = 0;
 800     char* __p2;
 801     _Tp __ld                                                     = std::__do_strtod<_Tp>(__a, &__p2);
 802     __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
 803     if (__current_errno == 0)
 804       errno = __save_errno;
 805     if (__p2 != __a_end) {
 806       __err = ios_base::failbit;
 807       return 0;
 808     } else if (__current_errno == ERANGE)
 809       __err = ios_base::failbit;
 810     return __ld;
 811   }
 812   __err = ios_base::failbit;
 813   return 0;
 814 }
 815
 816 template <class _CharT, class _InputIterator>
 817 _InputIterator num_get<_CharT, _InputIterator>::do_get(
 818     iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, bool& __v) const {
 819   if ((__iob.flags() & ios_base::boolalpha) == 0) {
 820     long __lv = -1;
 821     __b       = do_get(__b, __e, __iob, __err, __lv);
 822     switch (__lv) {
 823     case 0:
 824       __v = false;
 825       break;
 826     case 1:
 827       __v = true;
 828       break;
 829     default:
 830       __v   = true;
 831       __err = ios_base::failbit;
 832       break;
 833     }
 834     return __b;
 835   }
 836   const ctype<_CharT>& __ct    = std::use_facet<ctype<_CharT> >(__iob.getloc());
 837   const numpunct<_CharT>& __np = std::use_facet<numpunct<_CharT> >(__iob.getloc());
 838   typedef typename numpunct<_CharT>::string_type string_type;
 839   const string_type __names[2] = {__np.truename(), __np.falsename()};
 840   const string_type* __i       = std::__scan_keyword(__b, __e, __names, __names + 2, __ct, __err);
 841   __v                          = __i == __names;
 842   return __b;
 843 }
 844
 845 // signed
 846
 847 template <class _CharT, class _InputIterator>
 848 template <class _Signed>
 849 _InputIterator num_get<_CharT, _InputIterator>::__do_get_signed(
 850     iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Signed& __v) const {
 851   // Stage 1
 852   int __base = this->__get_base(__iob);
 853   // Stage 2
 854   char_type __thousands_sep;
 855   const int __atoms_size = __num_get_base::__int_chr_cnt;
 856 #  ifdef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
 857   char_type __atoms1[__atoms_size];
 858   const char_type* __atoms = this->__do_widen(__iob, __atoms1);
 859   string __grouping        = this->__stage2_int_prep(__iob, __thousands_sep);
 860 #  else
 861   char_type __atoms[__atoms_size];
 862   string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
 863 #  endif
 864   string __buf;
 865   __buf.resize(__buf.capacity());
 866   char* __a     = &__buf[0];
 867   char* __a_end = __a;
 868   unsigned __g[__num_get_base::__num_get_buf_sz];
 869   unsigned* __g_end = __g;
 870   unsigned __dc     = 0;
 871   for (; __b != __e; ++__b) {
 872     if (__a_end == __a + __buf.size()) {
 873       size_t __tmp = __buf.size();
 874       __buf.resize(2 * __buf.size());
 875       __buf.resize(__buf.capacity());
 876       __a     = &__buf[0];
 877       __a_end = __a + __tmp;
 878     }
 879     if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms))
 880       break;
 881   }
 882   if (__grouping.size() != 0 && __g_end - __g < __num_get_base::__num_get_buf_sz)
 883     *__g_end++ = __dc;
 884   // Stage 3
 885   __v = std::__num_get_signed_integral<_Signed>(__a, __a_end, __err, __base);
 886   // Digit grouping checked
 887   __check_grouping(__grouping, __g, __g_end, __err);
 888   // EOF checked
 889   if (__b == __e)
 890     __err |= ios_base::eofbit;
 891   return __b;
 892 }
 893
 894 // unsigned
 895
 896 template <class _CharT, class _InputIterator>
 897 template <class _Unsigned>
 898 _InputIterator num_get<_CharT, _InputIterator>::__do_get_unsigned(
 899     iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Unsigned& __v) const {
 900   // Stage 1
 901   int __base = this->__get_base(__iob);
 902   // Stage 2
 903   char_type __thousands_sep;
 904   const int __atoms_size = __num_get_base::__int_chr_cnt;
 905 #  ifdef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
 906   char_type __atoms1[__atoms_size];
 907   const char_type* __atoms = this->__do_widen(__iob, __atoms1);
 908   string __grouping        = this->__stage2_int_prep(__iob, __thousands_sep);
 909 #  else
 910   char_type __atoms[__atoms_size];
 911   string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
 912 #  endif
 913   string __buf;
 914   __buf.resize(__buf.capacity());
 915   char* __a     = &__buf[0];
 916   char* __a_end = __a;
 917   unsigned __g[__num_get_base::__num_get_buf_sz];
 918   unsigned* __g_end = __g;
 919   unsigned __dc     = 0;
 920   for (; __b != __e; ++__b) {
 921     if (__a_end == __a + __buf.size()) {
 922       size_t __tmp = __buf.size();
 923       __buf.resize(2 * __buf.size());
 924       __buf.resize(__buf.capacity());
 925       __a     = &__buf[0];
 926       __a_end = __a + __tmp;
 927     }
 928     if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms))
 929       break;
 930   }
 931   if (__grouping.size() != 0 && __g_end - __g < __num_get_base::__num_get_buf_sz)
 932     *__g_end++ = __dc;
 933   // Stage 3
 934   __v = std::__num_get_unsigned_integral<_Unsigned>(__a, __a_end, __err, __base);
 935   // Digit grouping checked
 936   __check_grouping(__grouping, __g, __g_end, __err);
 937   // EOF checked
 938   if (__b == __e)
 939     __err |= ios_base::eofbit;
 940   return __b;
 941 }
 942
 943 // floating point
 944
 945 template <class _CharT, class _InputIterator>
 946 template <class _Fp>
 947 _InputIterator num_get<_CharT, _InputIterator>::__do_get_floating_point(
 948     iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Fp& __v) const {
 949   // Stage 1, nothing to do
 950   // Stage 2
 951   char_type __atoms[__num_get_base::__fp_chr_cnt];
 952   char_type __decimal_point;
 953   char_type __thousands_sep;
 954   string __grouping = this->__stage2_float_prep(__iob, __atoms, __decimal_point, __thousands_sep);
 955   string __buf;
 956   __buf.resize(__buf.capacity());
 957   char* __a     = &__buf[0];
 958   char* __a_end = __a;
 959   unsigned __g[__num_get_base::__num_get_buf_sz];
 960   unsigned* __g_end        = __g;
 961   unsigned __dc            = 0;
 962   bool __in_units          = true;
 963   char __exp               = 'E';
 964   bool __is_leading_parsed = false;
 965   for (; __b != __e; ++__b) {
 966     if (__a_end == __a + __buf.size()) {
 967       size_t __tmp = __buf.size();
 968       __buf.resize(2 * __buf.size());
 969       __buf.resize(__buf.capacity());
 970       __a     = &__buf[0];
 971       __a_end = __a + __tmp;
 972     }
 973     if (this->__stage2_float_loop(
 974             *__b,
 975             __in_units,
 976             __exp,
 977             __a,
 978             __a_end,
 979             __decimal_point,
 980             __thousands_sep,
 981             __grouping,
 982             __g,
 983             __g_end,
 984             __dc,
 985             __atoms))
 986       break;
 987
 988     // the leading character excluding the sign must be a decimal digit
 989     if (!__is_leading_parsed) {
 990       if (__a_end - __a >= 1 && __a[0] != '-' && __a[0] != '+') {
 991         if (('0' <= __a[0] && __a[0] <= '9') || __a[0] == '.')
 992           __is_leading_parsed = true;
 993         else
 994           break;
 995       } else if (__a_end - __a >= 2 && (__a[0] == '-' || __a[0] == '+')) {
 996         if (('0' <= __a[1] && __a[1] <= '9') || __a[1] == '.')
 997           __is_leading_parsed = true;
 998         else
 999           break;
1000       }
1001     }
1002   }
1003   if (__grouping.size() != 0 && __in_units && __g_end - __g < __num_get_base::__num_get_buf_sz)
1004     *__g_end++ = __dc;
1005   // Stage 3
1006   __v = std::__num_get_float<_Fp>(__a, __a_end, __err);
1007   // Digit grouping checked
1008   __check_grouping(__grouping, __g, __g_end, __err);
1009   // EOF checked
1010   if (__b == __e)
1011     __err |= ios_base::eofbit;
1012   return __b;
1013 }
1014
1015 template <class _CharT, class _InputIterator>
1016 _InputIterator num_get<_CharT, _InputIterator>::do_get(
1017     iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, void*& __v) const {
1018   // Stage 1
1019   int __base = 16;
1020   // Stage 2
1021   char_type __atoms[__num_get_base::__int_chr_cnt];
1022   char_type __thousands_sep = char_type();
1023   string __grouping;
1024   std::use_facet<ctype<_CharT> >(__iob.getloc())
1025       .widen(__num_get_base::__src, __num_get_base::__src + __num_get_base::__int_chr_cnt, __atoms);
1026   string __buf;
1027   __buf.resize(__buf.capacity());
1028   char* __a     = &__buf[0];
1029   char* __a_end = __a;
1030   unsigned __g[__num_get_base::__num_get_buf_sz];
1031   unsigned* __g_end = __g;
1032   unsigned __dc     = 0;
1033   for (; __b != __e; ++__b) {
1034     if (__a_end == __a + __buf.size()) {
1035       size_t __tmp = __buf.size();
1036       __buf.resize(2 * __buf.size());
1037       __buf.resize(__buf.capacity());
1038       __a     = &__buf[0];
1039       __a_end = __a + __tmp;
1040     }
1041     if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms))
1042       break;
1043   }
1044   // Stage 3
1045   __buf.resize(__a_end - __a);
1046   if (__locale::__sscanf(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1)
1047     __err = ios_base::failbit;
1048   // EOF checked
1049   if (__b == __e)
1050     __err |= ios_base::eofbit;
1051   return __b;
1052 }
1053
1054 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<char>;
1055 #  if _LIBCPP_HAS_WIDE_CHARACTERS
1056 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<wchar_t>;
1057 #  endif
1058
1059 struct _LIBCPP_EXPORTED_FROM_ABI __num_put_base {
1060 protected:
1061   static void __format_int(char* __fmt, const char* __len, bool __signd, ios_base::fmtflags __flags);
1062   static bool __format_float(char* __fmt, const char* __len, ios_base::fmtflags __flags);
1063   static char* __identify_padding(char* __nb, char* __ne, const ios_base& __iob);
1064 };
1065
1066 template <class _CharT>
1067 struct __num_put : protected __num_put_base {
1068   static void __widen_and_group_int(
1069       char* __nb, char* __np, char* __ne, _CharT* __ob, _CharT*& __op, _CharT*& __oe, const locale& __loc);
1070   static void __widen_and_group_float(
1071       char* __nb, char* __np, char* __ne, _CharT* __ob, _CharT*& __op, _CharT*& __oe, const locale& __loc);
1072 };
1073
1074 template <class _CharT>
1075 void __num_put<_CharT>::__widen_and_group_int(
1076     char* __nb, char* __np, char* __ne, _CharT* __ob, _CharT*& __op, _CharT*& __oe, const locale& __loc) {
1077   const ctype<_CharT>& __ct     = std::use_facet<ctype<_CharT> >(__loc);
1078   const numpunct<_CharT>& __npt = std::use_facet<numpunct<_CharT> >(__loc);
1079   string __grouping             = __npt.grouping();
1080   if (__grouping.empty()) {
1081     __ct.widen(__nb, __ne, __ob);
1082     __oe = __ob + (__ne - __nb);
1083   } else {
1084     __oe       = __ob;
1085     char* __nf = __nb;
1086     if (*__nf == '-' || *__nf == '+')
1087       *__oe++ = __ct.widen(*__nf++);
1088     if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' || __nf[1] == 'X')) {
1089       *__oe++ = __ct.widen(*__nf++);
1090       *__oe++ = __ct.widen(*__nf++);
1091     }
1092     std::reverse(__nf, __ne);
1093     _CharT __thousands_sep = __npt.thousands_sep();
1094     unsigned __dc          = 0;
1095     unsigned __dg          = 0;
1096     for (char* __p = __nf; __p < __ne; ++__p) {
1097       if (static_cast<unsigned>(__grouping[__dg]) > 0 && __dc == static_cast<unsigned>(__grouping[__dg])) {
1098         *__oe++ = __thousands_sep;
1099         __dc    = 0;
1100         if (__dg < __grouping.size() - 1)
1101           ++__dg;
1102       }
1103       *__oe++ = __ct.widen(*__p);
1104       ++__dc;
1105     }
1106     std::reverse(__ob + (__nf - __nb), __oe);
1107   }
1108   if (__np == __ne)
1109     __op = __oe;
1110   else
1111     __op = __ob + (__np - __nb);
1112 }
1113
1114 template <class _CharT>
1115 void __num_put<_CharT>::__widen_and_group_float(
1116     char* __nb, char* __np, char* __ne, _CharT* __ob, _CharT*& __op, _CharT*& __oe, const locale& __loc) {
1117   const ctype<_CharT>& __ct     = std::use_facet<ctype<_CharT> >(__loc);
1118   const numpunct<_CharT>& __npt = std::use_facet<numpunct<_CharT> >(__loc);
1119   string __grouping             = __npt.grouping();
1120   __oe                          = __ob;
1121   char* __nf                    = __nb;
1122   if (*__nf == '-' || *__nf == '+')
1123     *__oe++ = __ct.widen(*__nf++);
1124   char* __ns;
1125   if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' || __nf[1] == 'X')) {
1126     *__oe++ = __ct.widen(*__nf++);
1127     *__oe++ = __ct.widen(*__nf++);
1128     for (__ns = __nf; __ns < __ne; ++__ns)
1129       if (!__locale::__isxdigit(*__ns, _LIBCPP_GET_C_LOCALE))
1130         break;
1131   } else {
1132     for (__ns = __nf; __ns < __ne; ++__ns)
1133       if (!__locale::__isdigit(*__ns, _LIBCPP_GET_C_LOCALE))
1134         break;
1135   }
1136   if (__grouping.empty()) {
1137     __ct.widen(__nf, __ns, __oe);
1138     __oe += __ns - __nf;
1139   } else {
1140     std::reverse(__nf, __ns);
1141     _CharT __thousands_sep = __npt.thousands_sep();
1142     unsigned __dc          = 0;
1143     unsigned __dg          = 0;
1144     for (char* __p = __nf; __p < __ns; ++__p) {
1145       if (__grouping[__dg] > 0 && __dc == static_cast<unsigned>(__grouping[__dg])) {
1146         *__oe++ = __thousands_sep;
1147         __dc    = 0;
1148         if (__dg < __grouping.size() - 1)
1149           ++__dg;
1150       }
1151       *__oe++ = __ct.widen(*__p);
1152       ++__dc;
1153     }
1154     std::reverse(__ob + (__nf - __nb), __oe);
1155   }
1156   for (__nf = __ns; __nf < __ne; ++__nf) {
1157     if (*__nf == '.') {
1158       *__oe++ = __npt.decimal_point();
1159       ++__nf;
1160       break;
1161     } else
1162       *__oe++ = __ct.widen(*__nf);
1163   }
1164   __ct.widen(__nf, __ne, __oe);
1165   __oe += __ne - __nf;
1166   if (__np == __ne)
1167     __op = __oe;
1168   else
1169     __op = __ob + (__np - __nb);
1170 }
1171
1172 extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<char>;
1173 #  if _LIBCPP_HAS_WIDE_CHARACTERS
1174 extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<wchar_t>;
1175 #  endif
1176
1177 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
1178 class _LIBCPP_TEMPLATE_VIS num_put : public locale::facet, private __num_put<_CharT> {
1179 public:
1180   typedef _CharT char_type;
1181   typedef _OutputIterator iter_type;
1182
1183   _LIBCPP_HIDE_FROM_ABI explicit num_put(size_t __refs = 0) : locale::facet(__refs) {}
1184
1185   _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, bool __v) const {
1186     return do_put(__s, __iob, __fl, __v);
1187   }
1188
1189   _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, long __v) const {
1190     return do_put(__s, __iob, __fl, __v);
1191   }
1192
1193   _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, long long __v) const {
1194     return do_put(__s, __iob, __fl, __v);
1195   }
1196
1197   _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, unsigned long __v) const {
1198     return do_put(__s, __iob, __fl, __v);
1199   }
1200
1201   _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, unsigned long long __v) const {
1202     return do_put(__s, __iob, __fl, __v);
1203   }
1204
1205   _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, double __v) const {
1206     return do_put(__s, __iob, __fl, __v);
1207   }
1208
1209   _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, long double __v) const {
1210     return do_put(__s, __iob, __fl, __v);
1211   }
1212
1213   _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, const void* __v) const {
1214     return do_put(__s, __iob, __fl, __v);
1215   }
1216
1217   static locale::id id;
1218
1219 protected:
1220   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~num_put() override {}
1221
1222   virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, bool __v) const;
1223   virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, long __v) const;
1224   virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, long long __v) const;
1225   virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, unsigned long) const;
1226   virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, unsigned long long) const;
1227   virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, double __v) const;
1228   virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, long double __v) const;
1229   virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, const void* __v) const;
1230
1231   template <class _Integral>
1232   _LIBCPP_HIDE_FROM_ABI inline _OutputIterator
1233   __do_put_integral(iter_type __s, ios_base& __iob, char_type __fl, _Integral __v, char const* __len) const;
1234
1235   template <class _Float>
1236   _LIBCPP_HIDE_FROM_ABI inline _OutputIterator
1237   __do_put_floating_point(iter_type __s, ios_base& __iob, char_type __fl, _Float __v, char const* __len) const;
1238 };
1239
1240 template <class _CharT, class _OutputIterator>
1241 locale::id num_put<_CharT, _OutputIterator>::id;
1242
1243 template <class _CharT, class _OutputIterator>
1244 _OutputIterator
1245 num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, bool __v) const {
1246   if ((__iob.flags() & ios_base::boolalpha) == 0)
1247     return do_put(__s, __iob, __fl, (unsigned long)__v);
1248   const numpunct<char_type>& __np = std::use_facet<numpunct<char_type> >(__iob.getloc());
1249   typedef typename numpunct<char_type>::string_type string_type;
1250   string_type __nm = __v ? __np.truename() : __np.falsename();
1251   for (typename string_type::iterator __i = __nm.begin(); __i != __nm.end(); ++__i, ++__s)
1252     *__s = *__i;
1253   return __s;
1254 }
1255
1256 template <class _CharT, class _OutputIterator>
1257 template <class _Integral>
1258 _LIBCPP_HIDE_FROM_ABI inline _OutputIterator num_put<_CharT, _OutputIterator>::__do_put_integral(
1259     iter_type __s, ios_base& __iob, char_type __fl, _Integral __v, char const* __len) const {
1260   // Stage 1 - Get number in narrow char
1261   char __fmt[8] = {'%', 0};
1262   this->__format_int(__fmt + 1, __len, is_signed<_Integral>::value, __iob.flags());
1263   // Worst case is octal, with showbase enabled. Note that octal is always
1264   // printed as an unsigned value.
1265   using _Unsigned = typename make_unsigned<_Integral>::type;
1266   _LIBCPP_CONSTEXPR const unsigned __nbuf =
1267       (numeric_limits<_Unsigned>::digits / 3)          // 1 char per 3 bits
1268       + ((numeric_limits<_Unsigned>::digits % 3) != 0) // round up
1269       + 2;                                             // base prefix + terminating null character
1270   char __nar[__nbuf];
1271   _LIBCPP_DIAGNOSTIC_PUSH
1272   _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
1273   _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
1274   int __nc = __locale::__snprintf(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
1275   _LIBCPP_DIAGNOSTIC_POP
1276   char* __ne = __nar + __nc;
1277   char* __np = this->__identify_padding(__nar, __ne, __iob);
1278   // Stage 2 - Widen __nar while adding thousands separators
1279   char_type __o[2 * (__nbuf - 1) - 1];
1280   char_type* __op; // pad here
1281   char_type* __oe; // end of output
1282   this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc());
1283   // [__o, __oe) contains thousands_sep'd wide number
1284   // Stage 3 & 4
1285   return std::__pad_and_output(__s, __o, __op, __oe, __iob, __fl);
1286 }
1287
1288 template <class _CharT, class _OutputIterator>
1289 _OutputIterator
1290 num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, long __v) const {
1291   return this->__do_put_integral(__s, __iob, __fl, __v, "l");
1292 }
1293
1294 template <class _CharT, class _OutputIterator>
1295 _OutputIterator
1296 num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, long long __v) const {
1297   return this->__do_put_integral(__s, __iob, __fl, __v, "ll");
1298 }
1299
1300 template <class _CharT, class _OutputIterator>
1301 _OutputIterator
1302 num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, unsigned long __v) const {
1303   return this->__do_put_integral(__s, __iob, __fl, __v, "l");
1304 }
1305
1306 template <class _CharT, class _OutputIterator>
1307 _OutputIterator
1308 num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, unsigned long long __v) const {
1309   return this->__do_put_integral(__s, __iob, __fl, __v, "ll");
1310 }
1311
1312 template <class _CharT, class _OutputIterator>
1313 template <class _Float>
1314 _LIBCPP_HIDE_FROM_ABI inline _OutputIterator num_put<_CharT, _OutputIterator>::__do_put_floating_point(
1315     iter_type __s, ios_base& __iob, char_type __fl, _Float __v, char const* __len) const {
1316   // Stage 1 - Get number in narrow char
1317   char __fmt[8]            = {'%', 0};
1318   bool __specify_precision = this->__format_float(__fmt + 1, __len, __iob.flags());
1319   const unsigned __nbuf    = 30;
1320   char __nar[__nbuf];
1321   char* __nb = __nar;
1322   int __nc;
1323   _LIBCPP_DIAGNOSTIC_PUSH
1324   _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
1325   _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
1326   if (__specify_precision)
1327     __nc = __locale::__snprintf(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
1328   else
1329     __nc = __locale::__snprintf(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
1330   unique_ptr<char, void (*)(void*)> __nbh(nullptr, free);
1331   if (__nc > static_cast<int>(__nbuf - 1)) {
1332     if (__specify_precision)
1333       __nc = __locale::__asprintf(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
1334     else
1335       __nc = __locale::__asprintf(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
1336     if (__nc == -1)
1337       __throw_bad_alloc();
1338     __nbh.reset(__nb);
1339   }
1340   _LIBCPP_DIAGNOSTIC_POP
1341   char* __ne = __nb + __nc;
1342   char* __np = this->__identify_padding(__nb, __ne, __iob);
1343   // Stage 2 - Widen __nar while adding thousands separators
1344   char_type __o[2 * (__nbuf - 1) - 1];
1345   char_type* __ob = __o;
1346   unique_ptr<char_type, void (*)(void*)> __obh(0, free);
1347   if (__nb != __nar) {
1348     __ob = (char_type*)malloc(2 * static_cast<size_t>(__nc) * sizeof(char_type));
1349     if (__ob == 0)
1350       __throw_bad_alloc();
1351     __obh.reset(__ob);
1352   }
1353   char_type* __op; // pad here
1354   char_type* __oe; // end of output
1355   this->__widen_and_group_float(__nb, __np, __ne, __ob, __op, __oe, __iob.getloc());
1356   // [__o, __oe) contains thousands_sep'd wide number
1357   // Stage 3 & 4
1358   __s = std::__pad_and_output(__s, __ob, __op, __oe, __iob, __fl);
1359   return __s;
1360 }
1361
1362 template <class _CharT, class _OutputIterator>
1363 _OutputIterator
1364 num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, double __v) const {
1365   return this->__do_put_floating_point(__s, __iob, __fl, __v, "");
1366 }
1367
1368 template <class _CharT, class _OutputIterator>
1369 _OutputIterator
1370 num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, long double __v) const {
1371   return this->__do_put_floating_point(__s, __iob, __fl, __v, "L");
1372 }
1373
1374 template <class _CharT, class _OutputIterator>
1375 _OutputIterator
1376 num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, const void* __v) const {
1377   // Stage 1 - Get pointer in narrow char
1378   const unsigned __nbuf = 20;
1379   char __nar[__nbuf];
1380   int __nc   = __locale::__snprintf(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, "%p", __v);
1381   char* __ne = __nar + __nc;
1382   char* __np = this->__identify_padding(__nar, __ne, __iob);
1383   // Stage 2 - Widen __nar
1384   char_type __o[2 * (__nbuf - 1) - 1];
1385   char_type* __op; // pad here
1386   char_type* __oe; // end of output
1387   const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
1388   __ct.widen(__nar, __ne, __o);
1389   __oe = __o + (__ne - __nar);
1390   if (__np == __ne)
1391     __op = __oe;
1392   else
1393     __op = __o + (__np - __nar);
1394   // [__o, __oe) contains wide number
1395   // Stage 3 & 4
1396   return std::__pad_and_output(__s, __o, __op, __oe, __iob, __fl);
1397 }
1398
1399 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<char>;
1400 #  if _LIBCPP_HAS_WIDE_CHARACTERS
1401 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<wchar_t>;
1402 #  endif
1403
1404 template <class _CharT, class _InputIterator>
1405 _LIBCPP_HIDE_FROM_ABI int __get_up_to_n_digits(
1406     _InputIterator& __b, _InputIterator __e, ios_base::iostate& __err, const ctype<_CharT>& __ct, int __n) {
1407   // Precondition:  __n >= 1
1408   if (__b == __e) {
1409     __err |= ios_base::eofbit | ios_base::failbit;
1410     return 0;
1411   }
1412   // get first digit
1413   _CharT __c = *__b;
1414   if (!__ct.is(ctype_base::digit, __c)) {
1415     __err |= ios_base::failbit;
1416     return 0;
1417   }
1418   int __r = __ct.narrow(__c, 0) - '0';
1419   for (++__b, (void)--__n; __b != __e && __n > 0; ++__b, (void)--__n) {
1420     // get next digit
1421     __c = *__b;
1422     if (!__ct.is(ctype_base::digit, __c))
1423       return __r;
1424     __r = __r * 10 + __ct.narrow(__c, 0) - '0';
1425   }
1426   if (__b == __e)
1427     __err |= ios_base::eofbit;
1428   return __r;
1429 }
1430
1431 class _LIBCPP_EXPORTED_FROM_ABI time_base {
1432 public:
1433   enum dateorder { no_order, dmy, mdy, ymd, ydm };
1434 };
1435
1436 template <class _CharT>
1437 class _LIBCPP_TEMPLATE_VIS __time_get_c_storage {
1438 protected:
1439   typedef basic_string<_CharT> string_type;
1440
1441   virtual const string_type* __weeks() const;
1442   virtual const string_type* __months() const;
1443   virtual const string_type* __am_pm() const;
1444   virtual const string_type& __c() const;
1445   virtual const string_type& __r() const;
1446   virtual const string_type& __x() const;
1447   virtual const string_type& __X() const;
1448
1449   _LIBCPP_HIDE_FROM_ABI ~__time_get_c_storage() {}
1450 };
1451
1452 template <>
1453 _LIBCPP_EXPORTED_FROM_ABI const string* __time_get_c_storage<char>::__weeks() const;
1454 template <>
1455 _LIBCPP_EXPORTED_FROM_ABI const string* __time_get_c_storage<char>::__months() const;
1456 template <>
1457 _LIBCPP_EXPORTED_FROM_ABI const string* __time_get_c_storage<char>::__am_pm() const;
1458 template <>
1459 _LIBCPP_EXPORTED_FROM_ABI const string& __time_get_c_storage<char>::__c() const;
1460 template <>
1461 _LIBCPP_EXPORTED_FROM_ABI const string& __time_get_c_storage<char>::__r() const;
1462 template <>
1463 _LIBCPP_EXPORTED_FROM_ABI const string& __time_get_c_storage<char>::__x() const;
1464 template <>
1465 _LIBCPP_EXPORTED_FROM_ABI const string& __time_get_c_storage<char>::__X() const;
1466
1467 #  if _LIBCPP_HAS_WIDE_CHARACTERS
1468 template <>
1469 _LIBCPP_EXPORTED_FROM_ABI const wstring* __time_get_c_storage<wchar_t>::__weeks() const;
1470 template <>
1471 _LIBCPP_EXPORTED_FROM_ABI const wstring* __time_get_c_storage<wchar_t>::__months() const;
1472 template <>
1473 _LIBCPP_EXPORTED_FROM_ABI const wstring* __time_get_c_storage<wchar_t>::__am_pm() const;
1474 template <>
1475 _LIBCPP_EXPORTED_FROM_ABI const wstring& __time_get_c_storage<wchar_t>::__c() const;
1476 template <>
1477 _LIBCPP_EXPORTED_FROM_ABI const wstring& __time_get_c_storage<wchar_t>::__r() const;
1478 template <>
1479 _LIBCPP_EXPORTED_FROM_ABI const wstring& __time_get_c_storage<wchar_t>::__x() const;
1480 template <>
1481 _LIBCPP_EXPORTED_FROM_ABI const wstring& __time_get_c_storage<wchar_t>::__X() const;
1482 #  endif
1483
1484 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
1485 class _LIBCPP_TEMPLATE_VIS time_get : public locale::facet, public time_base, private __time_get_c_storage<_CharT> {
1486 public:
1487   typedef _CharT char_type;
1488   typedef _InputIterator iter_type;
1489   typedef time_base::dateorder dateorder;
1490   typedef basic_string<char_type> string_type;
1491
1492   _LIBCPP_HIDE_FROM_ABI explicit time_get(size_t __refs = 0) : locale::facet(__refs) {}
1493
1494   _LIBCPP_HIDE_FROM_ABI dateorder date_order() const { return this->do_date_order(); }
1495
1496   _LIBCPP_HIDE_FROM_ABI iter_type
1497   get_time(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
1498     return do_get_time(__b, __e, __iob, __err, __tm);
1499   }
1500
1501   _LIBCPP_HIDE_FROM_ABI iter_type
1502   get_date(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
1503     return do_get_date(__b, __e, __iob, __err, __tm);
1504   }
1505
1506   _LIBCPP_HIDE_FROM_ABI iter_type
1507   get_weekday(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
1508     return do_get_weekday(__b, __e, __iob, __err, __tm);
1509   }
1510
1511   _LIBCPP_HIDE_FROM_ABI iter_type
1512   get_monthname(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
1513     return do_get_monthname(__b, __e, __iob, __err, __tm);
1514   }
1515
1516   _LIBCPP_HIDE_FROM_ABI iter_type
1517   get_year(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
1518     return do_get_year(__b, __e, __iob, __err, __tm);
1519   }
1520
1521   _LIBCPP_HIDE_FROM_ABI iter_type
1522   get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm, char __fmt, char __mod = 0)
1523       const {
1524     return do_get(__b, __e, __iob, __err, __tm, __fmt, __mod);
1525   }
1526
1527   iter_type
1528   get(iter_type __b,
1529       iter_type __e,
1530       ios_base& __iob,
1531       ios_base::iostate& __err,
1532       tm* __tm,
1533       const char_type* __fmtb,
1534       const char_type* __fmte) const;
1535
1536   static locale::id id;
1537
1538 protected:
1539   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~time_get() override {}
1540
1541   virtual dateorder do_date_order() const;
1542   virtual iter_type
1543   do_get_time(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const;
1544   virtual iter_type
1545   do_get_date(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const;
1546   virtual iter_type
1547   do_get_weekday(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const;
1548   virtual iter_type
1549   do_get_monthname(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const;
1550   virtual iter_type
1551   do_get_year(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const;
1552   virtual iter_type do_get(
1553       iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm, char __fmt, char __mod) const;
1554
1555 private:
1556   void __get_white_space(iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1557   void __get_percent(iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1558
1559   void __get_weekdayname(
1560       int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1561   void __get_monthname(
1562       int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1563   void __get_day(int& __d, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1564   void
1565   __get_month(int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1566   void
1567   __get_year(int& __y, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1568   void
1569   __get_year4(int& __y, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1570   void
1571   __get_hour(int& __d, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1572   void
1573   __get_12_hour(int& __h, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1574   void
1575   __get_am_pm(int& __h, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1576   void
1577   __get_minute(int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1578   void
1579   __get_second(int& __s, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1580   void
1581   __get_weekday(int& __w, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1582   void __get_day_year_num(
1583       int& __w, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
1584 };
1585
1586 template <class _CharT, class _InputIterator>
1587 locale::id time_get<_CharT, _InputIterator>::id;
1588
1589 // time_get primitives
1590
1591 template <class _CharT, class _InputIterator>
1592 void time_get<_CharT, _InputIterator>::__get_weekdayname(
1593     int& __w, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1594   // Note:  ignoring case comes from the POSIX strptime spec
1595   const string_type* __wk = this->__weeks();
1596   ptrdiff_t __i           = std::__scan_keyword(__b, __e, __wk, __wk + 14, __ct, __err, false) - __wk;
1597   if (__i < 14)
1598     __w = __i % 7;
1599 }
1600
1601 template <class _CharT, class _InputIterator>
1602 void time_get<_CharT, _InputIterator>::__get_monthname(
1603     int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1604   // Note:  ignoring case comes from the POSIX strptime spec
1605   const string_type* __month = this->__months();
1606   ptrdiff_t __i              = std::__scan_keyword(__b, __e, __month, __month + 24, __ct, __err, false) - __month;
1607   if (__i < 24)
1608     __m = __i % 12;
1609 }
1610
1611 template <class _CharT, class _InputIterator>
1612 void time_get<_CharT, _InputIterator>::__get_day(
1613     int& __d, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1614   int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
1615   if (!(__err & ios_base::failbit) && 1 <= __t && __t <= 31)
1616     __d = __t;
1617   else
1618     __err |= ios_base::failbit;
1619 }
1620
1621 template <class _CharT, class _InputIterator>
1622 void time_get<_CharT, _InputIterator>::__get_month(
1623     int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1624   int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2) - 1;
1625   if (!(__err & ios_base::failbit) && 0 <= __t && __t <= 11)
1626     __m = __t;
1627   else
1628     __err |= ios_base::failbit;
1629 }
1630
1631 template <class _CharT, class _InputIterator>
1632 void time_get<_CharT, _InputIterator>::__get_year(
1633     int& __y, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1634   int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 4);
1635   if (!(__err & ios_base::failbit)) {
1636     if (__t < 69)
1637       __t += 2000;
1638     else if (69 <= __t && __t <= 99)
1639       __t += 1900;
1640     __y = __t - 1900;
1641   }
1642 }
1643
1644 template <class _CharT, class _InputIterator>
1645 void time_get<_CharT, _InputIterator>::__get_year4(
1646     int& __y, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1647   int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 4);
1648   if (!(__err & ios_base::failbit))
1649     __y = __t - 1900;
1650 }
1651
1652 template <class _CharT, class _InputIterator>
1653 void time_get<_CharT, _InputIterator>::__get_hour(
1654     int& __h, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1655   int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
1656   if (!(__err & ios_base::failbit) && __t <= 23)
1657     __h = __t;
1658   else
1659     __err |= ios_base::failbit;
1660 }
1661
1662 template <class _CharT, class _InputIterator>
1663 void time_get<_CharT, _InputIterator>::__get_12_hour(
1664     int& __h, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1665   int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
1666   if (!(__err & ios_base::failbit) && 1 <= __t && __t <= 12)
1667     __h = __t;
1668   else
1669     __err |= ios_base::failbit;
1670 }
1671
1672 template <class _CharT, class _InputIterator>
1673 void time_get<_CharT, _InputIterator>::__get_minute(
1674     int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1675   int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
1676   if (!(__err & ios_base::failbit) && __t <= 59)
1677     __m = __t;
1678   else
1679     __err |= ios_base::failbit;
1680 }
1681
1682 template <class _CharT, class _InputIterator>
1683 void time_get<_CharT, _InputIterator>::__get_second(
1684     int& __s, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1685   int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
1686   if (!(__err & ios_base::failbit) && __t <= 60)
1687     __s = __t;
1688   else
1689     __err |= ios_base::failbit;
1690 }
1691
1692 template <class _CharT, class _InputIterator>
1693 void time_get<_CharT, _InputIterator>::__get_weekday(
1694     int& __w, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1695   int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 1);
1696   if (!(__err & ios_base::failbit) && __t <= 6)
1697     __w = __t;
1698   else
1699     __err |= ios_base::failbit;
1700 }
1701
1702 template <class _CharT, class _InputIterator>
1703 void time_get<_CharT, _InputIterator>::__get_day_year_num(
1704     int& __d, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1705   int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 3);
1706   if (!(__err & ios_base::failbit) && __t <= 365)
1707     __d = __t;
1708   else
1709     __err |= ios_base::failbit;
1710 }
1711
1712 template <class _CharT, class _InputIterator>
1713 void time_get<_CharT, _InputIterator>::__get_white_space(
1714     iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1715   for (; __b != __e && __ct.is(ctype_base::space, *__b); ++__b)
1716     ;
1717   if (__b == __e)
1718     __err |= ios_base::eofbit;
1719 }
1720
1721 template <class _CharT, class _InputIterator>
1722 void time_get<_CharT, _InputIterator>::__get_am_pm(
1723     int& __h, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1724   const string_type* __ap = this->__am_pm();
1725   if (__ap[0].size() + __ap[1].size() == 0) {
1726     __err |= ios_base::failbit;
1727     return;
1728   }
1729   ptrdiff_t __i = std::__scan_keyword(__b, __e, __ap, __ap + 2, __ct, __err, false) - __ap;
1730   if (__i == 0 && __h == 12)
1731     __h = 0;
1732   else if (__i == 1 && __h < 12)
1733     __h += 12;
1734 }
1735
1736 template <class _CharT, class _InputIterator>
1737 void time_get<_CharT, _InputIterator>::__get_percent(
1738     iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
1739   if (__b == __e) {
1740     __err |= ios_base::eofbit | ios_base::failbit;
1741     return;
1742   }
1743   if (__ct.narrow(*__b, 0) != '%')
1744     __err |= ios_base::failbit;
1745   else if (++__b == __e)
1746     __err |= ios_base::eofbit;
1747 }
1748
1749 // time_get end primitives
1750
1751 template <class _CharT, class _InputIterator>
1752 _InputIterator time_get<_CharT, _InputIterator>::get(
1753     iter_type __b,
1754     iter_type __e,
1755     ios_base& __iob,
1756     ios_base::iostate& __err,
1757     tm* __tm,
1758     const char_type* __fmtb,
1759     const char_type* __fmte) const {
1760   const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
1761   __err                        = ios_base::goodbit;
1762   while (__fmtb != __fmte && __err == ios_base::goodbit) {
1763     if (__b == __e) {
1764       __err = ios_base::failbit;
1765       break;
1766     }
1767     if (__ct.narrow(*__fmtb, 0) == '%') {
1768       if (++__fmtb == __fmte) {
1769         __err = ios_base::failbit;
1770         break;
1771       }
1772       char __cmd = __ct.narrow(*__fmtb, 0);
1773       char __opt = '\0';
1774       if (__cmd == 'E' || __cmd == '0') {
1775         if (++__fmtb == __fmte) {
1776           __err = ios_base::failbit;
1777           break;
1778         }
1779         __opt = __cmd;
1780         __cmd = __ct.narrow(*__fmtb, 0);
1781       }
1782       __b = do_get(__b, __e, __iob, __err, __tm, __cmd, __opt);
1783       ++__fmtb;
1784     } else if (__ct.is(ctype_base::space, *__fmtb)) {
1785       for (++__fmtb; __fmtb != __fmte && __ct.is(ctype_base::space, *__fmtb); ++__fmtb)
1786         ;
1787       for (; __b != __e && __ct.is(ctype_base::space, *__b); ++__b)
1788         ;
1789     } else if (__ct.toupper(*__b) == __ct.toupper(*__fmtb)) {
1790       ++__b;
1791       ++__fmtb;
1792     } else
1793       __err = ios_base::failbit;
1794   }
1795   if (__b == __e)
1796     __err |= ios_base::eofbit;
1797   return __b;
1798 }
1799
1800 template <class _CharT, class _InputIterator>
1801 typename time_get<_CharT, _InputIterator>::dateorder time_get<_CharT, _InputIterator>::do_date_order() const {
1802   return mdy;
1803 }
1804
1805 template <class _CharT, class _InputIterator>
1806 _InputIterator time_get<_CharT, _InputIterator>::do_get_time(
1807     iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
1808   const char_type __fmt[] = {'%', 'H', ':', '%', 'M', ':', '%', 'S'};
1809   return get(__b, __e, __iob, __err, __tm, __fmt, __fmt + sizeof(__fmt) / sizeof(__fmt[0]));
1810 }
1811
1812 template <class _CharT, class _InputIterator>
1813 _InputIterator time_get<_CharT, _InputIterator>::do_get_date(
1814     iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
1815   const string_type& __fmt = this->__x();
1816   return get(__b, __e, __iob, __err, __tm, __fmt.data(), __fmt.data() + __fmt.size());
1817 }
1818
1819 template <class _CharT, class _InputIterator>
1820 _InputIterator time_get<_CharT, _InputIterator>::do_get_weekday(
1821     iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
1822   const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
1823   __get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct);
1824   return __b;
1825 }
1826
1827 template <class _CharT, class _InputIterator>
1828 _InputIterator time_get<_CharT, _InputIterator>::do_get_monthname(
1829     iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
1830   const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
1831   __get_monthname(__tm->tm_mon, __b, __e, __err, __ct);
1832   return __b;
1833 }
1834
1835 template <class _CharT, class _InputIterator>
1836 _InputIterator time_get<_CharT, _InputIterator>::do_get_year(
1837     iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
1838   const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
1839   __get_year(__tm->tm_year, __b, __e, __err, __ct);
1840   return __b;
1841 }
1842
1843 template <class _CharT, class _InputIterator>
1844 _InputIterator time_get<_CharT, _InputIterator>::do_get(
1845     iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm, char __fmt, char) const {
1846   __err                        = ios_base::goodbit;
1847   const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
1848   switch (__fmt) {
1849   case 'a':
1850   case 'A':
1851     __get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct);
1852     break;
1853   case 'b':
1854   case 'B':
1855   case 'h':
1856     __get_monthname(__tm->tm_mon, __b, __e, __err, __ct);
1857     break;
1858   case 'c': {
1859     const string_type& __fm = this->__c();
1860     __b                     = get(__b, __e, __iob, __err, __tm, __fm.data(), __fm.data() + __fm.size());
1861   } break;
1862   case 'd':
1863   case 'e':
1864     __get_day(__tm->tm_mday, __b, __e, __err, __ct);
1865     break;
1866   case 'D': {
1867     const char_type __fm[] = {'%', 'm', '/', '%', 'd', '/', '%', 'y'};
1868     __b                    = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm) / sizeof(__fm[0]));
1869   } break;
1870   case 'F': {
1871     const char_type __fm[] = {'%', 'Y', '-', '%', 'm', '-', '%', 'd'};
1872     __b                    = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm) / sizeof(__fm[0]));
1873   } break;
1874   case 'H':
1875     __get_hour(__tm->tm_hour, __b, __e, __err, __ct);
1876     break;
1877   case 'I':
1878     __get_12_hour(__tm->tm_hour, __b, __e, __err, __ct);
1879     break;
1880   case 'j':
1881     __get_day_year_num(__tm->tm_yday, __b, __e, __err, __ct);
1882     break;
1883   case 'm':
1884     __get_month(__tm->tm_mon, __b, __e, __err, __ct);
1885     break;
1886   case 'M':
1887     __get_minute(__tm->tm_min, __b, __e, __err, __ct);
1888     break;
1889   case 'n':
1890   case 't':
1891     __get_white_space(__b, __e, __err, __ct);
1892     break;
1893   case 'p':
1894     __get_am_pm(__tm->tm_hour, __b, __e, __err, __ct);
1895     break;
1896   case 'r': {
1897     const char_type __fm[] = {'%', 'I', ':', '%', 'M', ':', '%', 'S', ' ', '%', 'p'};
1898     __b                    = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm) / sizeof(__fm[0]));
1899   } break;
1900   case 'R': {
1901     const char_type __fm[] = {'%', 'H', ':', '%', 'M'};
1902     __b                    = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm) / sizeof(__fm[0]));
1903   } break;
1904   case 'S':
1905     __get_second(__tm->tm_sec, __b, __e, __err, __ct);
1906     break;
1907   case 'T': {
1908     const char_type __fm[] = {'%', 'H', ':', '%', 'M', ':', '%', 'S'};
1909     __b                    = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm) / sizeof(__fm[0]));
1910   } break;
1911   case 'w':
1912     __get_weekday(__tm->tm_wday, __b, __e, __err, __ct);
1913     break;
1914   case 'x':
1915     return do_get_date(__b, __e, __iob, __err, __tm);
1916   case 'X': {
1917     const string_type& __fm = this->__X();
1918     __b                     = get(__b, __e, __iob, __err, __tm, __fm.data(), __fm.data() + __fm.size());
1919   } break;
1920   case 'y':
1921     __get_year(__tm->tm_year, __b, __e, __err, __ct);
1922     break;
1923   case 'Y':
1924     __get_year4(__tm->tm_year, __b, __e, __err, __ct);
1925     break;
1926   case '%':
1927     __get_percent(__b, __e, __err, __ct);
1928     break;
1929   default:
1930     __err |= ios_base::failbit;
1931   }
1932   return __b;
1933 }
1934
1935 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get<char>;
1936 #  if _LIBCPP_HAS_WIDE_CHARACTERS
1937 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get<wchar_t>;
1938 #  endif
1939
1940 class _LIBCPP_EXPORTED_FROM_ABI __time_get {
1941 protected:
1942   __locale::__locale_t __loc_;
1943
1944   __time_get(const char* __nm);
1945   __time_get(const string& __nm);
1946   ~__time_get();
1947 };
1948
1949 template <class _CharT>
1950 class _LIBCPP_TEMPLATE_VIS __time_get_storage : public __time_get {
1951 protected:
1952   typedef basic_string<_CharT> string_type;
1953
1954   string_type __weeks_[14];
1955   string_type __months_[24];
1956   string_type __am_pm_[2];
1957   string_type __c_;
1958   string_type __r_;
1959   string_type __x_;
1960   string_type __X_;
1961
1962   explicit __time_get_storage(const char* __nm);
1963   explicit __time_get_storage(const string& __nm);
1964
1965   _LIBCPP_HIDE_FROM_ABI ~__time_get_storage() {}
1966
1967   time_base::dateorder __do_date_order() const;
1968
1969 private:
1970   void init(const ctype<_CharT>&);
1971   string_type __analyze(char __fmt, const ctype<_CharT>&);
1972 };
1973
1974 #  define _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(_CharT)                                                      \
1975     template <>                                                                                                        \
1976     _LIBCPP_EXPORTED_FROM_ABI time_base::dateorder __time_get_storage<_CharT>::__do_date_order() const;                \
1977     template <>                                                                                                        \
1978     _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::__time_get_storage(const char*);                             \
1979     template <>                                                                                                        \
1980     _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::__time_get_storage(const string&);                           \
1981     template <>                                                                                                        \
1982     _LIBCPP_EXPORTED_FROM_ABI void __time_get_storage<_CharT>::init(const ctype<_CharT>&);                             \
1983     template <>                                                                                                        \
1984     _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::string_type __time_get_storage<_CharT>::__analyze(           \
1985         char, const ctype<_CharT>&);                                                                                   \
1986     extern template _LIBCPP_EXPORTED_FROM_ABI time_base::dateorder __time_get_storage<_CharT>::__do_date_order()       \
1987         const;                                                                                                         \
1988     extern template _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::__time_get_storage(const char*);             \
1989     extern template _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::__time_get_storage(const string&);           \
1990     extern template _LIBCPP_EXPORTED_FROM_ABI void __time_get_storage<_CharT>::init(const ctype<_CharT>&);             \
1991     extern template _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::string_type                                  \
1992     __time_get_storage<_CharT>::__analyze(char, const ctype<_CharT>&);                                                 \
1993     /**/
1994
1995 _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(char)
1996 #  if _LIBCPP_HAS_WIDE_CHARACTERS
1997 _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(wchar_t)
1998 #  endif
1999 #  undef _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION
2000
2001 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
2002 class _LIBCPP_TEMPLATE_VIS time_get_byname
2003     : public time_get<_CharT, _InputIterator>,
2004       private __time_get_storage<_CharT> {
2005 public:
2006   typedef time_base::dateorder dateorder;
2007   typedef _InputIterator iter_type;
2008   typedef _CharT char_type;
2009   typedef basic_string<char_type> string_type;
2010
2011   _LIBCPP_HIDE_FROM_ABI explicit time_get_byname(const char* __nm, size_t __refs = 0)
2012       : time_get<_CharT, _InputIterator>(__refs), __time_get_storage<_CharT>(__nm) {}
2013   _LIBCPP_HIDE_FROM_ABI explicit time_get_byname(const string& __nm, size_t __refs = 0)
2014       : time_get<_CharT, _InputIterator>(__refs), __time_get_storage<_CharT>(__nm) {}
2015
2016 protected:
2017   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~time_get_byname() override {}
2018
2019   _LIBCPP_HIDE_FROM_ABI_VIRTUAL dateorder do_date_order() const override { return this->__do_date_order(); }
2020
2021 private:
2022   _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type* __weeks() const override { return this->__weeks_; }
2023   _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type* __months() const override { return this->__months_; }
2024   _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type* __am_pm() const override { return this->__am_pm_; }
2025   _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type& __c() const override { return this->__c_; }
2026   _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type& __r() const override { return this->__r_; }
2027   _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type& __x() const override { return this->__x_; }
2028   _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type& __X() const override { return this->__X_; }
2029 };
2030
2031 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<char>;
2032 #  if _LIBCPP_HAS_WIDE_CHARACTERS
2033 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<wchar_t>;
2034 #  endif
2035
2036 class _LIBCPP_EXPORTED_FROM_ABI __time_put {
2037   __locale::__locale_t __loc_;
2038
2039 protected:
2040   _LIBCPP_HIDE_FROM_ABI __time_put() : __loc_(_LIBCPP_GET_C_LOCALE) {}
2041   __time_put(const char* __nm);
2042   __time_put(const string& __nm);
2043   ~__time_put();
2044   void __do_put(char* __nb, char*& __ne, const tm* __tm, char __fmt, char __mod) const;
2045 #  if _LIBCPP_HAS_WIDE_CHARACTERS
2046   void __do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm, char __fmt, char __mod) const;
2047 #  endif
2048 };
2049
2050 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
2051 class _LIBCPP_TEMPLATE_VIS time_put : public locale::facet, private __time_put {
2052 public:
2053   typedef _CharT char_type;
2054   typedef _OutputIterator iter_type;
2055
2056   _LIBCPP_HIDE_FROM_ABI explicit time_put(size_t __refs = 0) : locale::facet(__refs) {}
2057
2058   iter_type
2059   put(iter_type __s, ios_base& __iob, char_type __fl, const tm* __tm, const char_type* __pb, const char_type* __pe)
2060       const;
2061
2062   _LIBCPP_HIDE_FROM_ABI iter_type
2063   put(iter_type __s, ios_base& __iob, char_type __fl, const tm* __tm, char __fmt, char __mod = 0) const {
2064     return do_put(__s, __iob, __fl, __tm, __fmt, __mod);
2065   }
2066
2067   static locale::id id;
2068
2069 protected:
2070   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~time_put() override {}
2071   virtual iter_type do_put(iter_type __s, ios_base&, char_type, const tm* __tm, char __fmt, char __mod) const;
2072
2073   _LIBCPP_HIDE_FROM_ABI explicit time_put(const char* __nm, size_t __refs) : locale::facet(__refs), __time_put(__nm) {}
2074   _LIBCPP_HIDE_FROM_ABI explicit time_put(const string& __nm, size_t __refs)
2075       : locale::facet(__refs), __time_put(__nm) {}
2076 };
2077
2078 template <class _CharT, class _OutputIterator>
2079 locale::id time_put<_CharT, _OutputIterator>::id;
2080
2081 template <class _CharT, class _OutputIterator>
2082 _OutputIterator time_put<_CharT, _OutputIterator>::put(
2083     iter_type __s, ios_base& __iob, char_type __fl, const tm* __tm, const char_type* __pb, const char_type* __pe)
2084     const {
2085   const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
2086   for (; __pb != __pe; ++__pb) {
2087     if (__ct.narrow(*__pb, 0) == '%') {
2088       if (++__pb == __pe) {
2089         *__s++ = __pb[-1];
2090         break;
2091       }
2092       char __mod = 0;
2093       char __fmt = __ct.narrow(*__pb, 0);
2094       if (__fmt == 'E' || __fmt == 'O') {
2095         if (++__pb == __pe) {
2096           *__s++ = __pb[-2];
2097           *__s++ = __pb[-1];
2098           break;
2099         }
2100         __mod = __fmt;
2101         __fmt = __ct.narrow(*__pb, 0);
2102       }
2103       __s = do_put(__s, __iob, __fl, __tm, __fmt, __mod);
2104     } else
2105       *__s++ = *__pb;
2106   }
2107   return __s;
2108 }
2109
2110 template <class _CharT, class _OutputIterator>
2111 _OutputIterator time_put<_CharT, _OutputIterator>::do_put(
2112     iter_type __s, ios_base&, char_type, const tm* __tm, char __fmt, char __mod) const {
2113   char_type __nar[100];
2114   char_type* __nb = __nar;
2115   char_type* __ne = __nb + 100;
2116   __do_put(__nb, __ne, __tm, __fmt, __mod);
2117   return std::copy(__nb, __ne, __s);
2118 }
2119
2120 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<char>;
2121 #  if _LIBCPP_HAS_WIDE_CHARACTERS
2122 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<wchar_t>;
2123 #  endif
2124
2125 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
2126 class _LIBCPP_TEMPLATE_VIS time_put_byname : public time_put<_CharT, _OutputIterator> {
2127 public:
2128   _LIBCPP_HIDE_FROM_ABI explicit time_put_byname(const char* __nm, size_t __refs = 0)
2129       : time_put<_CharT, _OutputIterator>(__nm, __refs) {}
2130
2131   _LIBCPP_HIDE_FROM_ABI explicit time_put_byname(const string& __nm, size_t __refs = 0)
2132       : time_put<_CharT, _OutputIterator>(__nm, __refs) {}
2133
2134 protected:
2135   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~time_put_byname() override {}
2136 };
2137
2138 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<char>;
2139 #  if _LIBCPP_HAS_WIDE_CHARACTERS
2140 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<wchar_t>;
2141 #  endif
2142
2143 // money_base
2144
2145 class _LIBCPP_EXPORTED_FROM_ABI money_base {
2146 public:
2147   enum part { none, space, symbol, sign, value };
2148   struct pattern {
2149     char field[4];
2150   };
2151
2152   _LIBCPP_HIDE_FROM_ABI money_base() {}
2153 };
2154
2155 // moneypunct
2156
2157 template <class _CharT, bool _International = false>
2158 class _LIBCPP_TEMPLATE_VIS moneypunct : public locale::facet, public money_base {
2159 public:
2160   typedef _CharT char_type;
2161   typedef basic_string<char_type> string_type;
2162
2163   _LIBCPP_HIDE_FROM_ABI explicit moneypunct(size_t __refs = 0) : locale::facet(__refs) {}
2164
2165   _LIBCPP_HIDE_FROM_ABI char_type decimal_point() const { return do_decimal_point(); }
2166   _LIBCPP_HIDE_FROM_ABI char_type thousands_sep() const { return do_thousands_sep(); }
2167   _LIBCPP_HIDE_FROM_ABI string grouping() const { return do_grouping(); }
2168   _LIBCPP_HIDE_FROM_ABI string_type curr_symbol() const { return do_curr_symbol(); }
2169   _LIBCPP_HIDE_FROM_ABI string_type positive_sign() const { return do_positive_sign(); }
2170   _LIBCPP_HIDE_FROM_ABI string_type negative_sign() const { return do_negative_sign(); }
2171   _LIBCPP_HIDE_FROM_ABI int frac_digits() const { return do_frac_digits(); }
2172   _LIBCPP_HIDE_FROM_ABI pattern pos_format() const { return do_pos_format(); }
2173   _LIBCPP_HIDE_FROM_ABI pattern neg_format() const { return do_neg_format(); }
2174
2175   static locale::id id;
2176   static const bool intl = _International;
2177
2178 protected:
2179   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~moneypunct() override {}
2180
2181   virtual char_type do_decimal_point() const { return numeric_limits<char_type>::max(); }
2182   virtual char_type do_thousands_sep() const { return numeric_limits<char_type>::max(); }
2183   virtual string do_grouping() const { return string(); }
2184   virtual string_type do_curr_symbol() const { return string_type(); }
2185   virtual string_type do_positive_sign() const { return string_type(); }
2186   virtual string_type do_negative_sign() const { return string_type(1, '-'); }
2187   virtual int do_frac_digits() const { return 0; }
2188   virtual pattern do_pos_format() const {
2189     pattern __p = {{symbol, sign, none, value}};
2190     return __p;
2191   }
2192   virtual pattern do_neg_format() const {
2193     pattern __p = {{symbol, sign, none, value}};
2194     return __p;
2195   }
2196 };
2197
2198 template <class _CharT, bool _International>
2199 locale::id moneypunct<_CharT, _International>::id;
2200
2201 template <class _CharT, bool _International>
2202 const bool moneypunct<_CharT, _International>::intl;
2203
2204 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, false>;
2205 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, true>;
2206 #  if _LIBCPP_HAS_WIDE_CHARACTERS
2207 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, false>;
2208 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, true>;
2209 #  endif
2210
2211 // moneypunct_byname
2212
2213 template <class _CharT, bool _International = false>
2214 class _LIBCPP_TEMPLATE_VIS moneypunct_byname : public moneypunct<_CharT, _International> {
2215 public:
2216   typedef money_base::pattern pattern;
2217   typedef _CharT char_type;
2218   typedef basic_string<char_type> string_type;
2219
2220   _LIBCPP_HIDE_FROM_ABI explicit moneypunct_byname(const char* __nm, size_t __refs = 0)
2221       : moneypunct<_CharT, _International>(__refs) {
2222     init(__nm);
2223   }
2224
2225   _LIBCPP_HIDE_FROM_ABI explicit moneypunct_byname(const string& __nm, size_t __refs = 0)
2226       : moneypunct<_CharT, _International>(__refs) {
2227     init(__nm.c_str());
2228   }
2229
2230 protected:
2231   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~moneypunct_byname() override {}
2232
2233   char_type do_decimal_point() const override { return __decimal_point_; }
2234   char_type do_thousands_sep() const override { return __thousands_sep_; }
2235   string do_grouping() const override { return __grouping_; }
2236   string_type do_curr_symbol() const override { return __curr_symbol_; }
2237   string_type do_positive_sign() const override { return __positive_sign_; }
2238   string_type do_negative_sign() const override { return __negative_sign_; }
2239   int do_frac_digits() const override { return __frac_digits_; }
2240   pattern do_pos_format() const override { return __pos_format_; }
2241   pattern do_neg_format() const override { return __neg_format_; }
2242
2243 private:
2244   char_type __decimal_point_;
2245   char_type __thousands_sep_;
2246   string __grouping_;
2247   string_type __curr_symbol_;
2248   string_type __positive_sign_;
2249   string_type __negative_sign_;
2250   int __frac_digits_;
2251   pattern __pos_format_;
2252   pattern __neg_format_;
2253
2254   void init(const char*);
2255 };
2256
2257 template <>
2258 _LIBCPP_EXPORTED_FROM_ABI void moneypunct_byname<char, false>::init(const char*);
2259 template <>
2260 _LIBCPP_EXPORTED_FROM_ABI void moneypunct_byname<char, true>::init(const char*);
2261 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, false>;
2262 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, true>;
2263
2264 #  if _LIBCPP_HAS_WIDE_CHARACTERS
2265 template <>
2266 _LIBCPP_EXPORTED_FROM_ABI void moneypunct_byname<wchar_t, false>::init(const char*);
2267 template <>
2268 _LIBCPP_EXPORTED_FROM_ABI void moneypunct_byname<wchar_t, true>::init(const char*);
2269 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, false>;
2270 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, true>;
2271 #  endif
2272
2273 // money_get
2274
2275 template <class _CharT>
2276 class __money_get {
2277 protected:
2278   typedef _CharT char_type;
2279   typedef basic_string<char_type> string_type;
2280
2281   _LIBCPP_HIDE_FROM_ABI __money_get() {}
2282
2283   static void __gather_info(
2284       bool __intl,
2285       const locale& __loc,
2286       money_base::pattern& __pat,
2287       char_type& __dp,
2288       char_type& __ts,
2289       string& __grp,
2290       string_type& __sym,
2291       string_type& __psn,
2292       string_type& __nsn,
2293       int& __fd);
2294 };
2295
2296 template <class _CharT>
2297 void __money_get<_CharT>::__gather_info(
2298     bool __intl,
2299     const locale& __loc,
2300     money_base::pattern& __pat,
2301     char_type& __dp,
2302     char_type& __ts,
2303     string& __grp,
2304     string_type& __sym,
2305     string_type& __psn,
2306     string_type& __nsn,
2307     int& __fd) {
2308   if (__intl) {
2309     const moneypunct<char_type, true>& __mp = std::use_facet<moneypunct<char_type, true> >(__loc);
2310     __pat                                   = __mp.neg_format();
2311     __nsn                                   = __mp.negative_sign();
2312     __psn                                   = __mp.positive_sign();
2313     __dp                                    = __mp.decimal_point();
2314     __ts                                    = __mp.thousands_sep();
2315     __grp                                   = __mp.grouping();
2316     __sym                                   = __mp.curr_symbol();
2317     __fd                                    = __mp.frac_digits();
2318   } else {
2319     const moneypunct<char_type, false>& __mp = std::use_facet<moneypunct<char_type, false> >(__loc);
2320     __pat                                    = __mp.neg_format();
2321     __nsn                                    = __mp.negative_sign();
2322     __psn                                    = __mp.positive_sign();
2323     __dp                                     = __mp.decimal_point();
2324     __ts                                     = __mp.thousands_sep();
2325     __grp                                    = __mp.grouping();
2326     __sym                                    = __mp.curr_symbol();
2327     __fd                                     = __mp.frac_digits();
2328   }
2329 }
2330
2331 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<char>;
2332 #  if _LIBCPP_HAS_WIDE_CHARACTERS
2333 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<wchar_t>;
2334 #  endif
2335
2336 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
2337 class _LIBCPP_TEMPLATE_VIS money_get : public locale::facet, private __money_get<_CharT> {
2338 public:
2339   typedef _CharT char_type;
2340   typedef _InputIterator iter_type;
2341   typedef basic_string<char_type> string_type;
2342
2343   _LIBCPP_HIDE_FROM_ABI explicit money_get(size_t __refs = 0) : locale::facet(__refs) {}
2344
2345   _LIBCPP_HIDE_FROM_ABI iter_type
2346   get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, long double& __v) const {
2347     return do_get(__b, __e, __intl, __iob, __err, __v);
2348   }
2349
2350   _LIBCPP_HIDE_FROM_ABI iter_type
2351   get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, string_type& __v) const {
2352     return do_get(__b, __e, __intl, __iob, __err, __v);
2353   }
2354
2355   static locale::id id;
2356
2357 protected:
2358   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~money_get() override {}
2359
2360   virtual iter_type
2361   do_get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, long double& __v) const;
2362   virtual iter_type
2363   do_get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, string_type& __v) const;
2364
2365 private:
2366   static bool __do_get(
2367       iter_type& __b,
2368       iter_type __e,
2369       bool __intl,
2370       const locale& __loc,
2371       ios_base::fmtflags __flags,
2372       ios_base::iostate& __err,
2373       bool& __neg,
2374       const ctype<char_type>& __ct,
2375       unique_ptr<char_type, void (*)(void*)>& __wb,
2376       char_type*& __wn,
2377       char_type* __we);
2378 };
2379
2380 template <class _CharT, class _InputIterator>
2381 locale::id money_get<_CharT, _InputIterator>::id;
2382
2383 _LIBCPP_EXPORTED_FROM_ABI void __do_nothing(void*);
2384
2385 template <class _Tp>
2386 _LIBCPP_HIDE_FROM_ABI void __double_or_nothing(unique_ptr<_Tp, void (*)(void*)>& __b, _Tp*& __n, _Tp*& __e) {
2387   bool __owns      = __b.get_deleter() != __do_nothing;
2388   size_t __cur_cap = static_cast<size_t>(__e - __b.get()) * sizeof(_Tp);
2389   size_t __new_cap = __cur_cap < numeric_limits<size_t>::max() / 2 ? 2 * __cur_cap : numeric_limits<size_t>::max();
2390   if (__new_cap == 0)
2391     __new_cap = sizeof(_Tp);
2392   size_t __n_off = static_cast<size_t>(__n - __b.get());
2393   _Tp* __t       = (_Tp*)std::realloc(__owns ? __b.get() : 0, __new_cap);
2394   if (__t == 0)
2395     __throw_bad_alloc();
2396   if (__owns)
2397     __b.release();
2398   __b = unique_ptr<_Tp, void (*)(void*)>(__t, free);
2399   __new_cap /= sizeof(_Tp);
2400   __n = __b.get() + __n_off;
2401   __e = __b.get() + __new_cap;
2402 }
2403
2404 // true == success
2405 template <class _CharT, class _InputIterator>
2406 bool money_get<_CharT, _InputIterator>::__do_get(
2407     iter_type& __b,
2408     iter_type __e,
2409     bool __intl,
2410     const locale& __loc,
2411     ios_base::fmtflags __flags,
2412     ios_base::iostate& __err,
2413     bool& __neg,
2414     const ctype<char_type>& __ct,
2415     unique_ptr<char_type, void (*)(void*)>& __wb,
2416     char_type*& __wn,
2417     char_type* __we) {
2418   if (__b == __e) {
2419     __err |= ios_base::failbit;
2420     return false;
2421   }
2422   const unsigned __bz = 100;
2423   unsigned __gbuf[__bz];
2424   unique_ptr<unsigned, void (*)(void*)> __gb(__gbuf, __do_nothing);
2425   unsigned* __gn = __gb.get();
2426   unsigned* __ge = __gn + __bz;
2427   money_base::pattern __pat;
2428   char_type __dp;
2429   char_type __ts;
2430   string __grp;
2431   string_type __sym;
2432   string_type __psn;
2433   string_type __nsn;
2434   // Capture the spaces read into money_base::{space,none} so they
2435   // can be compared to initial spaces in __sym.
2436   string_type __spaces;
2437   int __fd;
2438   __money_get<_CharT>::__gather_info(__intl, __loc, __pat, __dp, __ts, __grp, __sym, __psn, __nsn, __fd);
2439   const string_type* __trailing_sign = 0;
2440   __wn                               = __wb.get();
2441   for (unsigned __p = 0; __p < 4 && __b != __e; ++__p) {
2442     switch (__pat.field[__p]) {
2443     case money_base::space:
2444       if (__p != 3) {
2445         if (__ct.is(ctype_base::space, *__b))
2446           __spaces.push_back(*__b++);
2447         else {
2448           __err |= ios_base::failbit;
2449           return false;
2450         }
2451       }
2452       _LIBCPP_FALLTHROUGH();
2453     case money_base::none:
2454       if (__p != 3) {
2455         while (__b != __e && __ct.is(ctype_base::space, *__b))
2456           __spaces.push_back(*__b++);
2457       }
2458       break;
2459     case money_base::sign:
2460       if (__psn.size() > 0 && *__b == __psn[0]) {
2461         ++__b;
2462         __neg = false;
2463         if (__psn.size() > 1)
2464           __trailing_sign = &__psn;
2465         break;
2466       }
2467       if (__nsn.size() > 0 && *__b == __nsn[0]) {
2468         ++__b;
2469         __neg = true;
2470         if (__nsn.size() > 1)
2471           __trailing_sign = &__nsn;
2472         break;
2473       }
2474       if (__psn.size() > 0 && __nsn.size() > 0) { // sign is required
2475         __err |= ios_base::failbit;
2476         return false;
2477       }
2478       if (__psn.size() == 0 && __nsn.size() == 0)
2479         // locale has no way of specifying a sign. Use the initial value of __neg as a default
2480         break;
2481       __neg = (__nsn.size() == 0);
2482       break;
2483     case money_base::symbol: {
2484       bool __more_needed =
2485           __trailing_sign || (__p < 2) || (__p == 2 && __pat.field[3] != static_cast<char>(money_base::none));
2486       bool __sb = (__flags & ios_base::showbase) != 0;
2487       if (__sb || __more_needed) {
2488         typename string_type::const_iterator __sym_space_end = __sym.begin();
2489         if (__p > 0 && (__pat.field[__p - 1] == money_base::none || __pat.field[__p - 1] == money_base::space)) {
2490           // Match spaces we've already read against spaces at
2491           // the beginning of __sym.
2492           while (__sym_space_end != __sym.end() && __ct.is(ctype_base::space, *__sym_space_end))
2493             ++__sym_space_end;
2494           const size_t __num_spaces = __sym_space_end - __sym.begin();
2495           if (__num_spaces > __spaces.size() ||
2496               !std::equal(__spaces.end() - __num_spaces, __spaces.end(), __sym.begin())) {
2497             // No match. Put __sym_space_end back at the
2498             // beginning of __sym, which will prevent a
2499             // match in the next loop.
2500             __sym_space_end = __sym.begin();
2501           }
2502         }
2503         typename string_type::const_iterator __sym_curr_char = __sym_space_end;
2504         while (__sym_curr_char != __sym.end() && __b != __e && *__b == *__sym_curr_char) {
2505           ++__b;
2506           ++__sym_curr_char;
2507         }
2508         if (__sb && __sym_curr_char != __sym.end()) {
2509           __err |= ios_base::failbit;
2510           return false;
2511         }
2512       }
2513     } break;
2514     case money_base::value: {
2515       unsigned __ng = 0;
2516       for (; __b != __e; ++__b) {
2517         char_type __c = *__b;
2518         if (__ct.is(ctype_base::digit, __c)) {
2519           if (__wn == __we)
2520             std::__double_or_nothing(__wb, __wn, __we);
2521           *__wn++ = __c;
2522           ++__ng;
2523         } else if (__grp.size() > 0 && __ng > 0 && __c == __ts) {
2524           if (__gn == __ge)
2525             std::__double_or_nothing(__gb, __gn, __ge);
2526           *__gn++ = __ng;
2527           __ng    = 0;
2528         } else
2529           break;
2530       }
2531       if (__gb.get() != __gn && __ng > 0) {
2532         if (__gn == __ge)
2533           std::__double_or_nothing(__gb, __gn, __ge);
2534         *__gn++ = __ng;
2535       }
2536       if (__fd > 0) {
2537         if (__b == __e || *__b != __dp) {
2538           __err |= ios_base::failbit;
2539           return false;
2540         }
2541         for (++__b; __fd > 0; --__fd, ++__b) {
2542           if (__b == __e || !__ct.is(ctype_base::digit, *__b)) {
2543             __err |= ios_base::failbit;
2544             return false;
2545           }
2546           if (__wn == __we)
2547             std::__double_or_nothing(__wb, __wn, __we);
2548           *__wn++ = *__b;
2549         }
2550       }
2551       if (__wn == __wb.get()) {
2552         __err |= ios_base::failbit;
2553         return false;
2554       }
2555     } break;
2556     }
2557   }
2558   if (__trailing_sign) {
2559     for (unsigned __i = 1; __i < __trailing_sign->size(); ++__i, ++__b) {
2560       if (__b == __e || *__b != (*__trailing_sign)[__i]) {
2561         __err |= ios_base::failbit;
2562         return false;
2563       }
2564     }
2565   }
2566   if (__gb.get() != __gn) {
2567     ios_base::iostate __et = ios_base::goodbit;
2568     __check_grouping(__grp, __gb.get(), __gn, __et);
2569     if (__et) {
2570       __err |= ios_base::failbit;
2571       return false;
2572     }
2573   }
2574   return true;
2575 }
2576
2577 template <class _CharT, class _InputIterator>
2578 _InputIterator money_get<_CharT, _InputIterator>::do_get(
2579     iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, long double& __v) const {
2580   const int __bz = 100;
2581   char_type __wbuf[__bz];
2582   unique_ptr<char_type, void (*)(void*)> __wb(__wbuf, __do_nothing);
2583   char_type* __wn;
2584   char_type* __we              = __wbuf + __bz;
2585   locale __loc                 = __iob.getloc();
2586   const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
2587   bool __neg                   = false;
2588   if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct, __wb, __wn, __we)) {
2589     const char __src[] = "0123456789";
2590     char_type __atoms[sizeof(__src) - 1];
2591     __ct.widen(__src, __src + (sizeof(__src) - 1), __atoms);
2592     char __nbuf[__bz];
2593     char* __nc = __nbuf;
2594     unique_ptr<char, void (*)(void*)> __h(nullptr, free);
2595     if (__wn - __wb.get() > __bz - 2) {
2596       __h.reset((char*)malloc(static_cast<size_t>(__wn - __wb.get() + 2)));
2597       if (__h.get() == nullptr)
2598         __throw_bad_alloc();
2599       __nc = __h.get();
2600     }
2601     if (__neg)
2602       *__nc++ = '-';
2603     for (const char_type* __w = __wb.get(); __w < __wn; ++__w, ++__nc)
2604       *__nc = __src[std::find(__atoms, std::end(__atoms), *__w) - __atoms];
2605     *__nc = char();
2606     if (sscanf(__nbuf, "%Lf", &__v) != 1)
2607       __throw_runtime_error("money_get error");
2608   }
2609   if (__b == __e)
2610     __err |= ios_base::eofbit;
2611   return __b;
2612 }
2613
2614 template <class _CharT, class _InputIterator>
2615 _InputIterator money_get<_CharT, _InputIterator>::do_get(
2616     iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, string_type& __v) const {
2617   const int __bz = 100;
2618   char_type __wbuf[__bz];
2619   unique_ptr<char_type, void (*)(void*)> __wb(__wbuf, __do_nothing);
2620   char_type* __wn;
2621   char_type* __we              = __wbuf + __bz;
2622   locale __loc                 = __iob.getloc();
2623   const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
2624   bool __neg                   = false;
2625   if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct, __wb, __wn, __we)) {
2626     __v.clear();
2627     if (__neg)
2628       __v.push_back(__ct.widen('-'));
2629     char_type __z = __ct.widen('0');
2630     char_type* __w;
2631     for (__w = __wb.get(); __w < __wn - 1; ++__w)
2632       if (*__w != __z)
2633         break;
2634     __v.append(__w, __wn);
2635   }
2636   if (__b == __e)
2637     __err |= ios_base::eofbit;
2638   return __b;
2639 }
2640
2641 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<char>;
2642 #  if _LIBCPP_HAS_WIDE_CHARACTERS
2643 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<wchar_t>;
2644 #  endif
2645
2646 // money_put
2647
2648 template <class _CharT>
2649 class __money_put {
2650 protected:
2651   typedef _CharT char_type;
2652   typedef basic_string<char_type> string_type;
2653
2654   _LIBCPP_HIDE_FROM_ABI __money_put() {}
2655
2656   static void __gather_info(
2657       bool __intl,
2658       bool __neg,
2659       const locale& __loc,
2660       money_base::pattern& __pat,
2661       char_type& __dp,
2662       char_type& __ts,
2663       string& __grp,
2664       string_type& __sym,
2665       string_type& __sn,
2666       int& __fd);
2667   static void __format(
2668       char_type* __mb,
2669       char_type*& __mi,
2670       char_type*& __me,
2671       ios_base::fmtflags __flags,
2672       const char_type* __db,
2673       const char_type* __de,
2674       const ctype<char_type>& __ct,
2675       bool __neg,
2676       const money_base::pattern& __pat,
2677       char_type __dp,
2678       char_type __ts,
2679       const string& __grp,
2680       const string_type& __sym,
2681       const string_type& __sn,
2682       int __fd);
2683 };
2684
2685 template <class _CharT>
2686 void __money_put<_CharT>::__gather_info(
2687     bool __intl,
2688     bool __neg,
2689     const locale& __loc,
2690     money_base::pattern& __pat,
2691     char_type& __dp,
2692     char_type& __ts,
2693     string& __grp,
2694     string_type& __sym,
2695     string_type& __sn,
2696     int& __fd) {
2697   if (__intl) {
2698     const moneypunct<char_type, true>& __mp = std::use_facet<moneypunct<char_type, true> >(__loc);
2699     if (__neg) {
2700       __pat = __mp.neg_format();
2701       __sn  = __mp.negative_sign();
2702     } else {
2703       __pat = __mp.pos_format();
2704       __sn  = __mp.positive_sign();
2705     }
2706     __dp  = __mp.decimal_point();
2707     __ts  = __mp.thousands_sep();
2708     __grp = __mp.grouping();
2709     __sym = __mp.curr_symbol();
2710     __fd  = __mp.frac_digits();
2711   } else {
2712     const moneypunct<char_type, false>& __mp = std::use_facet<moneypunct<char_type, false> >(__loc);
2713     if (__neg) {
2714       __pat = __mp.neg_format();
2715       __sn  = __mp.negative_sign();
2716     } else {
2717       __pat = __mp.pos_format();
2718       __sn  = __mp.positive_sign();
2719     }
2720     __dp  = __mp.decimal_point();
2721     __ts  = __mp.thousands_sep();
2722     __grp = __mp.grouping();
2723     __sym = __mp.curr_symbol();
2724     __fd  = __mp.frac_digits();
2725   }
2726 }
2727
2728 template <class _CharT>
2729 void __money_put<_CharT>::__format(
2730     char_type* __mb,
2731     char_type*& __mi,
2732     char_type*& __me,
2733     ios_base::fmtflags __flags,
2734     const char_type* __db,
2735     const char_type* __de,
2736     const ctype<char_type>& __ct,
2737     bool __neg,
2738     const money_base::pattern& __pat,
2739     char_type __dp,
2740     char_type __ts,
2741     const string& __grp,
2742     const string_type& __sym,
2743     const string_type& __sn,
2744     int __fd) {
2745   __me = __mb;
2746   for (char __p : __pat.field) {
2747     switch (__p) {
2748     case money_base::none:
2749       __mi = __me;
2750       break;
2751     case money_base::space:
2752       __mi    = __me;
2753       *__me++ = __ct.widen(' ');
2754       break;
2755     case money_base::sign:
2756       if (!__sn.empty())
2757         *__me++ = __sn[0];
2758       break;
2759     case money_base::symbol:
2760       if (!__sym.empty() && (__flags & ios_base::showbase))
2761         __me = std::copy(__sym.begin(), __sym.end(), __me);
2762       break;
2763     case money_base::value: {
2764       // remember start of value so we can reverse it
2765       char_type* __t = __me;
2766       // find beginning of digits
2767       if (__neg)
2768         ++__db;
2769       // find end of digits
2770       const char_type* __d;
2771       for (__d = __db; __d < __de; ++__d)
2772         if (!__ct.is(ctype_base::digit, *__d))
2773           break;
2774       // print fractional part
2775       if (__fd > 0) {
2776         int __f;
2777         for (__f = __fd; __d > __db && __f > 0; --__f)
2778           *__me++ = *--__d;
2779         char_type __z = __f > 0 ? __ct.widen('0') : char_type();
2780         for (; __f > 0; --__f)
2781           *__me++ = __z;
2782         *__me++ = __dp;
2783       }
2784       // print units part
2785       if (__d == __db) {
2786         *__me++ = __ct.widen('0');
2787       } else {
2788         unsigned __ng = 0;
2789         unsigned __ig = 0;
2790         unsigned __gl = __grp.empty() ? numeric_limits<unsigned>::max() : static_cast<unsigned>(__grp[__ig]);
2791         while (__d != __db) {
2792           if (__ng == __gl) {
2793             *__me++ = __ts;
2794             __ng    = 0;
2795             if (++__ig < __grp.size())
2796               __gl = __grp[__ig] == numeric_limits<char>::max()
2797                        ? numeric_limits<unsigned>::max()
2798                        : static_cast<unsigned>(__grp[__ig]);
2799           }
2800           *__me++ = *--__d;
2801           ++__ng;
2802         }
2803       }
2804       // reverse it
2805       std::reverse(__t, __me);
2806     } break;
2807     }
2808   }
2809   // print rest of sign, if any
2810   if (__sn.size() > 1)
2811     __me = std::copy(__sn.begin() + 1, __sn.end(), __me);
2812   // set alignment
2813   if ((__flags & ios_base::adjustfield) == ios_base::left)
2814     __mi = __me;
2815   else if ((__flags & ios_base::adjustfield) != ios_base::internal)
2816     __mi = __mb;
2817 }
2818
2819 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<char>;
2820 #  if _LIBCPP_HAS_WIDE_CHARACTERS
2821 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<wchar_t>;
2822 #  endif
2823
2824 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
2825 class _LIBCPP_TEMPLATE_VIS money_put : public locale::facet, private __money_put<_CharT> {
2826 public:
2827   typedef _CharT char_type;
2828   typedef _OutputIterator iter_type;
2829   typedef basic_string<char_type> string_type;
2830
2831   _LIBCPP_HIDE_FROM_ABI explicit money_put(size_t __refs = 0) : locale::facet(__refs) {}
2832
2833   _LIBCPP_HIDE_FROM_ABI iter_type
2834   put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, long double __units) const {
2835     return do_put(__s, __intl, __iob, __fl, __units);
2836   }
2837
2838   _LIBCPP_HIDE_FROM_ABI iter_type
2839   put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, const string_type& __digits) const {
2840     return do_put(__s, __intl, __iob, __fl, __digits);
2841   }
2842
2843   static locale::id id;
2844
2845 protected:
2846   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~money_put() override {}
2847
2848   virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, long double __units) const;
2849   virtual iter_type
2850   do_put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, const string_type& __digits) const;
2851 };
2852
2853 template <class _CharT, class _OutputIterator>
2854 locale::id money_put<_CharT, _OutputIterator>::id;
2855
2856 template <class _CharT, class _OutputIterator>
2857 _OutputIterator money_put<_CharT, _OutputIterator>::do_put(
2858     iter_type __s, bool __intl, ios_base& __iob, char_type __fl, long double __units) const {
2859   // convert to char
2860   const size_t __bs = 100;
2861   char __buf[__bs];
2862   char* __bb = __buf;
2863   char_type __digits[__bs];
2864   char_type* __db = __digits;
2865   int __n         = snprintf(__bb, __bs, "%.0Lf", __units);
2866   unique_ptr<char, void (*)(void*)> __hn(nullptr, free);
2867   unique_ptr<char_type, void (*)(void*)> __hd(0, free);
2868   // secure memory for digit storage
2869   if (static_cast<size_t>(__n) > __bs - 1) {
2870     __n = __locale::__asprintf(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units);
2871     if (__n == -1)
2872       __throw_bad_alloc();
2873     __hn.reset(__bb);
2874     __hd.reset((char_type*)malloc(static_cast<size_t>(__n) * sizeof(char_type)));
2875     if (__hd == nullptr)
2876       __throw_bad_alloc();
2877     __db = __hd.get();
2878   }
2879   // gather info
2880   locale __loc                 = __iob.getloc();
2881   const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
2882   __ct.widen(__bb, __bb + __n, __db);
2883   bool __neg = __n > 0 && __bb[0] == '-';
2884   money_base::pattern __pat;
2885   char_type __dp;
2886   char_type __ts;
2887   string __grp;
2888   string_type __sym;
2889   string_type __sn;
2890   int __fd;
2891   this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
2892   // secure memory for formatting
2893   char_type __mbuf[__bs];
2894   char_type* __mb = __mbuf;
2895   unique_ptr<char_type, void (*)(void*)> __hw(0, free);
2896   size_t __exn = __n > __fd ? (static_cast<size_t>(__n) - static_cast<size_t>(__fd)) * 2 + __sn.size() + __sym.size() +
2897                                   static_cast<size_t>(__fd) + 1
2898                             : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
2899   if (__exn > __bs) {
2900     __hw.reset((char_type*)malloc(__exn * sizeof(char_type)));
2901     __mb = __hw.get();
2902     if (__mb == 0)
2903       __throw_bad_alloc();
2904   }
2905   // format
2906   char_type* __mi;
2907   char_type* __me;
2908   this->__format(
2909       __mb, __mi, __me, __iob.flags(), __db, __db + __n, __ct, __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
2910   return std::__pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
2911 }
2912
2913 template <class _CharT, class _OutputIterator>
2914 _OutputIterator money_put<_CharT, _OutputIterator>::do_put(
2915     iter_type __s, bool __intl, ios_base& __iob, char_type __fl, const string_type& __digits) const {
2916   // gather info
2917   locale __loc                 = __iob.getloc();
2918   const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
2919   bool __neg                   = __digits.size() > 0 && __digits[0] == __ct.widen('-');
2920   money_base::pattern __pat;
2921   char_type __dp;
2922   char_type __ts;
2923   string __grp;
2924   string_type __sym;
2925   string_type __sn;
2926   int __fd;
2927   this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
2928   // secure memory for formatting
2929   char_type __mbuf[100];
2930   char_type* __mb = __mbuf;
2931   unique_ptr<char_type, void (*)(void*)> __h(0, free);
2932   size_t __exn =
2933       static_cast<int>(__digits.size()) > __fd
2934           ? (__digits.size() - static_cast<size_t>(__fd)) * 2 + __sn.size() + __sym.size() + static_cast<size_t>(__fd) +
2935                 1
2936           : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
2937   if (__exn > 100) {
2938     __h.reset((char_type*)malloc(__exn * sizeof(char_type)));
2939     __mb = __h.get();
2940     if (__mb == 0)
2941       __throw_bad_alloc();
2942   }
2943   // format
2944   char_type* __mi;
2945   char_type* __me;
2946   this->__format(
2947       __mb,
2948       __mi,
2949       __me,
2950       __iob.flags(),
2951       __digits.data(),
2952       __digits.data() + __digits.size(),
2953       __ct,
2954       __neg,
2955       __pat,
2956       __dp,
2957       __ts,
2958       __grp,
2959       __sym,
2960       __sn,
2961       __fd);
2962   return std::__pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
2963 }
2964
2965 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<char>;
2966 #  if _LIBCPP_HAS_WIDE_CHARACTERS
2967 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<wchar_t>;
2968 #  endif
2969
2970 // messages
2971
2972 class _LIBCPP_EXPORTED_FROM_ABI messages_base {
2973 public:
2974   typedef intptr_t catalog;
2975
2976   _LIBCPP_HIDE_FROM_ABI messages_base() {}
2977 };
2978
2979 template <class _CharT>
2980 class _LIBCPP_TEMPLATE_VIS messages : public locale::facet, public messages_base {
2981 public:
2982   typedef _CharT char_type;
2983   typedef basic_string<_CharT> string_type;
2984
2985   _LIBCPP_HIDE_FROM_ABI explicit messages(size_t __refs = 0) : locale::facet(__refs) {}
2986
2987   _LIBCPP_HIDE_FROM_ABI catalog open(const basic_string<char>& __nm, const locale& __loc) const {
2988     return do_open(__nm, __loc);
2989   }
2990
2991   _LIBCPP_HIDE_FROM_ABI string_type get(catalog __c, int __set, int __msgid, const string_type& __dflt) const {
2992     return do_get(__c, __set, __msgid, __dflt);
2993   }
2994
2995   _LIBCPP_HIDE_FROM_ABI void close(catalog __c) const { do_close(__c); }
2996
2997   static locale::id id;
2998
2999 protected:
3000   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~messages() override {}
3001
3002   virtual catalog do_open(const basic_string<char>&, const locale&) const;
3003   virtual string_type do_get(catalog, int __set, int __msgid, const string_type& __dflt) const;
3004   virtual void do_close(catalog) const;
3005 };
3006
3007 template <class _CharT>
3008 locale::id messages<_CharT>::id;
3009
3010 template <class _CharT>
3011 typename messages<_CharT>::catalog messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const {
3012 #  if _LIBCPP_HAS_CATOPEN
3013   return (catalog)catopen(__nm.c_str(), NL_CAT_LOCALE);
3014 #  else  // !_LIBCPP_HAS_CATOPEN
3015   (void)__nm;
3016   return -1;
3017 #  endif // _LIBCPP_HAS_CATOPEN
3018 }
3019
3020 template <class _CharT>
3021 typename messages<_CharT>::string_type
3022 messages<_CharT>::do_get(catalog __c, int __set, int __msgid, const string_type& __dflt) const {
3023 #  if _LIBCPP_HAS_CATOPEN
3024   string __ndflt;
3025   __narrow_to_utf8<sizeof(char_type) * __CHAR_BIT__>()(
3026       std::back_inserter(__ndflt), __dflt.c_str(), __dflt.c_str() + __dflt.size());
3027   nl_catd __cat = (nl_catd)__c;
3028   static_assert(sizeof(catalog) >= sizeof(nl_catd), "Unexpected nl_catd type");
3029   char* __n = catgets(__cat, __set, __msgid, __ndflt.c_str());
3030   string_type __w;
3031   __widen_from_utf8<sizeof(char_type) * __CHAR_BIT__>()(std::back_inserter(__w), __n, __n + std::strlen(__n));
3032   return __w;
3033 #  else  // !_LIBCPP_HAS_CATOPEN
3034   (void)__c;
3035   (void)__set;
3036   (void)__msgid;
3037   return __dflt;
3038 #  endif // _LIBCPP_HAS_CATOPEN
3039 }
3040
3041 template <class _CharT>
3042 void messages<_CharT>::do_close(catalog __c) const {
3043 #  if _LIBCPP_HAS_CATOPEN
3044   catclose((nl_catd)__c);
3045 #  else  // !_LIBCPP_HAS_CATOPEN
3046   (void)__c;
3047 #  endif // _LIBCPP_HAS_CATOPEN
3048 }
3049
3050 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<char>;
3051 #  if _LIBCPP_HAS_WIDE_CHARACTERS
3052 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<wchar_t>;
3053 #  endif
3054
3055 template <class _CharT>
3056 class _LIBCPP_TEMPLATE_VIS messages_byname : public messages<_CharT> {
3057 public:
3058   typedef messages_base::catalog catalog;
3059   typedef basic_string<_CharT> string_type;
3060
3061   _LIBCPP_HIDE_FROM_ABI explicit messages_byname(const char*, size_t __refs = 0) : messages<_CharT>(__refs) {}
3062
3063   _LIBCPP_HIDE_FROM_ABI explicit messages_byname(const string&, size_t __refs = 0) : messages<_CharT>(__refs) {}
3064
3065 protected:
3066   _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~messages_byname() override {}
3067 };
3068
3069 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<char>;
3070 #  if _LIBCPP_HAS_WIDE_CHARACTERS
3071 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<wchar_t>;
3072 #  endif
3073
3074 #  if _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_WSTRING_CONVERT)
3075
3076 template <class _Codecvt,
3077           class _Elem      = wchar_t,
3078           class _WideAlloc = allocator<_Elem>,
3079           class _ByteAlloc = allocator<char> >
3080 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 wstring_convert {
3081 public:
3082   typedef basic_string<char, char_traits<char>, _ByteAlloc> byte_string;
3083   typedef basic_string<_Elem, char_traits<_Elem>, _WideAlloc> wide_string;
3084   typedef typename _Codecvt::state_type state_type;
3085   typedef typename wide_string::traits_type::int_type int_type;
3086
3087 private:
3088   byte_string __byte_err_string_;
3089   wide_string __wide_err_string_;
3090   _Codecvt* __cvtptr_;
3091   state_type __cvtstate_;
3092   size_t __cvtcount_;
3093
3094 public:
3095 #    ifndef _LIBCPP_CXX03_LANG
3096   _LIBCPP_HIDE_FROM_ABI wstring_convert() : wstring_convert(new _Codecvt) {}
3097   _LIBCPP_HIDE_FROM_ABI explicit wstring_convert(_Codecvt* __pcvt);
3098 #    else
3099   _LIBCPP_HIDE_FROM_ABI _LIBCPP_EXPLICIT_SINCE_CXX14 wstring_convert(_Codecvt* __pcvt = new _Codecvt);
3100 #    endif
3101
3102   _LIBCPP_HIDE_FROM_ABI wstring_convert(_Codecvt* __pcvt, state_type __state);
3103   _LIBCPP_EXPLICIT_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
3104   wstring_convert(const byte_string& __byte_err, const wide_string& __wide_err = wide_string());
3105 #    ifndef _LIBCPP_CXX03_LANG
3106   _LIBCPP_HIDE_FROM_ABI wstring_convert(wstring_convert&& __wc);
3107 #    endif
3108   _LIBCPP_HIDE_FROM_ABI ~wstring_convert();
3109
3110   wstring_convert(const wstring_convert& __wc)            = delete;
3111   wstring_convert& operator=(const wstring_convert& __wc) = delete;
3112
3113   _LIBCPP_HIDE_FROM_ABI wide_string from_bytes(char __byte) { return from_bytes(&__byte, &__byte + 1); }
3114   _LIBCPP_HIDE_FROM_ABI wide_string from_bytes(const char* __ptr) {
3115     return from_bytes(__ptr, __ptr + char_traits<char>::length(__ptr));
3116   }
3117   _LIBCPP_HIDE_FROM_ABI wide_string from_bytes(const byte_string& __str) {
3118     return from_bytes(__str.data(), __str.data() + __str.size());
3119   }
3120   _LIBCPP_HIDE_FROM_ABI wide_string from_bytes(const char* __first, const char* __last);
3121
3122   _LIBCPP_HIDE_FROM_ABI byte_string to_bytes(_Elem __wchar) { return to_bytes(&__wchar, &__wchar + 1); }
3123   _LIBCPP_HIDE_FROM_ABI byte_string to_bytes(const _Elem* __wptr) {
3124     return to_bytes(__wptr, __wptr + char_traits<_Elem>::length(__wptr));
3125   }
3126   _LIBCPP_HIDE_FROM_ABI byte_string to_bytes(const wide_string& __wstr) {
3127     return to_bytes(__wstr.data(), __wstr.data() + __wstr.size());
3128   }
3129   _LIBCPP_HIDE_FROM_ABI byte_string to_bytes(const _Elem* __first, const _Elem* __last);
3130
3131   _LIBCPP_HIDE_FROM_ABI size_t converted() const _NOEXCEPT { return __cvtcount_; }
3132   _LIBCPP_HIDE_FROM_ABI state_type state() const { return __cvtstate_; }
3133 };
3134
3135 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
3136 template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
3137 inline wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::wstring_convert(_Codecvt* __pcvt)
3138     : __cvtptr_(__pcvt), __cvtstate_(), __cvtcount_(0) {}
3139 _LIBCPP_SUPPRESS_DEPRECATED_POP
3140
3141 template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
3142 inline wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::wstring_convert(_Codecvt* __pcvt, state_type __state)
3143     : __cvtptr_(__pcvt), __cvtstate_(__state), __cvtcount_(0) {}
3144
3145 template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
3146 wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::wstring_convert(
3147     const byte_string& __byte_err, const wide_string& __wide_err)
3148     : __byte_err_string_(__byte_err), __wide_err_string_(__wide_err), __cvtstate_(), __cvtcount_(0) {
3149   __cvtptr_ = new _Codecvt;
3150 }
3151
3152 #    ifndef _LIBCPP_CXX03_LANG
3153
3154 template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
3155 inline wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::wstring_convert(wstring_convert&& __wc)
3156     : __byte_err_string_(std::move(__wc.__byte_err_string_)),
3157       __wide_err_string_(std::move(__wc.__wide_err_string_)),
3158       __cvtptr_(__wc.__cvtptr_),
3159       __cvtstate_(__wc.__cvtstate_),
3160       __cvtcount_(__wc.__cvtcount_) {
3161   __wc.__cvtptr_ = nullptr;
3162 }
3163
3164 #    endif // _LIBCPP_CXX03_LANG
3165
3166 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
3167 template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
3168 wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::~wstring_convert() {
3169   delete __cvtptr_;
3170 }
3171
3172 template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
3173 typename wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::wide_string
3174 wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::from_bytes(const char* __frm, const char* __frm_end) {
3175   _LIBCPP_SUPPRESS_DEPRECATED_POP
3176   __cvtcount_ = 0;
3177   if (__cvtptr_ != nullptr) {
3178     wide_string __ws(2 * (__frm_end - __frm), _Elem());
3179     if (__frm != __frm_end)
3180       __ws.resize(__ws.capacity());
3181     codecvt_base::result __r = codecvt_base::ok;
3182     state_type __st          = __cvtstate_;
3183     if (__frm != __frm_end) {
3184       _Elem* __to     = &__ws[0];
3185       _Elem* __to_end = __to + __ws.size();
3186       const char* __frm_nxt;
3187       do {
3188         _Elem* __to_nxt;
3189         __r = __cvtptr_->in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
3190         __cvtcount_ += __frm_nxt - __frm;
3191         if (__frm_nxt == __frm) {
3192           __r = codecvt_base::error;
3193         } else if (__r == codecvt_base::noconv) {
3194           __ws.resize(__to - &__ws[0]);
3195           // This only gets executed if _Elem is char
3196           __ws.append((const _Elem*)__frm, (const _Elem*)__frm_end);
3197           __frm = __frm_nxt;
3198           __r   = codecvt_base::ok;
3199         } else if (__r == codecvt_base::ok) {
3200           __ws.resize(__to_nxt - &__ws[0]);
3201           __frm = __frm_nxt;
3202         } else if (__r == codecvt_base::partial) {
3203           ptrdiff_t __s = __to_nxt - &__ws[0];
3204           __ws.resize(2 * __s);
3205           __to     = &__ws[0] + __s;
3206           __to_end = &__ws[0] + __ws.size();
3207           __frm    = __frm_nxt;
3208         }
3209       } while (__r == codecvt_base::partial && __frm_nxt < __frm_end);
3210     }
3211     if (__r == codecvt_base::ok)
3212       return __ws;
3213   }
3214
3215   if (__wide_err_string_.empty())
3216     __throw_range_error("wstring_convert: from_bytes error");
3217
3218   return __wide_err_string_;
3219 }
3220
3221 template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
3222 typename wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::byte_string
3223 wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::to_bytes(const _Elem* __frm, const _Elem* __frm_end) {
3224   __cvtcount_ = 0;
3225   if (__cvtptr_ != nullptr) {
3226     byte_string __bs(2 * (__frm_end - __frm), char());
3227     if (__frm != __frm_end)
3228       __bs.resize(__bs.capacity());
3229     codecvt_base::result __r = codecvt_base::ok;
3230     state_type __st          = __cvtstate_;
3231     if (__frm != __frm_end) {
3232       char* __to     = &__bs[0];
3233       char* __to_end = __to + __bs.size();
3234       const _Elem* __frm_nxt;
3235       do {
3236         char* __to_nxt;
3237         __r = __cvtptr_->out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
3238         __cvtcount_ += __frm_nxt - __frm;
3239         if (__frm_nxt == __frm) {
3240           __r = codecvt_base::error;
3241         } else if (__r == codecvt_base::noconv) {
3242           __bs.resize(__to - &__bs[0]);
3243           // This only gets executed if _Elem is char
3244           __bs.append((const char*)__frm, (const char*)__frm_end);
3245           __frm = __frm_nxt;
3246           __r   = codecvt_base::ok;
3247         } else if (__r == codecvt_base::ok) {
3248           __bs.resize(__to_nxt - &__bs[0]);
3249           __frm = __frm_nxt;
3250         } else if (__r == codecvt_base::partial) {
3251           ptrdiff_t __s = __to_nxt - &__bs[0];
3252           __bs.resize(2 * __s);
3253           __to     = &__bs[0] + __s;
3254           __to_end = &__bs[0] + __bs.size();
3255           __frm    = __frm_nxt;
3256         }
3257       } while (__r == codecvt_base::partial && __frm_nxt < __frm_end);
3258     }
3259     if (__r == codecvt_base::ok) {
3260       size_t __s = __bs.size();
3261       __bs.resize(__bs.capacity());
3262       char* __to     = &__bs[0] + __s;
3263       char* __to_end = __to + __bs.size();
3264       do {
3265         char* __to_nxt;
3266         __r = __cvtptr_->unshift(__st, __to, __to_end, __to_nxt);
3267         if (__r == codecvt_base::noconv) {
3268           __bs.resize(__to - &__bs[0]);
3269           __r = codecvt_base::ok;
3270         } else if (__r == codecvt_base::ok) {
3271           __bs.resize(__to_nxt - &__bs[0]);
3272         } else if (__r == codecvt_base::partial) {
3273           ptrdiff_t __sp = __to_nxt - &__bs[0];
3274           __bs.resize(2 * __sp);
3275           __to     = &__bs[0] + __sp;
3276           __to_end = &__bs[0] + __bs.size();
3277         }
3278       } while (__r == codecvt_base::partial);
3279       if (__r == codecvt_base::ok)
3280         return __bs;
3281     }
3282   }
3283
3284   if (__byte_err_string_.empty())
3285     __throw_range_error("wstring_convert: to_bytes error");
3286
3287   return __byte_err_string_;
3288 }
3289
3290 template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> >
3291 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 wbuffer_convert : public basic_streambuf<_Elem, _Tr> {
3292 public:
3293   // types:
3294   typedef _Elem char_type;
3295   typedef _Tr traits_type;
3296   typedef typename traits_type::int_type int_type;
3297   typedef typename traits_type::pos_type pos_type;
3298   typedef typename traits_type::off_type off_type;
3299   typedef typename _Codecvt::state_type state_type;
3300
3301 private:
3302   char* __extbuf_;
3303   const char* __extbufnext_;
3304   const char* __extbufend_;
3305   char __extbuf_min_[8];
3306   size_t __ebs_;
3307   char_type* __intbuf_;
3308   size_t __ibs_;
3309   streambuf* __bufptr_;
3310   _Codecvt* __cv_;
3311   state_type __st_;
3312   ios_base::openmode __cm_;
3313   bool __owns_eb_;
3314   bool __owns_ib_;
3315   bool __always_noconv_;
3316
3317 public:
3318 #    ifndef _LIBCPP_CXX03_LANG
3319   _LIBCPP_HIDE_FROM_ABI wbuffer_convert() : wbuffer_convert(nullptr) {}
3320   explicit _LIBCPP_HIDE_FROM_ABI
3321   wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt = new _Codecvt, state_type __state = state_type());
3322 #    else
3323   _LIBCPP_EXPLICIT_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
3324   wbuffer_convert(streambuf* __bytebuf = nullptr, _Codecvt* __pcvt = new _Codecvt, state_type __state = state_type());
3325 #    endif
3326
3327   _LIBCPP_HIDE_FROM_ABI ~wbuffer_convert();
3328
3329   _LIBCPP_HIDE_FROM_ABI streambuf* rdbuf() const { return __bufptr_; }
3330   _LIBCPP_HIDE_FROM_ABI streambuf* rdbuf(streambuf* __bytebuf) {
3331     streambuf* __r = __bufptr_;
3332     __bufptr_      = __bytebuf;
3333     return __r;
3334   }
3335
3336   wbuffer_convert(const wbuffer_convert&)            = delete;
3337   wbuffer_convert& operator=(const wbuffer_convert&) = delete;
3338
3339   _LIBCPP_HIDE_FROM_ABI state_type state() const { return __st_; }
3340
3341 protected:
3342   _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual int_type underflow();
3343   _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual int_type pbackfail(int_type __c = traits_type::eof());
3344   _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual int_type overflow(int_type __c = traits_type::eof());
3345   _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n);
3346   _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual pos_type
3347   seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __wch = ios_base::in | ios_base::out);
3348   _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual pos_type
3349   seekpos(pos_type __sp, ios_base::openmode __wch = ios_base::in | ios_base::out);
3350   _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual int sync();
3351
3352 private:
3353   _LIBCPP_HIDE_FROM_ABI_VIRTUAL bool __read_mode();
3354   _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __write_mode();
3355   _LIBCPP_HIDE_FROM_ABI_VIRTUAL wbuffer_convert* __close();
3356 };
3357
3358 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
3359 template <class _Codecvt, class _Elem, class _Tr>
3360 wbuffer_convert<_Codecvt, _Elem, _Tr>::wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt, state_type __state)
3361     : __extbuf_(nullptr),
3362       __extbufnext_(nullptr),
3363       __extbufend_(nullptr),
3364       __ebs_(0),
3365       __intbuf_(0),
3366       __ibs_(0),
3367       __bufptr_(__bytebuf),
3368       __cv_(__pcvt),
3369       __st_(__state),
3370       __cm_(0),
3371       __owns_eb_(false),
3372       __owns_ib_(false),
3373       __always_noconv_(__cv_ ? __cv_->always_noconv() : false) {
3374   setbuf(0, 4096);
3375 }
3376
3377 template <class _Codecvt, class _Elem, class _Tr>
3378 wbuffer_convert<_Codecvt, _Elem, _Tr>::~wbuffer_convert() {
3379   __close();
3380   delete __cv_;
3381   if (__owns_eb_)
3382     delete[] __extbuf_;
3383   if (__owns_ib_)
3384     delete[] __intbuf_;
3385 }
3386
3387 template <class _Codecvt, class _Elem, class _Tr>
3388 typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow() {
3389   _LIBCPP_SUPPRESS_DEPRECATED_POP
3390   if (__cv_ == 0 || __bufptr_ == nullptr)
3391     return traits_type::eof();
3392   bool __initial = __read_mode();
3393   char_type __1buf;
3394   if (this->gptr() == 0)
3395     this->setg(&__1buf, &__1buf + 1, &__1buf + 1);
3396   const size_t __unget_sz = __initial ? 0 : std::min<size_t>((this->egptr() - this->eback()) / 2, 4);
3397   int_type __c            = traits_type::eof();
3398   if (this->gptr() == this->egptr()) {
3399     std::memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type));
3400     if (__always_noconv_) {
3401       streamsize __nmemb = static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz);
3402       __nmemb            = __bufptr_->sgetn((char*)this->eback() + __unget_sz, __nmemb);
3403       if (__nmemb != 0) {
3404         this->setg(this->eback(), this->eback() + __unget_sz, this->eback() + __unget_sz + __nmemb);
3405         __c = *this->gptr();
3406       }
3407     } else {
3408       if (__extbufend_ != __extbufnext_) {
3409         _LIBCPP_ASSERT_NON_NULL(__extbufnext_ != nullptr, "underflow moving from nullptr");
3410         _LIBCPP_ASSERT_NON_NULL(__extbuf_ != nullptr, "underflow moving into nullptr");
3411         std::memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
3412       }
3413       __extbufnext_      = __extbuf_ + (__extbufend_ - __extbufnext_);
3414       __extbufend_       = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
3415       streamsize __nmemb = std::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
3416                                     static_cast<streamsize>(__extbufend_ - __extbufnext_));
3417       codecvt_base::result __r;
3418       // FIXME: Do we ever need to restore the state here?
3419       // state_type __svs = __st_;
3420       streamsize __nr = __bufptr_->sgetn(const_cast<char*>(__extbufnext_), __nmemb);
3421       if (__nr != 0) {
3422         __extbufend_ = __extbufnext_ + __nr;
3423         char_type* __inext;
3424         __r = __cv_->in(
3425             __st_, __extbuf_, __extbufend_, __extbufnext_, this->eback() + __unget_sz, this->egptr(), __inext);
3426         if (__r == codecvt_base::noconv) {
3427           this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, (char_type*)const_cast<char*>(__extbufend_));
3428           __c = *this->gptr();
3429         } else if (__inext != this->eback() + __unget_sz) {
3430           this->setg(this->eback(), this->eback() + __unget_sz, __inext);
3431           __c = *this->gptr();
3432         }
3433       }
3434     }
3435   } else
3436     __c = *this->gptr();
3437   if (this->eback() == &__1buf)
3438     this->setg(0, 0, 0);
3439   return __c;
3440 }
3441
3442 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
3443 template <class _Codecvt, class _Elem, class _Tr>
3444 typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
3445 wbuffer_convert<_Codecvt, _Elem, _Tr>::pbackfail(int_type __c) {
3446   _LIBCPP_SUPPRESS_DEPRECATED_POP
3447   if (__cv_ != 0 && __bufptr_ && this->eback() < this->gptr()) {
3448     if (traits_type::eq_int_type(__c, traits_type::eof())) {
3449       this->gbump(-1);
3450       return traits_type::not_eof(__c);
3451     }
3452     if (traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])) {
3453       this->gbump(-1);
3454       *this->gptr() = traits_type::to_char_type(__c);
3455       return __c;
3456     }
3457   }
3458   return traits_type::eof();
3459 }
3460
3461 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
3462 template <class _Codecvt, class _Elem, class _Tr>
3463 typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type wbuffer_convert<_Codecvt, _Elem, _Tr>::overflow(int_type __c) {
3464   _LIBCPP_SUPPRESS_DEPRECATED_POP
3465   if (__cv_ == 0 || !__bufptr_)
3466     return traits_type::eof();
3467   __write_mode();
3468   char_type __1buf;
3469   char_type* __pb_save  = this->pbase();
3470   char_type* __epb_save = this->epptr();
3471   if (!traits_type::eq_int_type(__c, traits_type::eof())) {
3472     if (this->pptr() == 0)
3473       this->setp(&__1buf, &__1buf + 1);
3474     *this->pptr() = traits_type::to_char_type(__c);
3475     this->pbump(1);
3476   }
3477   if (this->pptr() != this->pbase()) {
3478     if (__always_noconv_) {
3479       streamsize __nmemb = static_cast<streamsize>(this->pptr() - this->pbase());
3480       if (__bufptr_->sputn((const char*)this->pbase(), __nmemb) != __nmemb)
3481         return traits_type::eof();
3482     } else {
3483       char* __extbe = __extbuf_;
3484       codecvt_base::result __r;
3485       do {
3486         const char_type* __e;
3487         __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, __extbuf_, __extbuf_ + __ebs_, __extbe);
3488         if (__e == this->pbase())
3489           return traits_type::eof();
3490         if (__r == codecvt_base::noconv) {
3491           streamsize __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
3492           if (__bufptr_->sputn((const char*)this->pbase(), __nmemb) != __nmemb)
3493             return traits_type::eof();
3494         } else if (__r == codecvt_base::ok || __r == codecvt_base::partial) {
3495           streamsize __nmemb = static_cast<size_t>(__extbe - __extbuf_);
3496           if (__bufptr_->sputn(__extbuf_, __nmemb) != __nmemb)
3497             return traits_type::eof();
3498           if (__r == codecvt_base::partial) {
3499             this->setp(const_cast<char_type*>(__e), this->pptr());
3500             this->__pbump(this->epptr() - this->pbase());
3501           }
3502         } else
3503           return traits_type::eof();
3504       } while (__r == codecvt_base::partial);
3505     }
3506     this->setp(__pb_save, __epb_save);
3507   }
3508   return traits_type::not_eof(__c);
3509 }
3510
3511 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
3512 template <class _Codecvt, class _Elem, class _Tr>
3513 basic_streambuf<_Elem, _Tr>* wbuffer_convert<_Codecvt, _Elem, _Tr>::setbuf(char_type* __s, streamsize __n) {
3514   _LIBCPP_SUPPRESS_DEPRECATED_POP
3515   this->setg(0, 0, 0);
3516   this->setp(0, 0);
3517   if (__owns_eb_)
3518     delete[] __extbuf_;
3519   if (__owns_ib_)
3520     delete[] __intbuf_;
3521   __ebs_ = __n;
3522   if (__ebs_ > sizeof(__extbuf_min_)) {
3523     if (__always_noconv_ && __s) {
3524       __extbuf_  = (char*)__s;
3525       __owns_eb_ = false;
3526     } else {
3527       __extbuf_  = new char[__ebs_];
3528       __owns_eb_ = true;
3529     }
3530   } else {
3531     __extbuf_  = __extbuf_min_;
3532     __ebs_     = sizeof(__extbuf_min_);
3533     __owns_eb_ = false;
3534   }
3535   if (!__always_noconv_) {
3536     __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_));
3537     if (__s && __ibs_ >= sizeof(__extbuf_min_)) {
3538       __intbuf_  = __s;
3539       __owns_ib_ = false;
3540     } else {
3541       __intbuf_  = new char_type[__ibs_];
3542       __owns_ib_ = true;
3543     }
3544   } else {
3545     __ibs_     = 0;
3546     __intbuf_  = 0;
3547     __owns_ib_ = false;
3548   }
3549   return this;
3550 }
3551
3552 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
3553 template <class _Codecvt, class _Elem, class _Tr>
3554 typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type
3555 wbuffer_convert<_Codecvt, _Elem, _Tr>::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __om) {
3556   int __width = __cv_->encoding();
3557   if (__cv_ == 0 || !__bufptr_ || (__width <= 0 && __off != 0) || sync())
3558     return pos_type(off_type(-1));
3559   // __width > 0 || __off == 0, now check __way
3560   if (__way != ios_base::beg && __way != ios_base::cur && __way != ios_base::end)
3561     return pos_type(off_type(-1));
3562   pos_type __r = __bufptr_->pubseekoff(__width * __off, __way, __om);
3563   __r.state(__st_);
3564   return __r;
3565 }
3566
3567 template <class _Codecvt, class _Elem, class _Tr>
3568 typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type
3569 wbuffer_convert<_Codecvt, _Elem, _Tr>::seekpos(pos_type __sp, ios_base::openmode __wch) {
3570   if (__cv_ == 0 || !__bufptr_ || sync())
3571     return pos_type(off_type(-1));
3572   if (__bufptr_->pubseekpos(__sp, __wch) == pos_type(off_type(-1)))
3573     return pos_type(off_type(-1));
3574   return __sp;
3575 }
3576
3577 template <class _Codecvt, class _Elem, class _Tr>
3578 int wbuffer_convert<_Codecvt, _Elem, _Tr>::sync() {
3579   _LIBCPP_SUPPRESS_DEPRECATED_POP
3580   if (__cv_ == 0 || !__bufptr_)
3581     return 0;
3582   if (__cm_ & ios_base::out) {
3583     if (this->pptr() != this->pbase())
3584       if (overflow() == traits_type::eof())
3585         return -1;
3586     codecvt_base::result __r;
3587     do {
3588       char* __extbe;
3589       __r                = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe);
3590       streamsize __nmemb = static_cast<streamsize>(__extbe - __extbuf_);
3591       if (__bufptr_->sputn(__extbuf_, __nmemb) != __nmemb)
3592         return -1;
3593     } while (__r == codecvt_base::partial);
3594     if (__r == codecvt_base::error)
3595       return -1;
3596     if (__bufptr_->pubsync())
3597       return -1;
3598   } else if (__cm_ & ios_base::in) {
3599     off_type __c;
3600     if (__always_noconv_)
3601       __c = this->egptr() - this->gptr();
3602     else {
3603       int __width = __cv_->encoding();
3604       __c         = __extbufend_ - __extbufnext_;
3605       if (__width > 0)
3606         __c += __width * (this->egptr() - this->gptr());
3607       else {
3608         if (this->gptr() != this->egptr()) {
3609           std::reverse(this->gptr(), this->egptr());
3610           codecvt_base::result __r;
3611           const char_type* __e = this->gptr();
3612           char* __extbe;
3613           do {
3614             __r = __cv_->out(__st_, __e, this->egptr(), __e, __extbuf_, __extbuf_ + __ebs_, __extbe);
3615             switch (__r) {
3616             case codecvt_base::noconv:
3617               __c += this->egptr() - this->gptr();
3618               break;
3619             case codecvt_base::ok:
3620             case codecvt_base::partial:
3621               __c += __extbe - __extbuf_;
3622               break;
3623             default:
3624               return -1;
3625             }
3626           } while (__r == codecvt_base::partial);
3627         }
3628       }
3629     }
3630     if (__bufptr_->pubseekoff(-__c, ios_base::cur, __cm_) == pos_type(off_type(-1)))
3631       return -1;
3632     this->setg(0, 0, 0);
3633     __cm_ = 0;
3634   }
3635   return 0;
3636 }
3637
3638 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
3639 template <class _Codecvt, class _Elem, class _Tr>
3640 bool wbuffer_convert<_Codecvt, _Elem, _Tr>::__read_mode() {
3641   if (!(__cm_ & ios_base::in)) {
3642     this->setp(0, 0);
3643     if (__always_noconv_)
3644       this->setg((char_type*)__extbuf_, (char_type*)__extbuf_ + __ebs_, (char_type*)__extbuf_ + __ebs_);
3645     else
3646       this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_);
3647     __cm_ = ios_base::in;
3648     return true;
3649   }
3650   return false;
3651 }
3652
3653 template <class _Codecvt, class _Elem, class _Tr>
3654 void wbuffer_convert<_Codecvt, _Elem, _Tr>::__write_mode() {
3655   if (!(__cm_ & ios_base::out)) {
3656     this->setg(0, 0, 0);
3657     if (__ebs_ > sizeof(__extbuf_min_)) {
3658       if (__always_noconv_)
3659         this->setp((char_type*)__extbuf_, (char_type*)__extbuf_ + (__ebs_ - 1));
3660       else
3661         this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1));
3662     } else
3663       this->setp(0, 0);
3664     __cm_ = ios_base::out;
3665   }
3666 }
3667
3668 template <class _Codecvt, class _Elem, class _Tr>
3669 wbuffer_convert<_Codecvt, _Elem, _Tr>* wbuffer_convert<_Codecvt, _Elem, _Tr>::__close() {
3670   wbuffer_convert* __rt = nullptr;
3671   if (__cv_ != nullptr && __bufptr_ != nullptr) {
3672     __rt = this;
3673     if ((__cm_ & ios_base::out) && sync())
3674       __rt = nullptr;
3675   }
3676   return __rt;
3677 }
3678
3679 _LIBCPP_SUPPRESS_DEPRECATED_POP
3680
3681 #  endif // _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_WSTRING_CONVERT)
3682
3683 _LIBCPP_END_NAMESPACE_STD
3684
3685 _LIBCPP_POP_MACROS
3686
3687 // NOLINTEND(libcpp-robust-against-adl)
3688
3689 #endif // _LIBCPP_HAS_LOCALIZATION
3690
3691 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
3692 #  include <atomic>
3693 #  include <concepts>
3694 #  include <cstdarg>
3695 #  include <iterator>
3696 #  include <mutex>
3697 #  include <stdexcept>
3698 #  include <type_traits>
3699 #  include <typeinfo>
3700 #endif
3701
3702 #endif // _LIBCPP_LOCALE