include/locale

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