Mercurial > hg > CbC > CbC_llvm

comparison libcxx/include/__locale @ 150:1d019706d866

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM10
author anatofuz
date Thu, 13 Feb 2020 15:10:13 +0900
parents
children 0572611fdcc8
comparison
equal deleted inserted replaced
147:c2174574ed3a 150:1d019706d866
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 #include <__config>
14 #include <string>
15 #include <memory>
16 #include <utility>
17 #include <mutex>
18 #include <cstdint>
19 #include <cctype>
20 #include <locale.h>
21 #if defined(_LIBCPP_MSVCRT_LIKE)
22 # include <cstring>
23 # include <support/win32/locale_win32.h>
24 #elif defined(_AIX)
25 # include <support/ibm/xlocale.h>
26 #elif defined(__ANDROID__)
27 # include <support/android/locale_bionic.h>
28 #elif defined(__sun__)
29 # include <xlocale.h>
30 # include <support/solaris/xlocale.h>
31 #elif defined(_NEWLIB_VERSION)
32 # include <support/newlib/xlocale.h>
33 #elif (defined(__APPLE__) || defined(__FreeBSD__) \
34 || defined(__EMSCRIPTEN__) || defined(__IBMCPP__))
35 # include <xlocale.h>
36 #elif defined(__Fuchsia__)
37 # include <support/fuchsia/xlocale.h>
38 #elif defined(__wasi__)
39 // WASI libc uses musl's locales support.
40 # include <support/musl/xlocale.h>
41 #elif defined(_LIBCPP_HAS_MUSL_LIBC)
42 # include <support/musl/xlocale.h>
43 #endif
44
45 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
46 #pragma GCC system_header
47 #endif
48
49 _LIBCPP_BEGIN_NAMESPACE_STD
50
51 #if !defined(_LIBCPP_LOCALE__L_EXTENSIONS)
52 struct __libcpp_locale_guard {
53 _LIBCPP_INLINE_VISIBILITY
54 __libcpp_locale_guard(locale_t& __loc) : __old_loc_(uselocale(__loc)) {}
55
56 _LIBCPP_INLINE_VISIBILITY
57 ~__libcpp_locale_guard() {
58 if (__old_loc_)
59 uselocale(__old_loc_);
60 }
61
62 locale_t __old_loc_;
63 private:
64 __libcpp_locale_guard(__libcpp_locale_guard const&);
65 __libcpp_locale_guard& operator=(__libcpp_locale_guard const&);
66 };
67 #elif defined(_LIBCPP_MSVCRT_LIKE)
68 struct __libcpp_locale_guard {
69 __libcpp_locale_guard(locale_t __l) :
70 __status(_configthreadlocale(_ENABLE_PER_THREAD_LOCALE)) {
71 // Setting the locale can be expensive even when the locale given is
72 // already the current locale, so do an explicit check to see if the
73 // current locale is already the one we want.
74 const char* __lc = __setlocale(nullptr);
75 // If every category is the same, the locale string will simply be the
76 // locale name, otherwise it will be a semicolon-separated string listing
77 // each category. In the second case, we know at least one category won't
78 // be what we want, so we only have to check the first case.
79 if (strcmp(__l.__get_locale(), __lc) != 0) {
80 __locale_all = _strdup(__lc);
81 if (__locale_all == nullptr)
82 __throw_bad_alloc();
83 __setlocale(__l.__get_locale());
84 }
85 }
86 ~__libcpp_locale_guard() {
87 // The CRT documentation doesn't explicitly say, but setlocale() does the
88 // right thing when given a semicolon-separated list of locale settings
89 // for the different categories in the same format as returned by
90 // setlocale(LC_ALL, nullptr).
91 if (__locale_all != nullptr) {
92 __setlocale(__locale_all);
93 free(__locale_all);
94 }
95 _configthreadlocale(__status);
96 }
97 static const char* __setlocale(const char* __locale) {
98 const char* __new_locale = setlocale(LC_ALL, __locale);
99 if (__new_locale == nullptr)
100 __throw_bad_alloc();
101 return __new_locale;
102 }
103 int __status;
104 char* __locale_all = nullptr;
105 };
106 #endif
107
108
109 class _LIBCPP_TYPE_VIS locale;
110
111 template <class _Facet>
112 _LIBCPP_INLINE_VISIBILITY
113 bool
114 has_facet(const locale&) _NOEXCEPT;
115
116 template <class _Facet>
117 _LIBCPP_INLINE_VISIBILITY
118 const _Facet&
119 use_facet(const locale&);
120
121 class _LIBCPP_TYPE_VIS locale
122 {
123 public:
124 // types:
125 class _LIBCPP_TYPE_VIS facet;
126 class _LIBCPP_TYPE_VIS id;
127
128 typedef int category;
129 _LIBCPP_AVAILABILITY_LOCALE_CATEGORY
130 static const category // values assigned here are for exposition only
131 none = 0,
132 collate = LC_COLLATE_MASK,
133 ctype = LC_CTYPE_MASK,
134 monetary = LC_MONETARY_MASK,
135 numeric = LC_NUMERIC_MASK,
136 time = LC_TIME_MASK,
137 messages = LC_MESSAGES_MASK,
138 all = collate | ctype | monetary | numeric | time | messages;
139
140 // construct/copy/destroy:
141 locale() _NOEXCEPT;
142 locale(const locale&) _NOEXCEPT;
143 explicit locale(const char*);
144 explicit locale(const string&);
145 locale(const locale&, const char*, category);
146 locale(const locale&, const string&, category);
147 template <class _Facet>
148 _LIBCPP_INLINE_VISIBILITY locale(const locale&, _Facet*);
149 locale(const locale&, const locale&, category);
150
151 ~locale();
152
153 const locale& operator=(const locale&) _NOEXCEPT;
154
155 template <class _Facet>
156 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
157 locale combine(const locale&) const;
158
159 // locale operations:
160 string name() const;
161 bool operator==(const locale&) const;
162 bool operator!=(const locale& __y) const {return !(*this == __y);}
163 template <class _CharT, class _Traits, class _Allocator>
164 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
165 bool operator()(const basic_string<_CharT, _Traits, _Allocator>&,
166 const basic_string<_CharT, _Traits, _Allocator>&) const;
167
168 // global locale objects:
169 static locale global(const locale&);
170 static const locale& classic();
171
172 private:
173 class __imp;
174 __imp* __locale_;
175
176 void __install_ctor(const locale&, facet*, long);
177 static locale& __global();
178 bool has_facet(id&) const;
179 const facet* use_facet(id&) const;
180
181 template <class _Facet> friend bool has_facet(const locale&) _NOEXCEPT;
182 template <class _Facet> friend const _Facet& use_facet(const locale&);
183 };
184
185 class _LIBCPP_TYPE_VIS locale::facet
186 : public __shared_count
187 {
188 protected:
189 _LIBCPP_INLINE_VISIBILITY
190 explicit facet(size_t __refs = 0)
191 : __shared_count(static_cast<long>(__refs)-1) {}
192
193 virtual ~facet();
194
195 // facet(const facet&) = delete; // effectively done in __shared_count
196 // void operator=(const facet&) = delete;
197 private:
198 virtual void __on_zero_shared() _NOEXCEPT;
199 };
200
201 class _LIBCPP_TYPE_VIS locale::id
202 {
203 once_flag __flag_;
204 int32_t __id_;
205
206 static int32_t __next_id;
207 public:
208 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR id() :__id_(0) {}
209 private:
210 void __init();
211 void operator=(const id&); // = delete;
212 id(const id&); // = delete;
213 public: // only needed for tests
214 long __get();
215
216 friend class locale;
217 friend class locale::__imp;
218 };
219
220 template <class _Facet>
221 inline _LIBCPP_INLINE_VISIBILITY
222 locale::locale(const locale& __other, _Facet* __f)
223 {
224 __install_ctor(__other, __f, __f ? __f->id.__get() : 0);
225 }
226
227 template <class _Facet>
228 locale
229 locale::combine(const locale& __other) const
230 {
231 if (!_VSTD::has_facet<_Facet>(__other))
232 __throw_runtime_error("locale::combine: locale missing facet");
233
234 return locale(*this, &const_cast<_Facet&>(_VSTD::use_facet<_Facet>(__other)));
235 }
236
237 template <class _Facet>
238 inline _LIBCPP_INLINE_VISIBILITY
239 bool
240 has_facet(const locale& __l) _NOEXCEPT
241 {
242 return __l.has_facet(_Facet::id);
243 }
244
245 template <class _Facet>
246 inline _LIBCPP_INLINE_VISIBILITY
247 const _Facet&
248 use_facet(const locale& __l)
249 {
250 return static_cast<const _Facet&>(*__l.use_facet(_Facet::id));
251 }
252
253 // template <class _CharT> class collate;
254
255 template <class _CharT>
256 class _LIBCPP_TEMPLATE_VIS collate
257 : public locale::facet
258 {
259 public:
260 typedef _CharT char_type;
261 typedef basic_string<char_type> string_type;
262
263 _LIBCPP_INLINE_VISIBILITY
264 explicit collate(size_t __refs = 0)
265 : locale::facet(__refs) {}
266
267 _LIBCPP_INLINE_VISIBILITY
268 int compare(const char_type* __lo1, const char_type* __hi1,
269 const char_type* __lo2, const char_type* __hi2) const
270 {
271 return do_compare(__lo1, __hi1, __lo2, __hi2);
272 }
273
274 // FIXME(EricWF): The _LIBCPP_ALWAYS_INLINE is needed on Windows to work
275 // around a dllimport bug that expects an external instantiation.
276 _LIBCPP_INLINE_VISIBILITY
277 _LIBCPP_ALWAYS_INLINE
278 string_type transform(const char_type* __lo, const char_type* __hi) const
279 {
280 return do_transform(__lo, __hi);
281 }
282
283 _LIBCPP_INLINE_VISIBILITY
284 long hash(const char_type* __lo, const char_type* __hi) const
285 {
286 return do_hash(__lo, __hi);
287 }
288
289 static locale::id id;
290
291 protected:
292 ~collate();
293 virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
294 const char_type* __lo2, const char_type* __hi2) const;
295 virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const
296 {return string_type(__lo, __hi);}
297 virtual long do_hash(const char_type* __lo, const char_type* __hi) const;
298 };
299
300 template <class _CharT> locale::id collate<_CharT>::id;
301
302 template <class _CharT>
303 collate<_CharT>::~collate()
304 {
305 }
306
307 template <class _CharT>
308 int
309 collate<_CharT>::do_compare(const char_type* __lo1, const char_type* __hi1,
310 const char_type* __lo2, const char_type* __hi2) const
311 {
312 for (; __lo2 != __hi2; ++__lo1, ++__lo2)
313 {
314 if (__lo1 == __hi1 || *__lo1 < *__lo2)
315 return -1;
316 if (*__lo2 < *__lo1)
317 return 1;
318 }
319 return __lo1 != __hi1;
320 }
321
322 template <class _CharT>
323 long
324 collate<_CharT>::do_hash(const char_type* __lo, const char_type* __hi) const
325 {
326 size_t __h = 0;
327 const size_t __sr = __CHAR_BIT__ * sizeof(size_t) - 8;
328 const size_t __mask = size_t(0xF) << (__sr + 4);
329 for(const char_type* __p = __lo; __p != __hi; ++__p)
330 {
331 __h = (__h << 4) + static_cast<size_t>(*__p);
332 size_t __g = __h & __mask;
333 __h ^= __g | (__g >> __sr);
334 }
335 return static_cast<long>(__h);
336 }
337
338 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS collate<char>)
339 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS collate<wchar_t>)
340
341 // template <class CharT> class collate_byname;
342
343 template <class _CharT> class _LIBCPP_TEMPLATE_VIS collate_byname;
344
345 template <>
346 class _LIBCPP_TYPE_VIS collate_byname<char>
347 : public collate<char>
348 {
349 locale_t __l;
350 public:
351 typedef char char_type;
352 typedef basic_string<char_type> string_type;
353
354 explicit collate_byname(const char* __n, size_t __refs = 0);
355 explicit collate_byname(const string& __n, size_t __refs = 0);
356
357 protected:
358 ~collate_byname();
359 virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
360 const char_type* __lo2, const char_type* __hi2) const;
361 virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const;
362 };
363
364 template <>
365 class _LIBCPP_TYPE_VIS collate_byname<wchar_t>
366 : public collate<wchar_t>
367 {
368 locale_t __l;
369 public:
370 typedef wchar_t char_type;
371 typedef basic_string<char_type> string_type;
372
373 explicit collate_byname(const char* __n, size_t __refs = 0);
374 explicit collate_byname(const string& __n, size_t __refs = 0);
375
376 protected:
377 ~collate_byname();
378
379 virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
380 const char_type* __lo2, const char_type* __hi2) const;
381 virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const;
382 };
383
384 template <class _CharT, class _Traits, class _Allocator>
385 bool
386 locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
387 const basic_string<_CharT, _Traits, _Allocator>& __y) const
388 {
389 return _VSTD::use_facet<_VSTD::collate<_CharT> >(*this).compare(
390 __x.data(), __x.data() + __x.size(),
391 __y.data(), __y.data() + __y.size()) < 0;
392 }
393
394 // template <class charT> class ctype
395
396 class _LIBCPP_TYPE_VIS ctype_base
397 {
398 public:
399 #if defined(__GLIBC__)
400 typedef unsigned short mask;
401 static const mask space = _ISspace;
402 static const mask print = _ISprint;
403 static const mask cntrl = _IScntrl;
404 static const mask upper = _ISupper;
405 static const mask lower = _ISlower;
406 static const mask alpha = _ISalpha;
407 static const mask digit = _ISdigit;
408 static const mask punct = _ISpunct;
409 static const mask xdigit = _ISxdigit;
410 static const mask blank = _ISblank;
411 #if defined(__mips__)
412 static const mask __regex_word = static_cast<mask>(_ISbit(15));
413 #else
414 static const mask __regex_word = 0x80;
415 #endif
416 #elif defined(_LIBCPP_MSVCRT_LIKE)
417 typedef unsigned short mask;
418 static const mask space = _SPACE;
419 static const mask print = _BLANK|_PUNCT|_ALPHA|_DIGIT;
420 static const mask cntrl = _CONTROL;
421 static const mask upper = _UPPER;
422 static const mask lower = _LOWER;
423 static const mask alpha = _ALPHA;
424 static const mask digit = _DIGIT;
425 static const mask punct = _PUNCT;
426 static const mask xdigit = _HEX;
427 static const mask blank = _BLANK;
428 static const mask __regex_word = 0x80;
429 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
430 #elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__)
431 # ifdef __APPLE__
432 typedef __uint32_t mask;
433 # elif defined(__FreeBSD__)
434 typedef unsigned long mask;
435 # elif defined(__EMSCRIPTEN__) || defined(__NetBSD__)
436 typedef unsigned short mask;
437 # endif
438 static const mask space = _CTYPE_S;
439 static const mask print = _CTYPE_R;
440 static const mask cntrl = _CTYPE_C;
441 static const mask upper = _CTYPE_U;
442 static const mask lower = _CTYPE_L;
443 static const mask alpha = _CTYPE_A;
444 static const mask digit = _CTYPE_D;
445 static const mask punct = _CTYPE_P;
446 static const mask xdigit = _CTYPE_X;
447
448 # if defined(__NetBSD__)
449 static const mask blank = _CTYPE_BL;
450 // NetBSD defines classes up to 0x2000
451 // see sys/ctype_bits.h, _CTYPE_Q
452 static const mask __regex_word = 0x8000;
453 # else
454 static const mask blank = _CTYPE_B;
455 static const mask __regex_word = 0x80;
456 # endif
457 #elif defined(__sun__) || defined(_AIX)
458 typedef unsigned int mask;
459 static const mask space = _ISSPACE;
460 static const mask print = _ISPRINT;
461 static const mask cntrl = _ISCNTRL;
462 static const mask upper = _ISUPPER;
463 static const mask lower = _ISLOWER;
464 static const mask alpha = _ISALPHA;
465 static const mask digit = _ISDIGIT;
466 static const mask punct = _ISPUNCT;
467 static const mask xdigit = _ISXDIGIT;
468 static const mask blank = _ISBLANK;
469 static const mask __regex_word = 0x80;
470 #elif defined(_NEWLIB_VERSION)
471 // Same type as Newlib's _ctype_ array in newlib/libc/include/ctype.h.
472 typedef char mask;
473 static const mask space = _S;
474 static const mask print = _P | _U | _L | _N | _B;
475 static const mask cntrl = _C;
476 static const mask upper = _U;
477 static const mask lower = _L;
478 static const mask alpha = _U | _L;
479 static const mask digit = _N;
480 static const mask punct = _P;
481 static const mask xdigit = _X | _N;
482 static const mask blank = _B;
483 static const mask __regex_word = 0x80;
484 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
485 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
486 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT
487 #else
488 typedef unsigned long mask;
489 static const mask space = 1<<0;
490 static const mask print = 1<<1;
491 static const mask cntrl = 1<<2;
492 static const mask upper = 1<<3;
493 static const mask lower = 1<<4;
494 static const mask alpha = 1<<5;
495 static const mask digit = 1<<6;
496 static const mask punct = 1<<7;
497 static const mask xdigit = 1<<8;
498 static const mask blank = 1<<9;
499 static const mask __regex_word = 1<<10;
500 #endif
501 static const mask alnum = alpha | digit;
502 static const mask graph = alnum | punct;
503
504 _LIBCPP_INLINE_VISIBILITY ctype_base() {}
505 };
506
507 template <class _CharT> class _LIBCPP_TEMPLATE_VIS ctype;
508
509 template <>
510 class _LIBCPP_TYPE_VIS ctype<wchar_t>
511 : public locale::facet,
512 public ctype_base
513 {
514 public:
515 typedef wchar_t char_type;
516
517 _LIBCPP_INLINE_VISIBILITY
518 explicit ctype(size_t __refs = 0)
519 : locale::facet(__refs) {}
520
521 _LIBCPP_INLINE_VISIBILITY
522 bool is(mask __m, char_type __c) const
523 {
524 return do_is(__m, __c);
525 }
526
527 _LIBCPP_INLINE_VISIBILITY
528 const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const
529 {
530 return do_is(__low, __high, __vec);
531 }
532
533 _LIBCPP_INLINE_VISIBILITY
534 const char_type* scan_is(mask __m, const char_type* __low, const char_type* __high) const
535 {
536 return do_scan_is(__m, __low, __high);
537 }
538
539 _LIBCPP_INLINE_VISIBILITY
540 const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const
541 {
542 return do_scan_not(__m, __low, __high);
543 }
544
545 _LIBCPP_INLINE_VISIBILITY
546 char_type toupper(char_type __c) const
547 {
548 return do_toupper(__c);
549 }
550
551 _LIBCPP_INLINE_VISIBILITY
552 const char_type* toupper(char_type* __low, const char_type* __high) const
553 {
554 return do_toupper(__low, __high);
555 }
556
557 _LIBCPP_INLINE_VISIBILITY
558 char_type tolower(char_type __c) const
559 {
560 return do_tolower(__c);
561 }
562
563 _LIBCPP_INLINE_VISIBILITY
564 const char_type* tolower(char_type* __low, const char_type* __high) const
565 {
566 return do_tolower(__low, __high);
567 }
568
569 _LIBCPP_INLINE_VISIBILITY
570 char_type widen(char __c) const
571 {
572 return do_widen(__c);
573 }
574
575 _LIBCPP_INLINE_VISIBILITY
576 const char* widen(const char* __low, const char* __high, char_type* __to) const
577 {
578 return do_widen(__low, __high, __to);
579 }
580
581 _LIBCPP_INLINE_VISIBILITY
582 char narrow(char_type __c, char __dfault) const
583 {
584 return do_narrow(__c, __dfault);
585 }
586
587 _LIBCPP_INLINE_VISIBILITY
588 const char_type* narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const
589 {
590 return do_narrow(__low, __high, __dfault, __to);
591 }
592
593 static locale::id id;
594
595 protected:
596 ~ctype();
597 virtual bool do_is(mask __m, char_type __c) const;
598 virtual const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const;
599 virtual const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const;
600 virtual const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const;
601 virtual char_type do_toupper(char_type) const;
602 virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
603 virtual char_type do_tolower(char_type) const;
604 virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
605 virtual char_type do_widen(char) const;
606 virtual const char* do_widen(const char* __low, const char* __high, char_type* __dest) const;
607 virtual char do_narrow(char_type, char __dfault) const;
608 virtual const char_type* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const;
609 };
610
611 template <>
612 class _LIBCPP_TYPE_VIS ctype<char>
613 : public locale::facet, public ctype_base
614 {
615 const mask* __tab_;
616 bool __del_;
617 public:
618 typedef char char_type;
619
620 explicit ctype(const mask* __tab = 0, bool __del = false, size_t __refs = 0);
621
622 _LIBCPP_INLINE_VISIBILITY
623 bool is(mask __m, char_type __c) const
624 {
625 return isascii(__c) ? (__tab_[static_cast<int>(__c)] & __m) !=0 : false;
626 }
627
628 _LIBCPP_INLINE_VISIBILITY
629 const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const
630 {
631 for (; __low != __high; ++__low, ++__vec)
632 *__vec = isascii(*__low) ? __tab_[static_cast<int>(*__low)] : 0;
633 return __low;
634 }
635
636 _LIBCPP_INLINE_VISIBILITY
637 const char_type* scan_is (mask __m, const char_type* __low, const char_type* __high) const
638 {
639 for (; __low != __high; ++__low)
640 if (isascii(*__low) && (__tab_[static_cast<int>(*__low)] & __m))
641 break;
642 return __low;
643 }
644
645 _LIBCPP_INLINE_VISIBILITY
646 const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const
647 {
648 for (; __low != __high; ++__low)
649 if (!(isascii(*__low) && (__tab_[static_cast<int>(*__low)] & __m)))
650 break;
651 return __low;
652 }
653
654 _LIBCPP_INLINE_VISIBILITY
655 char_type toupper(char_type __c) const
656 {
657 return do_toupper(__c);
658 }
659
660 _LIBCPP_INLINE_VISIBILITY
661 const char_type* toupper(char_type* __low, const char_type* __high) const
662 {
663 return do_toupper(__low, __high);
664 }
665
666 _LIBCPP_INLINE_VISIBILITY
667 char_type tolower(char_type __c) const
668 {
669 return do_tolower(__c);
670 }
671
672 _LIBCPP_INLINE_VISIBILITY
673 const char_type* tolower(char_type* __low, const char_type* __high) const
674 {
675 return do_tolower(__low, __high);
676 }
677
678 _LIBCPP_INLINE_VISIBILITY
679 char_type widen(char __c) const
680 {
681 return do_widen(__c);
682 }
683
684 _LIBCPP_INLINE_VISIBILITY
685 const char* widen(const char* __low, const char* __high, char_type* __to) const
686 {
687 return do_widen(__low, __high, __to);
688 }
689
690 _LIBCPP_INLINE_VISIBILITY
691 char narrow(char_type __c, char __dfault) const
692 {
693 return do_narrow(__c, __dfault);
694 }
695
696 _LIBCPP_INLINE_VISIBILITY
697 const char* narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const
698 {
699 return do_narrow(__low, __high, __dfault, __to);
700 }
701
702 static locale::id id;
703
704 #ifdef _CACHED_RUNES
705 static const size_t table_size = _CACHED_RUNES;
706 #else
707 static const size_t table_size = 256; // FIXME: Don't hardcode this.
708 #endif
709 _LIBCPP_INLINE_VISIBILITY const mask* table() const _NOEXCEPT {return __tab_;}
710 static const mask* classic_table() _NOEXCEPT;
711 #if defined(__GLIBC__) || defined(__EMSCRIPTEN__)
712 static const int* __classic_upper_table() _NOEXCEPT;
713 static const int* __classic_lower_table() _NOEXCEPT;
714 #endif
715 #if defined(__NetBSD__)
716 static const short* __classic_upper_table() _NOEXCEPT;
717 static const short* __classic_lower_table() _NOEXCEPT;
718 #endif
719
720 protected:
721 ~ctype();
722 virtual char_type do_toupper(char_type __c) const;
723 virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
724 virtual char_type do_tolower(char_type __c) const;
725 virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
726 virtual char_type do_widen(char __c) const;
727 virtual const char* do_widen(const char* __low, const char* __high, char_type* __to) const;
728 virtual char do_narrow(char_type __c, char __dfault) const;
729 virtual const char* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const;
730 };
731
732 // template <class CharT> class ctype_byname;
733
734 template <class _CharT> class _LIBCPP_TEMPLATE_VIS ctype_byname;
735
736 template <>
737 class _LIBCPP_TYPE_VIS ctype_byname<char>
738 : public ctype<char>
739 {
740 locale_t __l;
741
742 public:
743 explicit ctype_byname(const char*, size_t = 0);
744 explicit ctype_byname(const string&, size_t = 0);
745
746 protected:
747 ~ctype_byname();
748 virtual char_type do_toupper(char_type) const;
749 virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
750 virtual char_type do_tolower(char_type) const;
751 virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
752 };
753
754 template <>
755 class _LIBCPP_TYPE_VIS ctype_byname<wchar_t>
756 : public ctype<wchar_t>
757 {
758 locale_t __l;
759
760 public:
761 explicit ctype_byname(const char*, size_t = 0);
762 explicit ctype_byname(const string&, size_t = 0);
763
764 protected:
765 ~ctype_byname();
766 virtual bool do_is(mask __m, char_type __c) const;
767 virtual const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const;
768 virtual const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const;
769 virtual const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const;
770 virtual char_type do_toupper(char_type) const;
771 virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
772 virtual char_type do_tolower(char_type) const;
773 virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
774 virtual char_type do_widen(char) const;
775 virtual const char* do_widen(const char* __low, const char* __high, char_type* __dest) const;
776 virtual char do_narrow(char_type, char __dfault) const;
777 virtual const char_type* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const;
778 };
779
780 template <class _CharT>
781 inline _LIBCPP_INLINE_VISIBILITY
782 bool
783 isspace(_CharT __c, const locale& __loc)
784 {
785 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c);
786 }
787
788 template <class _CharT>
789 inline _LIBCPP_INLINE_VISIBILITY
790 bool
791 isprint(_CharT __c, const locale& __loc)
792 {
793 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c);
794 }
795
796 template <class _CharT>
797 inline _LIBCPP_INLINE_VISIBILITY
798 bool
799 iscntrl(_CharT __c, const locale& __loc)
800 {
801 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c);
802 }
803
804 template <class _CharT>
805 inline _LIBCPP_INLINE_VISIBILITY
806 bool
807 isupper(_CharT __c, const locale& __loc)
808 {
809 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c);
810 }
811
812 template <class _CharT>
813 inline _LIBCPP_INLINE_VISIBILITY
814 bool
815 islower(_CharT __c, const locale& __loc)
816 {
817 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c);
818 }
819
820 template <class _CharT>
821 inline _LIBCPP_INLINE_VISIBILITY
822 bool
823 isalpha(_CharT __c, const locale& __loc)
824 {
825 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c);
826 }
827
828 template <class _CharT>
829 inline _LIBCPP_INLINE_VISIBILITY
830 bool
831 isdigit(_CharT __c, const locale& __loc)
832 {
833 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c);
834 }
835
836 template <class _CharT>
837 inline _LIBCPP_INLINE_VISIBILITY
838 bool
839 ispunct(_CharT __c, const locale& __loc)
840 {
841 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c);
842 }
843
844 template <class _CharT>
845 inline _LIBCPP_INLINE_VISIBILITY
846 bool
847 isxdigit(_CharT __c, const locale& __loc)
848 {
849 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c);
850 }
851
852 template <class _CharT>
853 inline _LIBCPP_INLINE_VISIBILITY
854 bool
855 isalnum(_CharT __c, const locale& __loc)
856 {
857 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c);
858 }
859
860 template <class _CharT>
861 inline _LIBCPP_INLINE_VISIBILITY
862 bool
863 isgraph(_CharT __c, const locale& __loc)
864 {
865 return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c);
866 }
867
868 template <class _CharT>
869 inline _LIBCPP_INLINE_VISIBILITY
870 _CharT
871 toupper(_CharT __c, const locale& __loc)
872 {
873 return use_facet<ctype<_CharT> >(__loc).toupper(__c);
874 }
875
876 template <class _CharT>
877 inline _LIBCPP_INLINE_VISIBILITY
878 _CharT
879 tolower(_CharT __c, const locale& __loc)
880 {
881 return use_facet<ctype<_CharT> >(__loc).tolower(__c);
882 }
883
884 // codecvt_base
885
886 class _LIBCPP_TYPE_VIS codecvt_base
887 {
888 public:
889 _LIBCPP_INLINE_VISIBILITY codecvt_base() {}
890 enum result {ok, partial, error, noconv};
891 };
892
893 // template <class internT, class externT, class stateT> class codecvt;
894
895 template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_TEMPLATE_VIS codecvt;
896
897 // template <> class codecvt<char, char, mbstate_t>
898
899 template <>
900 class _LIBCPP_TYPE_VIS codecvt<char, char, mbstate_t>
901 : public locale::facet,
902 public codecvt_base
903 {
904 public:
905 typedef char intern_type;
906 typedef char extern_type;
907 typedef mbstate_t state_type;
908
909 _LIBCPP_INLINE_VISIBILITY
910 explicit codecvt(size_t __refs = 0)
911 : locale::facet(__refs) {}
912
913 _LIBCPP_INLINE_VISIBILITY
914 result out(state_type& __st,
915 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
916 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
917 {
918 return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
919 }
920
921 _LIBCPP_INLINE_VISIBILITY
922 result unshift(state_type& __st,
923 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
924 {
925 return do_unshift(__st, __to, __to_end, __to_nxt);
926 }
927
928 _LIBCPP_INLINE_VISIBILITY
929 result in(state_type& __st,
930 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
931 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
932 {
933 return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
934 }
935
936 _LIBCPP_INLINE_VISIBILITY
937 int encoding() const _NOEXCEPT
938 {
939 return do_encoding();
940 }
941
942 _LIBCPP_INLINE_VISIBILITY
943 bool always_noconv() const _NOEXCEPT
944 {
945 return do_always_noconv();
946 }
947
948 _LIBCPP_INLINE_VISIBILITY
949 int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
950 {
951 return do_length(__st, __frm, __end, __mx);
952 }
953
954 _LIBCPP_INLINE_VISIBILITY
955 int max_length() const _NOEXCEPT
956 {
957 return do_max_length();
958 }
959
960 static locale::id id;
961
962 protected:
963 _LIBCPP_INLINE_VISIBILITY
964 explicit codecvt(const char*, size_t __refs = 0)
965 : locale::facet(__refs) {}
966
967 ~codecvt();
968
969 virtual result do_out(state_type& __st,
970 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
971 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
972 virtual result do_in(state_type& __st,
973 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
974 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
975 virtual result do_unshift(state_type& __st,
976 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
977 virtual int do_encoding() const _NOEXCEPT;
978 virtual bool do_always_noconv() const _NOEXCEPT;
979 virtual int do_length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
980 virtual int do_max_length() const _NOEXCEPT;
981 };
982
983 // template <> class codecvt<wchar_t, char, mbstate_t>
984
985 template <>
986 class _LIBCPP_TYPE_VIS codecvt<wchar_t, char, mbstate_t>
987 : public locale::facet,
988 public codecvt_base
989 {
990 locale_t __l;
991 public:
992 typedef wchar_t intern_type;
993 typedef char extern_type;
994 typedef mbstate_t state_type;
995
996 explicit codecvt(size_t __refs = 0);
997
998 _LIBCPP_INLINE_VISIBILITY
999 result out(state_type& __st,
1000 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
1001 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
1002 {
1003 return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
1004 }
1005
1006 _LIBCPP_INLINE_VISIBILITY
1007 result unshift(state_type& __st,
1008 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
1009 {
1010 return do_unshift(__st, __to, __to_end, __to_nxt);
1011 }
1012
1013 _LIBCPP_INLINE_VISIBILITY
1014 result in(state_type& __st,
1015 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
1016 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
1017 {
1018 return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
1019 }
1020
1021 _LIBCPP_INLINE_VISIBILITY
1022 int encoding() const _NOEXCEPT
1023 {
1024 return do_encoding();
1025 }
1026
1027 _LIBCPP_INLINE_VISIBILITY
1028 bool always_noconv() const _NOEXCEPT
1029 {
1030 return do_always_noconv();
1031 }
1032
1033 _LIBCPP_INLINE_VISIBILITY
1034 int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
1035 {
1036 return do_length(__st, __frm, __end, __mx);
1037 }
1038
1039 _LIBCPP_INLINE_VISIBILITY
1040 int max_length() const _NOEXCEPT
1041 {
1042 return do_max_length();
1043 }
1044
1045 static locale::id id;
1046
1047 protected:
1048 explicit codecvt(const char*, size_t __refs = 0);
1049
1050 ~codecvt();
1051
1052 virtual result do_out(state_type& __st,
1053 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
1054 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
1055 virtual result do_in(state_type& __st,
1056 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
1057 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
1058 virtual result do_unshift(state_type& __st,
1059 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
1060 virtual int do_encoding() const _NOEXCEPT;
1061 virtual bool do_always_noconv() const _NOEXCEPT;
1062 virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
1063 virtual int do_max_length() const _NOEXCEPT;
1064 };
1065
1066 // template <> class codecvt<char16_t, char, mbstate_t>
1067
1068 template <>
1069 class _LIBCPP_TYPE_VIS codecvt<char16_t, char, mbstate_t>
1070 : public locale::facet,
1071 public codecvt_base
1072 {
1073 public:
1074 typedef char16_t intern_type;
1075 typedef char extern_type;
1076 typedef mbstate_t state_type;
1077
1078 _LIBCPP_INLINE_VISIBILITY
1079 explicit codecvt(size_t __refs = 0)
1080 : locale::facet(__refs) {}
1081
1082 _LIBCPP_INLINE_VISIBILITY
1083 result out(state_type& __st,
1084 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
1085 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
1086 {
1087 return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
1088 }
1089
1090 _LIBCPP_INLINE_VISIBILITY
1091 result unshift(state_type& __st,
1092 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
1093 {
1094 return do_unshift(__st, __to, __to_end, __to_nxt);
1095 }
1096
1097 _LIBCPP_INLINE_VISIBILITY
1098 result in(state_type& __st,
1099 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
1100 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
1101 {
1102 return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
1103 }
1104
1105 _LIBCPP_INLINE_VISIBILITY
1106 int encoding() const _NOEXCEPT
1107 {
1108 return do_encoding();
1109 }
1110
1111 _LIBCPP_INLINE_VISIBILITY
1112 bool always_noconv() const _NOEXCEPT
1113 {
1114 return do_always_noconv();
1115 }
1116
1117 _LIBCPP_INLINE_VISIBILITY
1118 int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
1119 {
1120 return do_length(__st, __frm, __end, __mx);
1121 }
1122
1123 _LIBCPP_INLINE_VISIBILITY
1124 int max_length() const _NOEXCEPT
1125 {
1126 return do_max_length();
1127 }
1128
1129 static locale::id id;
1130
1131 protected:
1132 _LIBCPP_INLINE_VISIBILITY
1133 explicit codecvt(const char*, size_t __refs = 0)
1134 : locale::facet(__refs) {}
1135
1136 ~codecvt();
1137
1138 virtual result do_out(state_type& __st,
1139 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
1140 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
1141 virtual result do_in(state_type& __st,
1142 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
1143 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
1144 virtual result do_unshift(state_type& __st,
1145 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
1146 virtual int do_encoding() const _NOEXCEPT;
1147 virtual bool do_always_noconv() const _NOEXCEPT;
1148 virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
1149 virtual int do_max_length() const _NOEXCEPT;
1150 };
1151
1152 // template <> class codecvt<char32_t, char, mbstate_t>
1153
1154 template <>
1155 class _LIBCPP_TYPE_VIS codecvt<char32_t, char, mbstate_t>
1156 : public locale::facet,
1157 public codecvt_base
1158 {
1159 public:
1160 typedef char32_t intern_type;
1161 typedef char extern_type;
1162 typedef mbstate_t state_type;
1163
1164 _LIBCPP_INLINE_VISIBILITY
1165 explicit codecvt(size_t __refs = 0)
1166 : locale::facet(__refs) {}
1167
1168 _LIBCPP_INLINE_VISIBILITY
1169 result out(state_type& __st,
1170 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
1171 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
1172 {
1173 return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
1174 }
1175
1176 _LIBCPP_INLINE_VISIBILITY
1177 result unshift(state_type& __st,
1178 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
1179 {
1180 return do_unshift(__st, __to, __to_end, __to_nxt);
1181 }
1182
1183 _LIBCPP_INLINE_VISIBILITY
1184 result in(state_type& __st,
1185 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
1186 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
1187 {
1188 return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
1189 }
1190
1191 _LIBCPP_INLINE_VISIBILITY
1192 int encoding() const _NOEXCEPT
1193 {
1194 return do_encoding();
1195 }
1196
1197 _LIBCPP_INLINE_VISIBILITY
1198 bool always_noconv() const _NOEXCEPT
1199 {
1200 return do_always_noconv();
1201 }
1202
1203 _LIBCPP_INLINE_VISIBILITY
1204 int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
1205 {
1206 return do_length(__st, __frm, __end, __mx);
1207 }
1208
1209 _LIBCPP_INLINE_VISIBILITY
1210 int max_length() const _NOEXCEPT
1211 {
1212 return do_max_length();
1213 }
1214
1215 static locale::id id;
1216
1217 protected:
1218 _LIBCPP_INLINE_VISIBILITY
1219 explicit codecvt(const char*, size_t __refs = 0)
1220 : locale::facet(__refs) {}
1221
1222 ~codecvt();
1223
1224 virtual result do_out(state_type& __st,
1225 const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
1226 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
1227 virtual result do_in(state_type& __st,
1228 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
1229 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
1230 virtual result do_unshift(state_type& __st,
1231 extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
1232 virtual int do_encoding() const _NOEXCEPT;
1233 virtual bool do_always_noconv() const _NOEXCEPT;
1234 virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
1235 virtual int do_max_length() const _NOEXCEPT;
1236 };
1237
1238 // template <class _InternT, class _ExternT, class _StateT> class codecvt_byname
1239
1240 template <class _InternT, class _ExternT, class _StateT>
1241 class _LIBCPP_TEMPLATE_VIS codecvt_byname
1242 : public codecvt<_InternT, _ExternT, _StateT>
1243 {
1244 public:
1245 _LIBCPP_INLINE_VISIBILITY
1246 explicit codecvt_byname(const char* __nm, size_t __refs = 0)
1247 : codecvt<_InternT, _ExternT, _StateT>(__nm, __refs) {}
1248 _LIBCPP_INLINE_VISIBILITY
1249 explicit codecvt_byname(const string& __nm, size_t __refs = 0)
1250 : codecvt<_InternT, _ExternT, _StateT>(__nm.c_str(), __refs) {}
1251 protected:
1252 ~codecvt_byname();
1253 };
1254
1255 template <class _InternT, class _ExternT, class _StateT>
1256 codecvt_byname<_InternT, _ExternT, _StateT>::~codecvt_byname()
1257 {
1258 }
1259
1260 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char, char, mbstate_t>)
1261 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<wchar_t, char, mbstate_t>)
1262 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char16_t, char, mbstate_t>)
1263 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char32_t, char, mbstate_t>)
1264
1265 template <size_t _Np>
1266 struct __narrow_to_utf8
1267 {
1268 template <class _OutputIterator, class _CharT>
1269 _OutputIterator
1270 operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const;
1271 };
1272
1273 template <>
1274 struct __narrow_to_utf8<8>
1275 {
1276 template <class _OutputIterator, class _CharT>
1277 _LIBCPP_INLINE_VISIBILITY
1278 _OutputIterator
1279 operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
1280 {
1281 for (; __wb < __we; ++__wb, ++__s)
1282 *__s = *__wb;
1283 return __s;
1284 }
1285 };
1286
1287 template <>
1288 struct _LIBCPP_TEMPLATE_VIS __narrow_to_utf8<16>
1289 : public codecvt<char16_t, char, mbstate_t>
1290 {
1291 _LIBCPP_INLINE_VISIBILITY
1292 __narrow_to_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}
1293
1294 _LIBCPP_EXPORTED_FROM_ABI ~__narrow_to_utf8();
1295
1296 template <class _OutputIterator, class _CharT>
1297 _LIBCPP_INLINE_VISIBILITY
1298 _OutputIterator
1299 operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
1300 {
1301 result __r = ok;
1302 mbstate_t __mb;
1303 while (__wb < __we && __r != error)
1304 {
1305 const int __sz = 32;
1306 char __buf[__sz];
1307 char* __bn;
1308 const char16_t* __wn = (const char16_t*)__wb;
1309 __r = do_out(__mb, (const char16_t*)__wb, (const char16_t*)__we, __wn,
1310 __buf, __buf+__sz, __bn);
1311 if (__r == codecvt_base::error || __wn == (const char16_t*)__wb)
1312 __throw_runtime_error("locale not supported");
1313 for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
1314 *__s = *__p;
1315 __wb = (const _CharT*)__wn;
1316 }
1317 return __s;
1318 }
1319 };
1320
1321 template <>
1322 struct _LIBCPP_TEMPLATE_VIS __narrow_to_utf8<32>
1323 : public codecvt<char32_t, char, mbstate_t>
1324 {
1325 _LIBCPP_INLINE_VISIBILITY
1326 __narrow_to_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}
1327
1328 _LIBCPP_EXPORTED_FROM_ABI ~__narrow_to_utf8();
1329
1330 template <class _OutputIterator, class _CharT>
1331 _LIBCPP_INLINE_VISIBILITY
1332 _OutputIterator
1333 operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
1334 {
1335 result __r = ok;
1336 mbstate_t __mb;
1337 while (__wb < __we && __r != error)
1338 {
1339 const int __sz = 32;
1340 char __buf[__sz];
1341 char* __bn;
1342 const char32_t* __wn = (const char32_t*)__wb;
1343 __r = do_out(__mb, (const char32_t*)__wb, (const char32_t*)__we, __wn,
1344 __buf, __buf+__sz, __bn);
1345 if (__r == codecvt_base::error || __wn == (const char32_t*)__wb)
1346 __throw_runtime_error("locale not supported");
1347 for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
1348 *__s = *__p;
1349 __wb = (const _CharT*)__wn;
1350 }
1351 return __s;
1352 }
1353 };
1354
1355 template <size_t _Np>
1356 struct __widen_from_utf8
1357 {
1358 template <class _OutputIterator>
1359 _OutputIterator
1360 operator()(_OutputIterator __s, const char* __nb, const char* __ne) const;
1361 };
1362
1363 template <>
1364 struct __widen_from_utf8<8>
1365 {
1366 template <class _OutputIterator>
1367 _LIBCPP_INLINE_VISIBILITY
1368 _OutputIterator
1369 operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
1370 {
1371 for (; __nb < __ne; ++__nb, ++__s)
1372 *__s = *__nb;
1373 return __s;
1374 }
1375 };
1376
1377 template <>
1378 struct _LIBCPP_TEMPLATE_VIS __widen_from_utf8<16>
1379 : public codecvt<char16_t, char, mbstate_t>
1380 {
1381 _LIBCPP_INLINE_VISIBILITY
1382 __widen_from_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}
1383
1384 _LIBCPP_EXPORTED_FROM_ABI ~__widen_from_utf8();
1385
1386 template <class _OutputIterator>
1387 _LIBCPP_INLINE_VISIBILITY
1388 _OutputIterator
1389 operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
1390 {
1391 result __r = ok;
1392 mbstate_t __mb;
1393 while (__nb < __ne && __r != error)
1394 {
1395 const int __sz = 32;
1396 char16_t __buf[__sz];
1397 char16_t* __bn;
1398 const char* __nn = __nb;
1399 __r = do_in(__mb, __nb, __ne - __nb > __sz ? __nb+__sz : __ne, __nn,
1400 __buf, __buf+__sz, __bn);
1401 if (__r == codecvt_base::error || __nn == __nb)
1402 __throw_runtime_error("locale not supported");
1403 for (const char16_t* __p = __buf; __p < __bn; ++__p, ++__s)
1404 *__s = (wchar_t)*__p;
1405 __nb = __nn;
1406 }
1407 return __s;
1408 }
1409 };
1410
1411 template <>
1412 struct _LIBCPP_TEMPLATE_VIS __widen_from_utf8<32>
1413 : public codecvt<char32_t, char, mbstate_t>
1414 {
1415 _LIBCPP_INLINE_VISIBILITY
1416 __widen_from_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}
1417
1418 _LIBCPP_EXPORTED_FROM_ABI ~__widen_from_utf8();
1419
1420 template <class _OutputIterator>
1421 _LIBCPP_INLINE_VISIBILITY
1422 _OutputIterator
1423 operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
1424 {
1425 result __r = ok;
1426 mbstate_t __mb;
1427 while (__nb < __ne && __r != error)
1428 {
1429 const int __sz = 32;
1430 char32_t __buf[__sz];
1431 char32_t* __bn;
1432 const char* __nn = __nb;
1433 __r = do_in(__mb, __nb, __ne - __nb > __sz ? __nb+__sz : __ne, __nn,
1434 __buf, __buf+__sz, __bn);
1435 if (__r == codecvt_base::error || __nn == __nb)
1436 __throw_runtime_error("locale not supported");
1437 for (const char32_t* __p = __buf; __p < __bn; ++__p, ++__s)
1438 *__s = (wchar_t)*__p;
1439 __nb = __nn;
1440 }
1441 return __s;
1442 }
1443 };
1444
1445 // template <class charT> class numpunct
1446
1447 template <class _CharT> class _LIBCPP_TEMPLATE_VIS numpunct;
1448
1449 template <>
1450 class _LIBCPP_TYPE_VIS numpunct<char>
1451 : public locale::facet
1452 {
1453 public:
1454 typedef char char_type;
1455 typedef basic_string<char_type> string_type;
1456
1457 explicit numpunct(size_t __refs = 0);
1458
1459 _LIBCPP_INLINE_VISIBILITY char_type decimal_point() const {return do_decimal_point();}
1460 _LIBCPP_INLINE_VISIBILITY char_type thousands_sep() const {return do_thousands_sep();}
1461 _LIBCPP_INLINE_VISIBILITY string grouping() const {return do_grouping();}
1462 _LIBCPP_INLINE_VISIBILITY string_type truename() const {return do_truename();}
1463 _LIBCPP_INLINE_VISIBILITY string_type falsename() const {return do_falsename();}
1464
1465 static locale::id id;
1466
1467 protected:
1468 ~numpunct();
1469 virtual char_type do_decimal_point() const;
1470 virtual char_type do_thousands_sep() const;
1471 virtual string do_grouping() const;
1472 virtual string_type do_truename() const;
1473 virtual string_type do_falsename() const;
1474
1475 char_type __decimal_point_;
1476 char_type __thousands_sep_;
1477 string __grouping_;
1478 };
1479
1480 template <>
1481 class _LIBCPP_TYPE_VIS numpunct<wchar_t>
1482 : public locale::facet
1483 {
1484 public:
1485 typedef wchar_t char_type;
1486 typedef basic_string<char_type> string_type;
1487
1488 explicit numpunct(size_t __refs = 0);
1489
1490 _LIBCPP_INLINE_VISIBILITY char_type decimal_point() const {return do_decimal_point();}
1491 _LIBCPP_INLINE_VISIBILITY char_type thousands_sep() const {return do_thousands_sep();}
1492 _LIBCPP_INLINE_VISIBILITY string grouping() const {return do_grouping();}
1493 _LIBCPP_INLINE_VISIBILITY string_type truename() const {return do_truename();}
1494 _LIBCPP_INLINE_VISIBILITY string_type falsename() const {return do_falsename();}
1495
1496 static locale::id id;
1497
1498 protected:
1499 ~numpunct();
1500 virtual char_type do_decimal_point() const;
1501 virtual char_type do_thousands_sep() const;
1502 virtual string do_grouping() const;
1503 virtual string_type do_truename() const;
1504 virtual string_type do_falsename() const;
1505
1506 char_type __decimal_point_;
1507 char_type __thousands_sep_;
1508 string __grouping_;
1509 };
1510
1511 // template <class charT> class numpunct_byname
1512
1513 template <class _CharT> class _LIBCPP_TEMPLATE_VIS numpunct_byname;
1514
1515 template <>
1516 class _LIBCPP_TYPE_VIS numpunct_byname<char>
1517 : public numpunct<char>
1518 {
1519 public:
1520 typedef char char_type;
1521 typedef basic_string<char_type> string_type;
1522
1523 explicit numpunct_byname(const char* __nm, size_t __refs = 0);
1524 explicit numpunct_byname(const string& __nm, size_t __refs = 0);
1525
1526 protected:
1527 ~numpunct_byname();
1528
1529 private:
1530 void __init(const char*);
1531 };
1532
1533 template <>
1534 class _LIBCPP_TYPE_VIS numpunct_byname<wchar_t>
1535 : public numpunct<wchar_t>
1536 {
1537 public:
1538 typedef wchar_t char_type;
1539 typedef basic_string<char_type> string_type;
1540
1541 explicit numpunct_byname(const char* __nm, size_t __refs = 0);
1542 explicit numpunct_byname(const string& __nm, size_t __refs = 0);
1543
1544 protected:
1545 ~numpunct_byname();
1546
1547 private:
1548 void __init(const char*);
1549 };
1550
1551 _LIBCPP_END_NAMESPACE_STD
1552
1553 #endif // _LIBCPP___LOCALE