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