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