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